repo stringlengths 5 92 | file_url stringlengths 80 287 | file_path stringlengths 5 197 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:37:27 2026-01-04 17:58:21 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/errors.rb | lib/rukawa/errors.rb | module Rukawa
class DependencyUnsatisfied < StandardError; end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/overview.rb | lib/rukawa/overview.rb | module Rukawa
module Overview
class << self
def list_job_net(with_jobs: false)
header = ["Job", "Desc"]
header << "Dependencies" if with_jobs
table = Terminal::Table.new headings: header do |t|
JobNet.descendants.each do |job_net|
list_table_row(t, job_net, with_jobs: with_jobs)
end
end
puts table
end
def list_job
header = ["Job", "Desc"]
table = Terminal::Table.new headings: header do |t|
Job.descendants.each do |job|
row = [Paint[job.name, :bold, :underline], job.desc]
t << row
end
end
puts table
end
def list_table_row(table, job_net, with_jobs: false)
row = [Paint[job_net.name, :bold, :underline], job_net.desc]
row << "" if with_jobs
table << row
if with_jobs
job_net.dependencies.each do |inner_j, deps|
table << [Paint["#{" "}#{inner_j.name}"], inner_j.desc, deps.join(", ")]
end
end
end
def display_running_status(root_job_net)
context = root_job_net.context
table = Terminal::Table.new(headings: [
"Job",
"Status",
"Elapsed Time",
"Resource Count (#{context.semaphore.available_permits}/#{context.concurrency})",
]) do |t|
root_job_net.each_with_index do |j|
running_table_row(t, j)
end
end
puts table
end
def running_table_row(table, job, level = 0)
if job.is_a?(JobNet)
table << [
Paint["#{" " * level}#{job.class}", :bold, :underline],
Paint[job.state.colored, :bold, :underline],
Paint[job.formatted_elapsed_time_from, :bold, :underline],
"",
]
job.each do |inner_j|
running_table_row(table, inner_j, level + 1)
end
else
table << [Paint["#{" " * level}#{job.class}", :bold], job.state.colored, job.formatted_elapsed_time_from, job.resource_count]
end
end
end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/state.rb | lib/rukawa/state.rb | module Rukawa::State
def self.get(name)
const_get(name.to_s.split("_").map(&:capitalize).join)
end
module BaseExt
def state_name
@state_name ||= to_s.gsub(/Rukawa::State::/, "").downcase
end
def colored
Paint[state_name.to_s, color]
end
def merge(other)
other
end
def success?
false
end
%i(running? skipped? bypassed? error? aborted? waiting? finished?).each do |sym|
define_method(sym) do
false
end
end
end
module Running
extend BaseExt
def self.color
:cyan
end
def self.merge(_other)
self
end
def self.running?
true
end
end
module Skipped
extend BaseExt
def self.color
:yellow
end
def self.merge(other)
if other == Finished
self
else
other
end
end
def self.skipped?
true
end
end
module Bypassed
extend BaseExt
def self.color
:yellow
end
def self.success?
true
end
def self.bypassed?
true
end
end
module Error
extend BaseExt
def self.color
:red
end
def self.merge(other)
if other == Running
other
else
self
end
end
def self.error?
true
end
end
module Aborted
extend BaseExt
def name
"aborted"
end
def self.color
:magenta
end
def self.merge(other)
if other == Running || other == Error
other
else
self
end
end
def self.error?
true
end
def self.aborted?
true
end
end
module Waiting
extend BaseExt
def self.color
:default
end
def self.waiting?
true
end
end
module Finished
extend BaseExt
def self.color
:green
end
def self.success?
true
end
def self.finished?
true
end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/abstract_job.rb | lib/rukawa/abstract_job.rb | require 'set'
require 'rukawa/state'
require 'active_support/core_ext/class'
module Rukawa
class AbstractJob
attr_reader :parent_job_net
extend ActiveSupport::DescendantsTracker
class_attribute :skip_rules, instance_writer: false
self.skip_rules = []
class << self
def add_skip_rule(callable_or_symbol)
self.skip_rules = skip_rules + [callable_or_symbol]
end
def description
@description
end
alias :desc :description
def set_description(body)
@description = body
end
alias :set_desc :set_description
end
def name
self.class.name || self.class.to_s
end
def inspect
to_s
end
def skip?
parent_skip = @parent_job_net ? @parent_job_net.skip? : false
parent_skip || skip_rules.inject(false) do |cond, rule|
cond || rule.is_a?(Symbol) ? method(rule).call : rule.call(self)
end
end
def elapsed_time_from(time = Time.now)
return finished_at - started_at if started_at && finished_at
return time - started_at if started_at
nil
end
def formatted_elapsed_time_from(time = Time.now)
elapsed = elapsed_time_from(time)
return "N/A" unless elapsed
hour = elapsed.to_i / 3600
min = (elapsed - hour * 3600).to_i / 60
sec = (elapsed - hour * 3600 - min * 60).to_i
hour_format = hour > 0 ? "%dh " % hour : ""
min_format = hour > 0 || min > 0 ? "%dm " % min : ""
sec_format = "#{sec}s"
"#{hour_format}#{min_format}#{sec_format}"
end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/configuration.rb | lib/rukawa/configuration.rb | require 'singleton'
require 'ostruct'
require 'delegate'
require 'concurrent'
module Rukawa
class Configuration < Delegator
include Singleton
def initialize
@config = OpenStruct.new(
concurrency: Concurrent.processor_count,
dot_command: "dot",
job_dirs: [File.join(Dir.pwd, "job_nets"), File.join(Dir.pwd, "jobs")],
status_store: nil,
status_expire_duration: 24 * 60 * 60,
logger: Logger.new('./rukawa.log')
)
@config.graph = GraphConfig.new.tap { |c| c.rankdir = "LR" }
end
def __getobj__
@config
end
def graph_attrs
if @config.graph.rankdir || @config.graph.size || @config.graph
end
end
end
GraphConfig = Struct.new(:rankdir, :size, :rotate, :ranksep, :nodesep, :concentrate, :node) do
def initialize(*args)
super
self.node = GraphNodeConfig.new
end
def attrs
if rankdir || size || rotate || ranksep || nodesep || concentrate
values = to_h.map { |k, v| "#{k} = #{v}" if k != :node && v }.compact
"graph [#{values.join(",")}];\n"
else
""
end
end
end
GraphNodeConfig = Struct.new(:shape, :style) do
def attrs
if shape || style
values = to_h.map { |k, v| "#{k} = #{v}" if v }.compact
"node [#{values.join(",")}];\n"
else
""
end
end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/runner.rb | lib/rukawa/runner.rb | require 'terminal-table'
require 'paint'
require 'rukawa/overview'
module Rukawa
class Runner
DEFAULT_REFRESH_INTERVAL = 3
def self.run(job_net, batch_mode = false, refresh_interval = DEFAULT_REFRESH_INTERVAL)
new(job_net).run(batch_mode, refresh_interval)
end
def initialize(root_job_net)
@root_job_net = root_job_net
end
def run(batch_mode = false, refresh_interval = DEFAULT_REFRESH_INTERVAL)
displayed_at = Time.at(0)
promise = @root_job_net.run do
unless batch_mode
if Time.now - displayed_at >= refresh_interval
displayed_at = Time.now
Overview.display_running_status(@root_job_net)
end
end
end
futures = promise.value
Overview.display_running_status(@root_job_net) unless batch_mode
puts "Finished #{@root_job_net.name} in #{@root_job_net.formatted_elapsed_time_from}"
if futures.all?(&:fulfilled?)
true
else
false
end
end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/cli.rb | lib/rukawa/cli.rb | require 'thor'
require 'rukawa/runner'
require 'rukawa/overview'
module Rukawa
class Cli < Thor
def self.base_options
method_option :config, type: :string, default: nil, desc: "If this options is not set, try to load ./rukawa.rb"
method_option :job_dirs, type: :array, default: [], desc: "Load job directories", banner: "JOB_DIR1 JOB_DIR2"
end
def self.run_options
method_option :concurrency, aliases: "-c", type: :numeric, default: nil, desc: "Default: cpu count"
method_option :variables, aliases: "--var", type: :hash, default: {}, banner: "KEY:VALUE KEY:VALUE"
method_option :varfile, type: :string, default: nil, desc: "variable definition file. ex (variables.yml, variables.json)"
method_option :batch, aliases: "-b", type: :boolean, default: false, desc: "If batch mode, not display running status"
method_option :log, aliases: "-l", type: :string, desc: "Default: ./rukawa.log"
method_option :stdout, type: :boolean, default: false, desc: "Output log to stdout"
method_option :syslog, type: :boolean, default: false, desc: "Output log to syslog"
method_option :dot, aliases: "-d", type: :string, default: nil, desc: "Output job status by dot format"
method_option :format, aliases: "-f", type: :string, desc: "Output job status format: png, svg, pdf, ... etc"
method_option :refresh_interval, aliases: "-r", type: :numeric, default: 3, desc: "Refresh interval for running status information"
end
desc "run JOB_NET_NAME [JOB_NAME] [JOB_NAME] ...", "Run jobnet. If JOB_NET is set, resume from JOB_NAME"
map "run" => "_run"
base_options
run_options
def _run(job_net_name, *job_name)
load_config
set_logger
set_concurrency
load_job_definitions
job_net_class = get_class(job_net_name)
job_classes = job_name.map { |name| get_class(name) }
job_net = job_net_class.new(variables: variables, resume_job_classes: job_classes)
result = Runner.run(job_net, options[:batch], options[:refresh_interval])
if options[:dot]
job_net.output_dot(options[:dot], format: options[:format])
end
unless result
puts "\nIf you want to retry, run following command."
failed_jobs = job_net.dag.jobs.each_with_object([]) { |j, arr| arr << j.class.to_s if j.state == Rukawa::State::Error }
puts " rukawa run #{job_net_name} #{failed_jobs.join(" ")}"
exit 1
end
end
desc "graph JOB_NET_NAME [JOB_NAME] [JOB_NAME] ...", "Output jobnet graph. If JOB_NET is set, simulate resumed job sequence"
base_options
method_option :output, aliases: "-o", type: :string, required: true
method_option :format, aliases: "-f", type: :string
def graph(job_net_name, *job_name)
load_config
load_job_definitions
job_net_class = get_class(job_net_name)
job_classes = job_name.map { |name| get_class(name) }
job_net = job_net_class.new(resume_job_classes: job_classes)
job_net.output_dot(options[:output], format: options[:format])
end
desc "run_job JOB_NAME [JOB_NAME] ...", "Run specific jobs."
base_options
run_options
def run_job(*job_name)
load_config
set_logger
set_concurrency
load_job_definitions
job_classes = job_name.map { |name| get_class(name) }
job_net_class = anonymous_job_net_class(*job_classes)
job_net = job_net_class.new
result = Runner.run(job_net, options[:batch], options[:refresh_interval])
if options[:dot]
job_net.output_dot(options[:dot])
end
exit 1 unless result
end
desc "list", "List JobNet"
base_options
method_option :jobs, aliases: "-j", type: :boolean, desc: "Show jobs", default: false
def list
load_config
load_job_definitions
Rukawa::Overview.list_job_net(with_jobs: options[:jobs])
end
desc "list_job", "List Job"
base_options
def list_job
load_config
load_job_definitions
Rukawa::Overview.list_job
end
map %w[version -v] => "__print_version"
desc "version(-v)", "Print the version"
def __print_version
puts "rukawa #{Rukawa::VERSION}"
end
private
def load_config
if options[:config]
load File.expand_path(options[:config], Dir.pwd)
else
load default_config_file if File.exist?(default_config_file)
end
Rukawa.configure do |c|
c.job_dirs.concat(options[:job_dirs]) unless options[:job_dirs].empty?
end
end
def set_logger
Rukawa.configure do |c|
if options[:stdout]
c.logger = Logger.new($stdout)
elsif options[:syslog]
require 'syslog/logger'
c.logger = Syslog::Logger.new('rukawa')
elsif options[:log]
c.logger = Logger.new(options[:log])
end
end
end
def set_concurrency
Rukawa.configure do |c|
c.concurrency = options[:concurrency] if options[:concurrency]
end
end
def default_config_file
"./rukawa.rb"
end
def load_job_definitions
Rukawa.load_jobs
end
def get_class(name)
Object.const_get(name)
rescue NameError
$stderr.puts("`#{name}` class is not found")
exit 1
end
def anonymous_job_net_class(*job_classes)
Class.new(JobNet) do
self.singleton_class.send(:define_method, :dependencies) do
job_classes.map { |klass| [klass, []] }.to_h
end
define_method(:name) { "AnonymousJobNet" }
end
end
def variables
if options[:varfile]
read_varfile.freeze
else
options[:variables].freeze
end
end
def read_varfile
unless File.exist?(options[:varfile])
$stderr.puts("`#{options[:varfile]}` is not found")
exit 1
end
extname = File.extname(options[:varfile])
if %w(.yml .yaml).include?(extname)
require 'yaml'
deserializer = ->(data) { YAML.load(data) }
elsif %w(.js .json).include?(extname)
require 'json'
deserializer = ->(data) { JSON.load(data) }
end
deserializer.call(File.read(options[:varfile]))
end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/wrapper.rb | lib/rukawa/wrapper.rb | module Rukawa
module Wrapper
class WrappedJobError < StandardError; end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/context.rb | lib/rukawa/context.rb | module Rukawa
class Context
attr_reader :store, :executor, :semaphore, :concurrency
def initialize(concurrency = nil)
@concurrency = concurrency || Rukawa.config.concurrency
@store = Concurrent::Hash.new
@executor = Concurrent::CachedThreadPool.new
@semaphore = Concurrent::Semaphore.new(@concurrency)
end
def shutdown
@executor.shutdown if @executor.running?
end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/job.rb | lib/rukawa/job.rb | require 'concurrent'
require 'rukawa/abstract_job'
require 'rukawa/dependency'
require 'rukawa/state'
require 'active_support/core_ext/class'
require 'active_support/callbacks'
module Rukawa
class Job < AbstractJob
include ActiveSupport::Callbacks
define_callbacks :run,
terminator: ->(_,result) { result == false },
skip_after_callbacks_if_terminated: true,
scope: [:kind, :name],
only: [:before, :around, :after]
define_callbacks :fail,
terminator: ->(_,result) { result == false },
skip_after_callbacks_if_terminated: true,
scope: [:kind, :name],
only: [:after]
attr_accessor :in_comings, :out_goings
attr_reader :state, :started_at, :finished_at, :variables
class_attribute :retryable, :retry_limit, :retry_exception_type, :retry_wait, instance_writer: false
class_attribute :dependency_type, instance_writer: false
class_attribute :resource_count, instance_reader: false, instance_writer: false
self.dependency_type = Dependency::AllSuccess
self.resource_count = 1
class << self
def set_retryable(limit: 8, type: nil, wait: nil)
self.retryable = true
self.retry_limit = limit
self.retry_exception_type = type
self.retry_wait = wait
end
def set_dependency_type(name)
self.dependency_type = Rukawa::Dependency.get(name)
end
def set_resource_count(count)
self.resource_count = count
end
def before_run(*args, **options, &block)
set_callback :run, :before, *args, **options, &block
end
def after_run(*args, **options, &block)
options[:prepend] = true
conditional = ActiveSupport::Callbacks::Conditionals::Value.new { |v|
v != false
}
options[:if] = Array(options[:if]) << conditional
set_callback :run, :after, *args, **options, &block
end
def after_fail(*args, **options, &block)
options[:prepend] = true
conditional = ActiveSupport::Callbacks::Conditionals::Value.new { |v|
v != false
}
options[:if] = Array(options[:if]) << conditional
set_callback :fail, :after, *args, **options, &block
end
def around_run(*args, **options, &block)
set_callback :run, :around, *args, **options, &block
end
def wrappers
@@wrappers ||= {}
end
def wrapper_for(*classes)
classes.each do |c|
raise "Wrapper for #{c} is already defined" if wrappers[c]
wrappers[c] = self
end
end
end
around_run do |_, blk|
Rukawa.logger.info("Start #{self.class}")
blk.call
Rukawa.logger.info("Finish #{self.class}")
end
around_run do |_, blk|
set_state(:running)
blk.call
set_state(:finished)
end
def initialize(variables: {}, context: Context.new, parent_job_net: nil)
@parent_job_net = parent_job_net
@variables = variables
@context = context
@in_comings = Set.new
@out_goings = Set.new
@retry_count = 0
@retry_wait = 1
set_state(:waiting)
end
def set_state(name)
@state = Rukawa::State.get(name)
end
def root?
in_comings.select { |edge| edge.cluster == @parent_job_net }.empty?
end
def leaf?
out_goings.select { |edge| edge.cluster == @parent_job_net }.empty?
end
def dataflow
return @dataflow if @dataflow
return @dataflow = bypass_dataflow if @state.bypassed?
@dataflow = Concurrent.dataflow_with(@context.executor, *depend_dataflows) do |*results|
acquire_resource do
do_run(*results)
@state
end
end
end
def run
end
private def do_run(*results)
@started_at = Time.now
if skip?
Rukawa.logger.info("Skip #{self.class}")
set_state(:skipped)
else
check_dependencies(results)
run_callbacks :run do
run
end
end
rescue => e
run_callbacks :fail
handle_error(e)
Rukawa.logger.error("Retry #{self.class}")
retry
ensure
@finished_at = Time.now
end
def jobs_as_from
[self]
end
alias :jobs_as_to :jobs_as_from
def to_dot_def
if state == Rukawa::State::Waiting
"\"#{name}\";\n"
else
"\"#{name}\" [style = filled,fillcolor = #{state.color}];\n"
end
end
def resource_count
[self.class.resource_count, Rukawa.config.concurrency].min
end
private
def depend_dataflows
in_comings.map { |edge| edge.from.dataflow }
end
def bypass_dataflow
Concurrent.dataflow_with(@context.executor, *depend_dataflows) do
Rukawa.logger.info("Skip #{self.class}")
@state
end
end
def dependency_type
self.class.dependency_type
end
def check_dependencies(results)
dependency = dependency_type.new(*results)
unless dependency.resolve
set_state(:aborted)
raise DependencyUnsatisfied
end
end
def handle_error(e)
Rukawa.logger.error("Error #{self.class} by #{e}")
if retry?(e)
@retry_count += 1
set_state(:waiting)
sleep @retry_wait
@retry_wait = self.class.retry_wait ? self.class.retry_wait : @retry_wait * 2
else
set_state(:error) unless e.is_a?(DependencyUnsatisfied)
raise e
end
end
def retry?(e)
return false unless self.class.retryable
type_condition = case self.class.retry_exception_type
when Array
self.class.retry_exception_type.include?(e.class)
when Class
e.is_a?(self.class.retry_exception_type)
when nil
!e.is_a?(DependencyUnsatisfied)
end
type_condition && (self.class.retry_limit.nil? || self.class.retry_limit == 0 || @retry_count < self.class.retry_limit)
end
def store(key, value)
@context.store[self.class] ||= Concurrent::Hash.new
@context.store[self.class][key] = value
end
def fetch(job, key)
job = job.is_a?(String) ? Object.const_get(job) : job
raise TypeError, "job must be a Class" unless job.is_a?(Class)
if @context.store[job]
@context.store[job][key]
end
end
def acquire_resource
@context.semaphore.acquire(resource_count) if resource_count > 0
yield
ensure
@context.semaphore.release(resource_count) if resource_count > 0
end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/remote.rb | lib/rukawa/remote.rb | module Rukawa
module Remote
class << self
def store
Rukawa.config.status_store
end
end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/dependency.rb | lib/rukawa/dependency.rb | module Rukawa
module Dependency
def self.get(name)
const_get(name.to_s.split("_").map(&:capitalize).join)
end
class Base
def initialize(*results)
@results = results
end
def resolve
raise NotImplementedError
end
end
class AllSuccess < Base
def resolve
@results.all? { |r| r && r.success? }
end
end
class AllDone < Base
def resolve
true
end
end
class OneSuccess < Base
def resolve
@results.empty? || @results.any? { |r| r && r.success? }
end
end
class AllSuccessOrSkipped < Base
def resolve
@results.all? { |r| r && (r.success? || r.skipped?) }
end
end
class OneSuccessOrSkipped < Base
def resolve
@results.empty? || @results.any? { |r| r && (r.success? || r.skipped?) }
end
end
class AllFailed < Base
def resolve
@results.none? { |r| r }
end
end
class OneFailed < Base
def resolve
@results.empty? || @results.any? { |r| r.nil? }
end
end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/dag.rb | lib/rukawa/dag.rb | require 'set'
require 'tsort'
module Rukawa
class Dag
include Enumerable
include TSort
attr_reader :nodes, :jobs, :edges
def initialize
@nodes = Set.new
@jobs = Set.new
@edges = Set.new
end
def build(job_net, variables, context, dependencies)
deps = tsortable_hash(dependencies).tsort
deps.each do |job_class|
job = job_class.new(variables: variables, context: context, parent_job_net: job_net)
@nodes << job
@jobs << job if job.is_a?(Job)
dependencies[job_class].each do |depend_job_class|
depend_job = @nodes.find { |j| j.instance_of?(depend_job_class) }
depend_job.jobs_as_from.product(job.jobs_as_to).each do |from, to|
@jobs << from
@jobs << to
edge = Edge.new(from, to, job_net)
@edges << edge
from.out_goings << edge
to.in_comings << edge
end
end
end
if job_net.parent_job_net
job_net.parent_job_net.dag.jobs.merge(@jobs)
end
end
def each
if block_given?
@nodes.each { |j| yield j }
else
@nodes.each
end
end
def tsort_each_node(&block)
@jobs.each(&block)
end
def tsort_each_child(node)
if block_given?
node.out_goings.each do |edge|
yield edge.to
end
else
Enumerator.new do |y|
node.out_goings.each do |edge|
y << edge.to
end
end
end
end
def leveled_each
visited = Set.new
queue = []
queue.push(*@jobs.select { |j| j.in_comings.empty? })
if block_given?
until queue.empty?
next_job = queue.shift
yield next_job unless visited.include?(next_job)
queue.push(*next_job.out_goings.map(&:to)) if visited.add?(next_job)
end
else
Enumerator.new do |y|
until queue.empty?
next_job = queue.shift
y << next_job unless visited.include?(next_job)
queue.push(*next_job.out_goings.map(&:to)) if visited.add?(next_job)
end
end
end
end
private
def tsortable_hash(hash)
ensure_dependencies_have_all_jobs_as_key!(hash)
class << hash
include TSort
alias :tsort_each_node :each_key
def tsort_each_child(node, &block)
fetch(node).each(&block)
end
end
hash
end
def ensure_dependencies_have_all_jobs_as_key!(hash)
hash.values.each do |parents|
parents.each do |j|
hash[j] ||= []
end
end
end
class Edge
attr_reader :from, :to, :cluster
def initialize(from, to, cluster = nil)
@from, @to, @cluster = from, to, cluster
end
def inspect
"#{@from.name} -> #{@to.name}"
end
def ==(edge)
return false unless edge.is_a?(Edge)
from == edge.from && to == edge.to
end
alias :eql? :==
def hash
[from, to].hash
end
end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/builtins/waiter.rb | lib/rukawa/builtins/waiter.rb | require 'rukawa/builtins/base'
require 'timeout'
module Rukawa
module Builtins
class Waiter < Base
class_attribute :timeout, :poll_interval
self.timeout = 1800
self.poll_interval = 1
class << self
def handle_parameters(timeout: nil, poll_interval: nil, **rest)
self.timeout = timeout if timeout
self.poll_interval = poll_interval if poll_interval
end
end
def run
Timeout.timeout(timeout) do
wait_until do
fetch_condition
end
end
end
private
def wait_until
until yield
sleep poll_interval
end
end
def fetch_condition
raise NotImplementedError
end
end
class SleepWaiter < Waiter
class_attribute :sec
class << self
def handle_parameters(sec:, **rest)
self.sec = sec
end
end
private
def fetch_condition
sleep sec
end
end
class LocalFileWaiter < Waiter
class_attribute :path, :if_modified_since, :if_unmodified_since
class << self
def handle_parameters(path:, if_modified_since: nil, if_unmodified_since: nil, **rest)
self.path = path
self.if_modified_since = if_modified_since if if_modified_since
self.if_unmodified_since = if_unmodified_since if if_unmodified_since
super(**rest)
end
end
private
def fetch_condition
if path.respond_to?(:all?)
get_stat_and_check_condition(p)
path.all?(&method(:get_stat_and_check_condition))
else
get_stat_and_check_condition(path)
end
end
def get_stat_and_check_condition(path)
stat = File.stat(path)
if if_modified_since
stat.mtime > if_modified_since
elsif if_unmodified_since
stat.mtime <= if_unmodified_since
else
true
end
rescue
false
end
end
class S3Waiter < Waiter
class_attribute :url, :aws_access_key_id, :aws_secret_access_key, :region, :if_modified_since, :if_unmodified_since
class << self
def handle_parameters(url:, aws_access_key_id: nil, aws_secret_access_key: nil, region: nil, if_modified_since: nil, if_unmodified_since: nil, **rest)
require 'aws-sdk'
self.url = url
self.aws_access_key_id = aws_access_key_id if aws_access_key_id
self.aws_secret_access_key = aws_secret_access_key if aws_secret_access_key
self.region = region if region
self.if_modified_since = if_modified_since if if_modified_since
self.if_unmodified_since = if_unmodified_since if if_unmodified_since
super(**rest)
end
end
private
def fetch_condition
opts = {if_modified_since: if_modified_since, if_unmodified_since: if_unmodified_since}.reject do |_, v|
v.nil?
end
if url.respond_to?(:all?)
url.all? do |u|
s3url = URI.parse(u)
client.head_object(bucket: s3url.host, key: s3url.path[1..-1], **opts) rescue false
end
else
s3url = URI.parse(url)
client.head_object(bucket: s3url.host, key: s3url.path[1..-1], **opts) rescue false
end
end
def client
return @client if @client
if aws_secret_access_key || aws_secret_access_key || region
options = {access_key_id: aws_access_key_id, secret_access_key: aws_secret_access_key, region: region}.reject do |_, v|
v.nil?
end
@client = Aws::S3::Client.new(options)
else
@client = Aws::S3::Client.new
end
end
end
class GCSWaiter < Waiter
class_attribute :url, :json_key, :if_modified_since, :if_unmodified_since
class << self
def handle_parameters(url:, json_key: nil, if_modified_since: nil, if_unmodified_since: nil, **rest)
require 'google/apis/storage_v1'
require 'googleauth'
self.url = url
self.json_key = json_key if json_key
self.if_modified_since = if_modified_since if if_modified_since
self.if_unmodified_since = if_unmodified_since if if_unmodified_since
super(**rest)
end
end
private
def fetch_condition
if url.respond_to?(:all?)
url.all? do |u|
get_object_and_check_condition(URI.parse(u))
end
else
get_object_and_check_condition(URI.parse(url))
end
end
def get_object_and_check_condition(url)
obj = client.get_object(url.host, url.path[1..-1])
if if_modified_since
obj.updated.to_time > if_modified_since
elsif if_unmodified_since
obj.updated.to_time <= if_unmodified_since
else
true
end
rescue
false
end
def client
return @client if @client
client = Google::Apis::StorageV1::StorageService.new
scope = "https://www.googleapis.com/auth/devstorage.read_only"
if json_key
begin
JSON.parse(json_key)
key = StringIO.new(json_key)
client.authorization = Google::Auth::ServiceAccountCredentials.make_creds(json_key_io: key, scope: scope)
rescue JSON::ParserError
key = json_key
File.open(json_key) do |f|
client.authorization = Google::Auth::ServiceAccountCredentials.make_creds(json_key_io: f, scope: scope)
end
end
else
client.authorization = Google::Auth.get_application_default([scope])
end
client
end
end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/builtins/embulk.rb | lib/rukawa/builtins/embulk.rb | require 'rukawa/builtins/shell'
module Rukawa
module Builtins
class Embulk < Shell
class_attribute :config, :embulk_bin, :embulk_bundle, :embulk_vm_options, :jvm_options, :preview
self.embulk_bin = "embulk"
self.embulk_bundle = nil
self.embulk_vm_options = []
self.jvm_options = []
self.preview = false
class << self
def handle_parameters(config:, embulk_bin: nil, embulk_bundle: nil, embulk_vm_options: nil, jvm_options: nil, stdout: nil, stderr: nil, env: nil, chdir: nil, preview: false)
self.config = config
self.embulk_bin = embulk_bin if embulk_bin
self.embulk_bundle = embulk_bundle if embulk_bundle
self.embulk_vm_options = embulk_vm_options if embulk_vm_options
self.jvm_options = jvm_options if jvm_options
self.stdout = stdout if stdout
self.stderr = stderr if stderr
self.env = env if env
self.chdir = chdir if chdir
self.preview = preview
end
end
def run
process = -> do
if preview
stdout.puts "Config:\n#{File.read(config)}"
cmds = [embulk_bin, "preview", *embulk_bundle, config].compact
stdout.puts cmds.join(" ")
else
cmds = [embulk_bin, *embulk_vm_options, *jvm_options, "run", *embulk_bundle, config].compact
stdout.puts cmds.join(" ")
end
stdout.flush
cmdenv = env || {}
opts = chdir ? {chdir: chdir} : {}
result, log = execute_command(cmds, cmdenv, opts)
unless result.success?
next if log =~ /NoSampleException/
raise "embulk error"
end
end
if defined?(Bundler)
Bundler.with_clean_env(&process)
else
process.call
end
end
end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/builtins/base.rb | lib/rukawa/builtins/base.rb | require 'rukawa/job'
module Rukawa
module Builtins
class Base < ::Rukawa::Job
class << self
def [](**params)
Class.new(self) do
handle_parameters(params)
def self.name
super || "#{superclass.name}_#{object_id}"
end
end
end
def handle_parameters(**params)
end
end
end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/builtins/shell.rb | lib/rukawa/builtins/shell.rb | require 'rukawa/builtins/base'
require 'active_support/core_ext/class'
require 'open3'
module Rukawa
module Builtins
class Shell < Base
class_attribute :command, :args, :env, :chdir, :stdout, :stderr
self.args = []
self.stdout = $stdout
self.stderr = $stderr
class << self
def handle_parameters(command:, args: [], env: nil, chdir: nil, stdout: nil, stderr: nil, **rest)
self.command = command
self.args = args
self.env = env if env
self.chdir = chdir if chdir
self.stdout = stdout if stdout
self.stderr = stderr if stderr
end
end
def run
cmdenv = env || {}
opts = chdir ? {chdir: chdir} : {}
if defined?(Bundler)
result, log = nil
Bundler.with_clean_env do
result, log = execute_command([command, *args], cmdenv, opts)
end
else
result, log = execute_command([command, *args], cmdenv, opts)
end
unless result.success?
raise "command error"
end
end
def execute_command(command, env, opts)
log = "".dup
result = Open3.popen3(env, *command, opts) do |stdin, out, err, wait_th|
stdin.close
until out.eof? && err.eof?
rs, = IO.select([out, err])
rs.each do |rio|
line = rio.gets
if line
log << line
if rio == out
stdout.write(line)
else
stderr.write(line)
end
end
end
end
wait_th.value
end
stdout.flush
stderr.flush unless stdout == stderr
return result, log
end
end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/remote/status_store.rb | lib/rukawa/remote/status_store.rb | module Rukawa
module Remote
class StatusStore
ENQUEUED = "enqueued".freeze
PERFORMING = "performing".freeze
COMPLETED = "completed".freeze
FAILED = "failed".freeze
# default expire duration is 24 hours.
def initialize(job_id:, expire_duration: Rukawa.config.status_expire_duration)
@job_id = job_id
@expire_duration = expire_duration
end
def fetch
Rukawa.config.status_store.fetch(store_key)
end
def enqueued
Rukawa.config.status_store.write(store_key, ENQUEUED, expires_in: @expire_duration)
end
def performing
Rukawa.config.status_store.write(store_key, PERFORMING, expires_in: @expire_duration)
end
def completed
Rukawa.config.status_store.write(store_key, COMPLETED, expires_in: @expire_duration)
end
def failed
Rukawa.config.status_store.write(store_key, FAILED, expires_in: @expire_duration)
end
def delete
Rukawa.config.status_store.delete(store_key)
end
private
def store_key
"rukawa.remote_job.status.#{@job_id}"
end
end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/lib/rukawa/wrapper/active_job.rb | lib/rukawa/wrapper/active_job.rb | require 'rukawa/job'
require 'rukawa/wrapper'
require 'rukawa/remote/status_store'
module Rukawa
module Wrapper
module ActiveJob
def self.[](job_class)
raise "Please set Rukawa.config.status_store subclass of ActiveSupport::Cache::Store" unless Rukawa.config.status_store
@wrapper_classes ||= {}
return @wrapper_classes[job_class] if @wrapper_classes[job_class]
wrapper = Class.new(Rukawa::Job) do
set_resource_count 0
define_singleton_method(:origin_class) do
job_class
end
def initialize(variables: {}, context: Context.new, parent_job_net: nil)
super
@job_class = self.class.origin_class
end
def run
@job_class.include(Hooks) unless @job_class.include?(Hooks)
@job_class.prepend(HooksForFailure) unless @job_class.include?(HooksForFailure)
job = @job_class.perform_later
status_store = Rukawa::Remote::StatusStore.new(job_id: job.job_id)
finish_statuses = [Rukawa::Remote::StatusStore::COMPLETED, Rukawa::Remote::StatusStore::FAILED]
until finish_statuses.include?(last_status = status_store.fetch)
sleep 0.1
end
status_store.delete
raise WrappedJobError if last_status == Rukawa::Remote::StatusStore::FAILED
end
end
@wrapper_classes[job_class] = wrapper
Rukawa::Wrapper.const_set("#{job_class.to_s.gsub(/::/, "_")}Wrapper", wrapper)
wrapper
end
end
module Hooks
def self.included(base)
base.class_eval do
before_enqueue { status_store.enqueued }
before_perform { status_store.performing }
after_perform { status_store.completed }
end
end
private
def status_store
@status_store ||= Rukawa::Remote::StatusStore.new(job_id: job_id)
end
end
module HooksForFailure
def perform(*args)
super
rescue Exception
status_store.failed
raise
end
end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/sample/rukawa.rb | sample/rukawa.rb | Rukawa.configure do |c|
c.graph.concentrate = true
c.graph.nodesep = 0.8
end
redis_host = ENV["REDIS_HOST"] || "localhost:6379"
Rukawa.configure do |c|
c.status_store = ActiveSupport::Cache::RedisStore.new(redis_host)
end
require 'active_job'
ActiveJob::Base.queue_adapter = :sucker_punch
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/sample/jobs/active_job.rb | sample/jobs/active_job.rb | require 'active_job'
class ActiveJobSample1 < ActiveJob::Base
queue_as :default
def perform
sleep 10
p "active_job1"
end
end
class ActiveJobSample2 < ActiveJob::Base
queue_as :default
def perform
sleep 10
raise "active_job2 is failed"
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/sample/jobs/sample_job.rb | sample/jobs/sample_job.rb | module ExecuteLog
def self.store
@store ||= {}
end
end
class Notifier
def after_run(job)
puts "#{job.name}:#{job.state.name}:#{job.elapsed_time_from}"
end
end
class SampleJob < Rukawa::Job
def run
sleep rand(5)
ExecuteLog.store[self.class] = Time.now
end
end
class Job1 < SampleJob
set_description "Job1 description body"
after_run Notifier.new
def run
p variables unless variables.empty?
super
end
end
class Job2 < SampleJob
after_fail do |job|
p "Job2 Failed!!! #{job.state.name}"
end
def run
raise "job2 error"
end
end
class Job3 < SampleJob
end
class Job4 < SampleJob
# inherited by subclass
set_dependency_type :one_success
set_resource_count 3
end
class Job5 < SampleJob
# inherited by subclass
set_retryable limit: 3, wait: 2, type: RuntimeError
def run
raise "job5 error"
end
end
class Job6 < SampleJob
set_dependency_type :one_failed
end
class Job7 < SampleJob
end
class Job8 < SampleJob
end
class InnerJob1 < SampleJob
end
class InnerJob2 < SampleJob
def run
raise "inner job2 error"
end
end
class InnerJob3 < SampleJob
end
class InnerJob4 < SampleJob
end
class InnerJob5 < SampleJob
# inherited by subclass
add_skip_rule ->(job) { job.is_a?(SampleJob) }
end
class InnerJob6 < SampleJob
end
class InnerJob7 < SampleJob
end
class InnerJob8 < SampleJob
end
class InnerJob9 < SampleJob
end
class InnerJob10 < SampleJob
end
class InnerJob11 < SampleJob
end
class InnerJob12 < SampleJob
end
class InnerJob13 < SampleJob
end
class NestedJob1 < SampleJob
end
class NestedJob2 < SampleJob
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
joker1007/rukawa | https://github.com/joker1007/rukawa/blob/23b32adbbb61a42c549b582f03df92b8cc548746/sample/job_nets/sample_job_net.rb | sample/job_nets/sample_job_net.rb | class InnerJobNet < Rukawa::JobNet
class << self
def dependencies
{
InnerJob2 => [InnerJob1, InnerJob3],
}
end
end
end
class InnerJobNet2 < Rukawa::JobNet
class << self
def dependencies
{
InnerJob5 => [InnerJob4],
InnerJob6 => [InnerJob4, InnerJob5],
}
end
end
end
class InnerJobNet3 < Rukawa::JobNet
class << self
def dependencies
{
InnerJob9 => [InnerJob7, InnerJob8],
InnerJob10 => [InnerJob7, InnerJob8],
}
end
end
end
class InnerJobNet4 < Rukawa::JobNet
class << self
def dependencies
{
NestedJobNet => [InnerJob11, InnerJob12],
}
end
end
end
class NestedJobNet < Rukawa::JobNet
class << self
def dependencies
{
NestedJob2 => [NestedJob1],
}
end
end
end
class SampleJobNet < Rukawa::JobNet
class << self
def dependencies
wrapped1 = Rukawa::Wrapper::ActiveJob[ActiveJobSample1]
wrapped2 = Rukawa::Wrapper::ActiveJob[ActiveJobSample2]
{
Job1 => [],
wrapped1 => [Job1],
wrapped2 => [wrapped1],
Job2 => [Job1], Job3 => [Job1, wrapped1],
Job4 => [Job2, Job3],
InnerJobNet => [Job3],
Job8 => [InnerJobNet],
Job5 => [Job3],
Job6 => [Job4, Job5],
Job7 => [Job6],
InnerJobNet2 => [Job4],
InnerJobNet3 => [Job8, Job7],
InnerJobNet4 => [InnerJobNet3],
}
end
end
end
| ruby | MIT | 23b32adbbb61a42c549b582f03df92b8cc548746 | 2026-01-04T17:51:46.689670Z | false |
seratch/rspec-kickstarter | https://github.com/seratch/rspec-kickstarter/blob/969d85fb9d702908ab0c6f2acc014b72a91c17e9/spec/rspec_kickstarter_spec.rb | spec/rspec_kickstarter_spec.rb | # -*- encoding: utf-8 -*-
require 'spec_helper'
describe RSpecKickstarter do
describe '#write_spec' do
it 'works' do
file_path = 'lib/rspec_kickstarter.rb'
spec_dir = './spec'
force_write = false
dry_run = false
RSpecKickstarter.write_spec(file_path, spec_dir, force_write, dry_run)
end
end
end
| ruby | MIT | 969d85fb9d702908ab0c6f2acc014b72a91c17e9 | 2026-01-04T17:51:47.903820Z | false |
seratch/rspec-kickstarter | https://github.com/seratch/rspec-kickstarter/blob/969d85fb9d702908ab0c6f2acc014b72a91c17e9/spec/spec_helper.rb | spec/spec_helper.rb | require 'simplecov'
if ENV['TRAVIS']
require 'coveralls'
Coveralls.wear!
else
require 'simplecov'
SimpleCov.start
end
# RSpec.configure do |config|
# end
| ruby | MIT | 969d85fb9d702908ab0c6f2acc014b72a91c17e9 | 2026-01-04T17:51:47.903820Z | false |
seratch/rspec-kickstarter | https://github.com/seratch/rspec-kickstarter/blob/969d85fb9d702908ab0c6f2acc014b72a91c17e9/spec/rspec_kickstarter/version_spec.rb | spec/rspec_kickstarter/version_spec.rb | # -*- encoding: utf-8 -*-
require 'spec_helper'
require 'rspec_kickstarter/version'
describe RSpecKickstarter do
describe RSpecKickstarter::VERSION do
it 'exists' do
expect(RSpecKickstarter::VERSION).not_to be_nil
end
end
end
| ruby | MIT | 969d85fb9d702908ab0c6f2acc014b72a91c17e9 | 2026-01-04T17:51:47.903820Z | false |
seratch/rspec-kickstarter | https://github.com/seratch/rspec-kickstarter/blob/969d85fb9d702908ab0c6f2acc014b72a91c17e9/spec/rspec_kickstarter/generator_spec.rb | spec/rspec_kickstarter/generator_spec.rb | # -*- encoding: utf-8 -*-
require 'spec_helper'
require 'rspec_kickstarter/generator'
describe RSpecKickstarter::Generator do
let(:generator) { RSpecKickstarter::Generator.new('tmp/spec') }
describe '#new' do
it 'works without params' do
result = RSpecKickstarter::Generator.new
expect(result).not_to be_nil
end
it 'works' do
spec_dir = './spec'
result = RSpecKickstarter::Generator.new(spec_dir)
expect(result).not_to be_nil
end
end
describe '#get_complete_class_name' do
it 'works' do
parent = double(:parent, name: nil)
c = double(:c, parent: parent)
name = 'ClassName'
result = generator.get_complete_class_name(c, name)
expect(result).to eq('ClassName')
end
end
describe '#instance_name' do
it 'works' do
c = double(:c, name: 'generator')
result = generator.instance_name(c)
expect(result).to eq('generator')
end
end
describe '#to_param_names_array' do
it 'works' do
params = "(a, b = 'foo', c = 123)"
result = generator.to_param_names_array(params)
expect(result).to eq(%w(a b c))
end
end
describe '#get_params_initialization_code' do
it 'works' do
method = double(:method, params: "(a = 1,b = 'aaaa')")
result = generator.get_params_initialization_code(method)
expect(result).to eq(" a = double('a')\n b = double('b')\n")
end
end
describe '#get_instantiation_code' do
it 'works with modules' do
method = double(:method, singleton: true, name: 'do_something')
c = double(:c, name: 'Foo', method_list: [method])
result = generator.get_instantiation_code(c, method)
expect(result).to eq('')
end
it 'works with classes' do
parent = double(:parent, name: nil)
method = double(:method, singleton: false, name: 'do_something')
c = double(:c, name: 'Foo', parent: parent, method_list: [method])
result = generator.get_instantiation_code(c, method)
expect(result).to eq(" foo = Foo.new\n")
end
end
describe '#get_method_invocation_code' do
it 'works with modules' do
parent = double(:parent, name: nil)
method = double(:method, singleton: true, name: 'do_something', params: '(a, b)', block_params: '')
c = double(:c, name: 'Module', parent: parent, method_list: [method])
result = generator.get_method_invocation_code(c, method)
expect(result).to eq('Module.do_something(a, b)')
end
it 'works with classes' do
parent = double(:parent, name: 'Module')
method = double(:method, singleton: false, name: 'do_something', params: '(a, b)', block_params: '')
c = double(:c, name: 'ClassName', parent: parent, method_list: [method])
result = generator.get_method_invocation_code(c, method)
expect(result).to eq('class_name.do_something(a, b)')
end
end
describe '#get_block_code' do
it 'works with no arg' do
method = double(:method, block_params: '')
result = generator.get_block_code(method)
expect(result).to eq('')
end
it 'works with 1 arg block' do
method = double(:method, block_params: 'a')
result = generator.get_block_code(method)
expect(result).to eq(' { |a| }')
end
it 'works with 2 args block' do
method = double(:method, block_params: 'a, b')
result = generator.get_block_code(method)
expect(result).to eq(' { |a, b| }')
end
end
class CannotExtractTargetClass < RSpecKickstarter::Generator
def extract_target_class_or_module(*)
nil
end
end
describe '#write_spec' do
it 'just works' do
file_path = 'lib/rspec_kickstarter.rb'
generator.write_spec(file_path)
end
it 'works with -f option' do
file_path = 'lib/rspec_kickstarter.rb'
generator.write_spec(file_path, true)
end
it 'works with -n option' do
file_path = 'lib/rspec_kickstarter.rb'
generator.write_spec(file_path, false, true)
end
it 'works with no target class' do
file_path = 'lib/rspec_kickstarter.rb'
CannotExtractTargetClass.new.write_spec(file_path, true)
end
it 'creates new spec with full_tempalte' do
FileUtils.rm_rf('tmp/spec') if File.exist?('tmp/spec')
FileUtils.mkdir_p('tmp/spec')
code = <<CODE
class Foo
def hello; 'aaa'; end
end
CODE
FileUtils.mkdir_p('tmp/lib')
File.open('tmp/lib/foo.rb', 'w') { |f| f.write(code) }
generator.full_template = 'samples/full_template.erb'
generator.write_spec('tmp/lib/foo.rb')
end
it 'appends new cases' do
FileUtils.rm_rf('tmp/spec') if File.exist?('tmp/spec')
FileUtils.mkdir_p('tmp/spec')
code = <<CODE
class Foo
def hello; 'aaa'; end
end
CODE
FileUtils.mkdir_p('tmp/lib')
File.open('tmp/lib/foo.rb', 'w') { |f| f.write(code) }
generator.write_spec('tmp/lib/foo.rb')
code2 = <<CODE
class Foo
def hello; 'aaa'; end
def bye; 'aaa'; end
end
CODE
File.open('tmp/lib/foo.rb', 'w') { |f| f.write(code2) }
generator.write_spec('tmp/lib/foo.rb', true, true)
generator.write_spec('tmp/lib/foo.rb', true)
end
it 'appends new cases with delta_template' do
FileUtils.rm_rf('tmp/spec') if File.exist?('tmp/spec')
FileUtils.mkdir_p('tmp/spec')
code = <<CODE
class Foo
def hello; 'aaa'; end
end
CODE
FileUtils.mkdir_p('tmp/lib')
File.open('tmp/lib/foo.rb', 'w') { |f| f.write(code) }
generator.delta_template = 'sample/delta_template.erb'
generator.write_spec('tmp/lib/foo.rb')
code2 = <<CODE
class Foo
def hello; 'aaa'; end
def bye; 'aaa'; end
end
CODE
File.open('tmp/lib/foo.rb', 'w') { |f| f.write(code2) }
generator.write_spec('tmp/lib/foo.rb', true, true)
generator.write_spec('tmp/lib/foo.rb', true)
end
it 'works with rails controllers' do
FileUtils.rm_rf('tmp/spec') if File.exist?('tmp/spec')
FileUtils.mkdir_p('tmp/spec')
code = <<CODE
class FooController
end
CODE
FileUtils.mkdir_p('tmp/app/controllers')
File.open('tmp/app/controllers/foo_controller.rb', 'w') { |f| f.write(code) }
generator.write_spec('tmp/app/controllers/foo_controller.rb', true, false, true)
code = <<CODE
class FooController
def foo
end
end
CODE
File.open('tmp/app/controllers/foo_controller.rb', 'w') { |f| f.write(code) }
generator.write_spec('tmp/app/controllers/foo_controller.rb', true, false, true)
end
it 'works with rails helpers' do
FileUtils.rm_rf('tmp/spec') if File.exist?('tmp/spec')
FileUtils.mkdir_p('tmp/spec')
code = <<CODE
class FooHelper
end
CODE
FileUtils.mkdir_p('tmp/app/helpers')
File.open('tmp/app/helpers/foo_helper.rb', 'w') { |f| f.write(code) }
generator.write_spec('tmp/app/helpers/foo_helper.rb', true, false, true)
code = <<CODE
class FooHelper
def foo
end
end
CODE
File.open('tmp/app/helpers/foo_helper.rb', 'w') { |f| f.write(code) }
generator.write_spec('tmp/app/helpers/foo_helper.rb', true, false, true)
end
end
describe '#get_spec_path' do
it 'works' do
file_path = 'lib/foo/bar.rb'
result = generator.get_spec_path(file_path)
expect(result).to eq('tmp/spec/foo/bar_spec.rb')
end
it 'works with path which starts with current dir' do
file_path = './lib/foo/bar.rb'
result = generator.get_spec_path(file_path)
expect(result).to eq('tmp/spec/foo/bar_spec.rb')
end
end
describe '#to_string_value_to_require' do
it 'works' do
file_path = 'lib/foo/bar.rb'
result = generator.to_string_value_to_require(file_path)
expect(result).to eq('foo/bar')
end
end
describe '#get_rails_helper_method_invocation_code' do
it 'works' do
method = double(:method, singleton: false, name: 'do_something', params: '(a, b)', block_params: '')
result = generator.get_rails_helper_method_invocation_code(method)
expect(result).to eq('do_something(a, b)')
end
end
describe '#get_rails_http_method' do
it 'works' do
expect(generator.get_rails_http_method('foo')).to eq('get')
expect(generator.get_rails_http_method('index')).to eq('get')
expect(generator.get_rails_http_method('new')).to eq('get')
expect(generator.get_rails_http_method('create')).to eq('post')
expect(generator.get_rails_http_method('show')).to eq('get')
expect(generator.get_rails_http_method('edit')).to eq('get')
expect(generator.get_rails_http_method('update')).to eq('put')
expect(generator.get_rails_http_method('destroy')).to eq('delete')
end
end
end
| ruby | MIT | 969d85fb9d702908ab0c6f2acc014b72a91c17e9 | 2026-01-04T17:51:47.903820Z | false |
seratch/rspec-kickstarter | https://github.com/seratch/rspec-kickstarter/blob/969d85fb9d702908ab0c6f2acc014b72a91c17e9/spec/rspec_kickstarter/rdoc_factory_spec.rb | spec/rspec_kickstarter/rdoc_factory_spec.rb | # -*- encoding: utf-8 -*-
require 'spec_helper'
require 'rspec_kickstarter/rdoc_factory'
describe RSpecKickstarter::RDocFactory do
describe '#get_rdoc_class_or_module' do
it 'works' do
file_path = 'lib/rspec_kickstarter.rb'
result = RSpecKickstarter::RDocFactory.get_rdoc_class_or_module(file_path)
expect(result).not_to be_nil
end
it 'works with Ruby 2.0' do
unless defined?(RDoc::Store)
module RDoc
class Store
end
class TopLevel
def store=(*)
end
end
end
begin
file_path = 'lib/rspec_kickstarter.rb'
result = RSpecKickstarter::RDocFactory.get_rdoc_class_or_module(file_path)
expect(result).not_to be_nil
ensure
RDoc.class_eval do
remove_const :Store
end
end
end
end
end
end
| ruby | MIT | 969d85fb9d702908ab0c6f2acc014b72a91c17e9 | 2026-01-04T17:51:47.903820Z | false |
seratch/rspec-kickstarter | https://github.com/seratch/rspec-kickstarter/blob/969d85fb9d702908ab0c6f2acc014b72a91c17e9/lib/rspec_kickstarter.rb | lib/rspec_kickstarter.rb | # -*- encoding: utf-8 -*-
require 'rspec_kickstarter/generator'
require 'rspec_kickstarter/version'
#
# RSpecKickstarter Facade
#
module RSpecKickstarter
def self.write_spec(file_path, spec_dir = './spec', force_write = false, dry_run = false)
generator = RSpecKickstarter::Generator.new(spec_dir)
generator.write_spec(file_path, force_write, dry_run)
end
end
| ruby | MIT | 969d85fb9d702908ab0c6f2acc014b72a91c17e9 | 2026-01-04T17:51:47.903820Z | false |
seratch/rspec-kickstarter | https://github.com/seratch/rspec-kickstarter/blob/969d85fb9d702908ab0c6f2acc014b72a91c17e9/lib/rspec_kickstarter/erb_factory.rb | lib/rspec_kickstarter/erb_factory.rb | # -*- encoding: utf-8 -*-
require 'erb'
require 'rspec_kickstarter'
require 'rspec_kickstarter/erb_templates'
#
# ERB instance provider
#
module RSpecKickstarter
class ERBFactory
def initialize(custom_template)
@custom_template = custom_template
end
#
# Returns ERB instance for creating new spec
#
def get_instance_for_new_spec(rails_mode, target_path)
template = get_erb_template(@custom_template, true, rails_mode, target_path)
ERB.new(template, nil, '-', '_new_spec_code')
end
#
# Returns ERB instance for appeding lacking tests
#
def get_instance_for_appending(rails_mode, target_path)
template = get_erb_template(@custom_template, false, rails_mode, target_path)
ERB.new(template, nil, '-', '_additional_spec_code')
end
private
#
# Returns ERB template
#
def get_erb_template(custom_template, is_full, rails_mode, target_path)
if custom_template
custom_template
elsif rails_mode && target_path.match(/controllers/)
get_rails_controller_template(is_full)
elsif rails_mode && target_path.match(/helpers/)
get_rails_helper_template(is_full)
else
get_basic_template(is_full)
end
end
def get_rails_controller_template(is_full)
if is_full
RSpecKickstarter::ERBTemplates::RAILS_CONTROLLER_NEW_SPEC_TEMPLATE
else
RSpecKickstarter::ERBTemplates::RAILS_CONTROLLER_METHODS_PART_TEMPLATE
end
end
def get_rails_helper_template(is_full)
if is_full
RSpecKickstarter::ERBTemplates::RAILS_HELPER_NEW_SPEC_TEMPLATE
else
RSpecKickstarter::ERBTemplates::RAILS_HELPER_METHODS_PART_TEMPLATE
end
end
def get_basic_template(is_full)
if is_full
RSpecKickstarter::ERBTemplates::BASIC_NEW_SPEC_TEMPLATE
else
RSpecKickstarter::ERBTemplates::BASIC_METHODS_PART_TEMPLATE
end
end
end
end
| ruby | MIT | 969d85fb9d702908ab0c6f2acc014b72a91c17e9 | 2026-01-04T17:51:47.903820Z | false |
seratch/rspec-kickstarter | https://github.com/seratch/rspec-kickstarter/blob/969d85fb9d702908ab0c6f2acc014b72a91c17e9/lib/rspec_kickstarter/version.rb | lib/rspec_kickstarter/version.rb | # -*- encoding: utf-8 -*-
#
# Gem version
#
module RSpecKickstarter
VERSION = '1.0.2'
end
| ruby | MIT | 969d85fb9d702908ab0c6f2acc014b72a91c17e9 | 2026-01-04T17:51:47.903820Z | false |
seratch/rspec-kickstarter | https://github.com/seratch/rspec-kickstarter/blob/969d85fb9d702908ab0c6f2acc014b72a91c17e9/lib/rspec_kickstarter/rdoc_factory.rb | lib/rspec_kickstarter/rdoc_factory.rb | # -*- encoding: utf-8 -*-
require 'rdoc'
require 'rdoc/generator'
require 'rdoc/options'
require 'rdoc/parser/ruby'
require 'rdoc/stats'
require 'rspec_kickstarter'
#
# RDoc instance factory
#
module RSpecKickstarter
class RDocFactory
#
# Returns RDoc::NormalClass/RDoc::NormalModule instance.
#
def self.get_rdoc_class_or_module(file_path)
top_level = get_ruby_parser(file_path).scan
extract_target_class_or_module(top_level)
end
#
# Creates new RDoc::Parser::Ruby instance.
#
def self.get_ruby_parser(file_path)
top_level = RDoc::TopLevel.new(file_path)
if RUBY_VERSION.to_f < 2.0
# reset is removed since 2.0
RDoc::TopLevel.reset
end
# RDoc::Stats initialization
if defined?(RDoc::Store)
# RDoc 4.0.0 requires RDoc::Store internally.
store = RDoc::Store.new
top_level.store = store
stats = RDoc::Stats.new(store, 1)
else
stats = RDoc::Stats.new(1)
end
RDoc::Parser::Ruby.new(
top_level,
file_path,
File.read(file_path),
RDoc::Options.new,
stats
)
end
#
# Extracts RDoc::NormalClass/RDoc::NormalModule from RDoc::TopLevel.
#
def self.extract_target_class_or_module(top_level)
c = top_level.classes.first
if c.nil?
m = top_level.modules.first
if m.nil?
top_level.is_a?(RDoc::NormalModule) ? top_level : nil
else
extract_target_class_or_module(m)
end
else
c
end
end
end
end
| ruby | MIT | 969d85fb9d702908ab0c6f2acc014b72a91c17e9 | 2026-01-04T17:51:47.903820Z | false |
seratch/rspec-kickstarter | https://github.com/seratch/rspec-kickstarter/blob/969d85fb9d702908ab0c6f2acc014b72a91c17e9/lib/rspec_kickstarter/generator.rb | lib/rspec_kickstarter/generator.rb | # -*- encoding: utf-8 -*-
require 'rdoc'
require 'rspec_kickstarter'
require 'rspec_kickstarter/erb_factory'
require 'rspec_kickstarter/erb_templates'
require 'rspec_kickstarter/rdoc_factory'
#
# RSpec Code Generator
#
module RSpecKickstarter
class Generator
include RSpecKickstarter::ERBTemplates
attr_accessor :spec_dir, :delta_template, :full_template
def initialize(spec_dir = './spec', delta_template = nil, full_template = nil)
@spec_dir = spec_dir.gsub(/\/$/, '')
@delta_template = delta_template
@full_template = full_template
end
#
# Writes new spec or appends to the existing spec.
#
def write_spec(file_path, force_write = false, dry_run = false, rails_mode = false)
class_or_module = RSpecKickstarter::RDocFactory.get_rdoc_class_or_module(file_path)
if class_or_module
spec_path = get_spec_path(file_path)
if force_write && File.exist?(spec_path)
append_to_existing_spec(class_or_module, dry_run, rails_mode, spec_path)
else
create_new_spec(class_or_module, dry_run, rails_mode, file_path, spec_path)
end
else
puts "#{file_path} skipped (Class/Module not found)."
end
end
#
# Gets the complete class name from RDoc::NormalClass/RDoc::NormalModule instance.
#
def get_complete_class_name(class_or_module, name = class_or_module.name)
if !class_or_module.parent.name.nil? && class_or_module.parent.is_a?(RDoc::NormalModule)
get_complete_class_name(class_or_module.parent, "#{class_or_module.parent.name}::#{name}")
else
name
end
end
#
# Returns spec file path.
# e.g. "lib/foo/bar_baz.rb" -> "spec/foo/bar_baz_spec.rb"
#
def get_spec_path(file_path)
spec_dir + '/' + file_path.gsub(/^\.\//, '').gsub(%r{^(lib/)|(app/)}, '').gsub(/\.rb$/, '_spec.rb')
end
#
# Returns string value to require.
# e.g. "lib/foo/bar_baz.rb" -> "foo/bar_baz"
#
def to_string_value_to_require(file_path)
file_path.gsub(%r{^(lib/)|(app/)}, '').gsub(/\.rb$/, '')
end
#
# Returns snake_case name.
# e.g. FooBar -> "foo_bar"
#
def instance_name(c)
c.name.
gsub(/::/, '/').
gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
gsub(/([a-z\d])([A-Z])/, '\1_\2').
tr('-', '_').
downcase
end
#
# Extracts parameter names as an *Array*.
# e.g. "()" -> []
# e.g. "(a, b = 'foo')" -> ["a", "b"]
#
def to_param_names_array(params)
params.split(',').map { |p| p.gsub(/[\(\)\s]/, '').gsub(/=.+$/, '') }.reject { |p| p.nil? || p.empty? }
end
#
# Returns params part
# e.g. ["a","b"] -> "(a, b)"
# e.g. [] -> ""
#
def to_params_part(params)
param_csv = to_param_names_array(params).join(', ')
param_csv.empty? ? '' : "(#{param_csv})"
end
#
# Creates new spec.
#
# rubocop:disable Metrics/AbcSize
def create_new_spec(class_or_module, dry_run, rails_mode, file_path, spec_path)
# These names are used in ERB template, don't delete.
# rubocop:disable Lint/UselessAssignment
methods_to_generate = class_or_module.method_list.select { |m| m.visibility == :public }
c = class_or_module
self_path = to_string_value_to_require(file_path)
# rubocop:enable Lint/UselessAssignment
erb = RSpecKickstarter::ERBFactory.new(@full_template).get_instance_for_new_spec(rails_mode, file_path)
code = erb.result(binding)
if dry_run
puts "----- #{spec_path} -----"
puts code
else
if File.exist?(spec_path)
puts "#{spec_path} already exists."
else
FileUtils.mkdir_p(File.dirname(spec_path))
File.open(spec_path, 'w') { |f| f.write(code) }
puts "#{spec_path} created."
end
end
end
# rubocop:enable Metrics/AbcSize
#
# Appends new tests to the existing spec.
#
# rubocop:disable Metrics/AbcSize
def append_to_existing_spec(class_or_module, dry_run, rails_mode, spec_path)
existing_spec = File.read(spec_path)
lacking_methods = class_or_module.method_list.
select { |m| m.visibility == :public }.
reject { |m| existing_spec.match(m.name) }
if lacking_methods.empty?
puts "#{spec_path} skipped."
else
# These names are used in ERB template, don't delete.
# rubocop:disable Lint/UselessAssignment
methods_to_generate = lacking_methods
c = class_or_module
# rubocop:enable Lint/UselessAssignment
erb = RSpecKickstarter::ERBFactory.new(@delta_template).get_instance_for_appending(rails_mode, spec_path)
additional_spec = erb.result(binding)
last_end_not_found = true
code = existing_spec.split("\n").reverse.reject { |line|
before_modified = last_end_not_found
last_end_not_found = line.gsub(/#.+$/, '').strip != 'end' if before_modified
before_modified
}.reverse.join("\n") + "\n" + additional_spec + "\nend\n"
if dry_run
puts "----- #{spec_path} -----"
puts code
else
File.open(spec_path, 'w') { |f| f.write(code) }
end
puts "#{spec_path} modified."
end
end
# rubocop:enable Metrics/AbcSize
# -----
# Code generation
# -----
#
# e.g.
# a = double('a')
# b = double('b')
# bar_baz = BarBaz.new(a, b)
#
def get_instantiation_code(c, method)
if method.singleton
''
else
constructor = c.method_list.find { |m| m.name == 'new' }
if constructor.nil?
" #{instance_name(c)} = #{get_complete_class_name(c)}.new\n"
else
get_params_initialization_code(constructor) +
" #{instance_name(c)} = #{get_complete_class_name(c)}.new#{to_params_part(constructor.params)}\n"
end
end
end
#
# e.g.
# a = double('a')
# b = double('b')
#
def get_params_initialization_code(method)
code = to_param_names_array(method.params).map { |p| " #{p} = double('#{p}')" }.join("\n")
code.empty? ? '' : "#{code}\n"
end
#
# e.g. BarBaz.do_something(a, b) { |c| }
#
def get_method_invocation_code(c, method)
target = method.singleton ? get_complete_class_name(c) : instance_name(c)
"#{target}.#{method.name}#{to_params_part(method.params)}#{get_block_code(method)}"
end
#
# e.g. do_something(a, b) { |c| }
#
def get_rails_helper_method_invocation_code(method)
"#{method.name}#{to_params_part(method.params)}#{get_block_code(method)}"
end
#
# e.g. { |a, b| }
#
def get_block_code(method)
if method.block_params.nil? || method.block_params.empty?
''
else
" { |#{method.block_params}| }"
end
end
def get_rails_http_method(method_name)
http_method = RAILS_RESOURCE_METHOD_AND_HTTP_METHOD[method_name]
http_method.nil? ? 'get' : http_method
end
RAILS_RESOURCE_METHOD_AND_HTTP_METHOD = {
'index' => 'get',
'new' => 'get',
'create' => 'post',
'show' => 'get',
'edit' => 'get',
'update' => 'put',
'destroy' => 'delete'
}
end
end
| ruby | MIT | 969d85fb9d702908ab0c6f2acc014b72a91c17e9 | 2026-01-04T17:51:47.903820Z | false |
seratch/rspec-kickstarter | https://github.com/seratch/rspec-kickstarter/blob/969d85fb9d702908ab0c6f2acc014b72a91c17e9/lib/rspec_kickstarter/erb_templates.rb | lib/rspec_kickstarter/erb_templates.rb | # -*- encoding: utf-8 -*-
require 'erb'
require 'rspec_kickstarter'
#
# ERB templates
#
module RSpecKickstarter
module ERBTemplates
BASIC_METHODS_PART_TEMPLATE = <<SPEC
<%- methods_to_generate.map { |method| %>
# TODO: auto-generated
describe '#<%= method.name %>' do
it 'works' do
<%- unless get_instantiation_code(c, method).nil? -%><%= get_instantiation_code(c, method) %><%- end -%>
<%- unless get_params_initialization_code(method).nil? -%><%= get_params_initialization_code(method) %><%- end -%>
result = <%= get_method_invocation_code(c, method) %>
expect(result).not_to be_nil
end
end
<% } %>
SPEC
BASIC_NEW_SPEC_TEMPLATE = <<SPEC
# -*- encoding: utf-8 -*-
require 'spec_helper'
<% unless rails_mode then %>require '<%= self_path %>'
<% end -%>
describe <%= get_complete_class_name(c) %> do
<%= ERB.new(BASIC_METHODS_PART_TEMPLATE, nil, '-').result(binding) -%>
end
SPEC
RAILS_CONTROLLER_METHODS_PART_TEMPLATE = <<SPEC
<%- methods_to_generate.map { |method| %>
# TODO: auto-generated
describe '<%= get_rails_http_method(method.name).upcase %> <%= method.name %>' do
it 'works' do
<%= get_rails_http_method(method.name) %> :<%= method.name %>, {}, {}
expect(response.status).to eq(200)
end
end
<% } %>
SPEC
RAILS_CONTROLLER_NEW_SPEC_TEMPLATE = <<SPEC
# -*- encoding: utf-8 -*-
require 'rails_helper'
describe <%= get_complete_class_name(c) %> do
<%= ERB.new(RAILS_CONTROLLER_METHODS_PART_TEMPLATE, nil, '-').result(binding) -%>
end
SPEC
RAILS_HELPER_METHODS_PART_TEMPLATE = <<SPEC
<%- methods_to_generate.map { |method| %>
# TODO: auto-generated
describe '#<%= method.name %>' do
it 'works' do
result = <%= get_rails_helper_method_invocation_code(method) %>
expect(result).not_to be_nil
end
end
<% } %>
SPEC
RAILS_HELPER_NEW_SPEC_TEMPLATE = <<SPEC
# -*- encoding: utf-8 -*-
require 'rails_helper'
describe <%= get_complete_class_name(c) %> do
<%= ERB.new(RAILS_HELPER_METHODS_PART_TEMPLATE, nil, '-').result(binding) -%>
end
SPEC
end
end
| ruby | MIT | 969d85fb9d702908ab0c6f2acc014b72a91c17e9 | 2026-01-04T17:51:47.903820Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/test/cie94_test.rb | test/cie94_test.rb | require 'test_helper'
describe ScorchedEarth::Services::CIE94 do
Color = Java::JavaAwt::Color # HACK
it 'can tell colors are the same' do
assert_equal 0, ScorchedEarth::Services::CIE94.new.call(Color.black, Color.black)
end
it 'can tell colors are different' do
assert_equal 9341.57053391457, ScorchedEarth::Services::CIE94.new.call(Color.black, Color.white)
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/test/test_helper.rb | test/test_helper.rb | $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
require 'bundler/setup'
require 'support/simplecov'
require 'support/null_object'
require 'scorched_earth'
require 'minitest/autorun'
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/test/game_test.rb | test/game_test.rb | require 'test_helper'
describe ScorchedEarth::Game do
before do
@game = ScorchedEarth::Game.new(800, 600)
@game.setup
end
it 'renders' do
@game.publish ScorchedEarth::Events::MouseMoved.new(0, 0)
@game.render graphics = NullObject.new
end
it 'fires when clicked' do
@game.publish ScorchedEarth::Events::MouseMoved.new(0, 0)
@game.publish ScorchedEarth::Events::MousePressed.new(0, 0)
@game.publish ScorchedEarth::Events::MouseReleased.new(0, 0)
@game.update(1)
assert @game.objects.select { |object| object.is_a? ScorchedEarth::Shot }.size, 1
end
it 'changes player when mouse is released' do
original_player = @game.current_player
@game.publish ScorchedEarth::Events::MouseReleased.new(0, 0)
@game.update(1)
assert @game.current_player != original_player
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/test/helpers_test.rb | test/helpers_test.rb | require 'test_helper'
describe ScorchedEarth::Helpers do
before do
@subject = ScorchedEarth::Helpers
end
it('#angle') { @subject.angle(1, 1).must_equal 45 }
it('#radians_to_degrees') { @subject.radians_to_degrees(Math::PI).must_equal 180 }
it('#degrees_to_radians') { @subject.degrees_to_radians(180).must_equal Math::PI }
it('#offset_x') { @subject.offset_x(45, 1).must_equal 0 }
it('#offset_y') { @subject.offset_y(45, 1).must_equal(-1) }
it('#inside_radius?') { @subject.inside_radius?(1, 1, 5) }
it('#circle') { @subject.circle(1).to_a.must_equal [[-1, 0.0], [0, 1.0], [1, 0.0]] }
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/test/deform_test.rb | test/deform_test.rb | require 'test_helper'
describe ScorchedEarth::Services::Deform do
it 'reduces' do
assert_equal [10.0, 9.0, 10.0], ScorchedEarth::Services::Deform.new([10, 10, 10]).call(1, 1)
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/test/support/simplecov.rb | test/support/simplecov.rb | require 'simplecov'
SimpleCov.add_group 'Events', 'lib/scorched_earth/events/'
SimpleCov.add_group 'Objects', 'lib/scorched_earth/objects/'
SimpleCov.add_group 'Services', 'lib/scorched_earth/services/'
SimpleCov.add_group 'Subscribers', 'lib/scorched_earth/subscribers/'
SimpleCov.add_group 'Renders', 'lib/scorched_earth/renders/'
SimpleCov.add_filter 'vendor'
SimpleCov.add_filter 'test'
SimpleCov.add_filter 'lib/scorched_earth/game_window.rb'
SimpleCov.start
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/test/support/null_object.rb | test/support/null_object.rb | class NullObject
def method_missing(*_args)
self
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth.rb | lib/scorched_earth.rb | $LOAD_PATH.unshift File.dirname(__FILE__)
require 'scorched_earth/version'
require 'scorched_earth/game'
require 'scorched_earth/game_window'
module ScorchedEarth; end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/version.rb | lib/scorched_earth/version.rb | module ScorchedEarth
VERSION = '1.0.0'.freeze
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/renders.rb | lib/scorched_earth/renders.rb | require 'scorched_earth/renders/explosion'
require 'scorched_earth/renders/mouse'
require 'scorched_earth/renders/player'
require 'scorched_earth/renders/shot'
require 'scorched_earth/renders/map'
module ScorchedEarth
module Renders
def self.find(object)
class_name = object.class.name.split('::').last
render_class = const_get class_name
render_class.new object
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/event_runner.rb | lib/scorched_earth/event_runner.rb | module ScorchedEarth
class EventRunner
attr_reader :queue, :subscribers
def initialize
@queue = Queue.new
@subscribers = []
end
def publish(event)
queue << event
end
def subscribe(klass, &block)
subscribers << [klass, block]
end
def run(event)
subscribers.each do |klass, block|
block.call event if event.is_a? klass
end
end
def process!
processing = Array.new(queue.size) { queue.pop }
processing.each do |event|
run event
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/game.rb | lib/scorched_earth/game.rb | include Java
import java.awt.Color
require 'scorched_earth/objects/player'
require 'scorched_earth/objects/shot'
require 'scorched_earth/objects/explosion'
require 'scorched_earth/objects/mouse'
require 'scorched_earth/event_runner'
require 'scorched_earth/events/game_update'
require 'scorched_earth/events/game_render'
require 'scorched_earth/subscribers/game_over/timeout'
require 'scorched_earth/subscribers/game_update/collisions'
require 'scorched_earth/subscribers/game_update/delta'
require 'scorched_earth/subscribers/game_render'
require 'scorched_earth/subscribers/hit/deform'
require 'scorched_earth/subscribers/hit/effect'
require 'scorched_earth/subscribers/hit/radius'
require 'scorched_earth/subscribers/mouse_moved'
require 'scorched_earth/subscribers/mouse_pressed'
require 'scorched_earth/subscribers/mouse_released/fire'
require 'scorched_earth/subscribers/mouse_released/next_player'
require 'scorched_earth/helpers'
require 'scorched_earth/services/color_palette'
require 'scorched_earth/services/deform'
require 'scorched_earth/services/wave'
require 'scorched_earth/renders'
module ScorchedEarth
class Game
include Helpers
Subscribers.constants.each { |name| prepend Subscribers.const_get name }
attr_reader :width, :height, :mouse,
:event_runner, :color_palette, :objects, :players, :array
def initialize(width, height)
@width = width
@height = height
@mouse = Mouse.new
end
def setup
@color_palette = Services::ColorPalette.new Color::RED, Color::YELLOW, Color::WHITE
@event_runner = EventRunner.new
@objects = []
@array = Services::Wave.new(width, height, phases = rand(10)).each.to_a # Array.new(width) { height / 4 }
@players = Array.new(2) { x = rand(width); Player.new(x, array[x]) }
end
def update(delta)
event_runner.publish Events::GameUpdate.new delta
event_runner.process!
end
def render(graphics)
event_runner.run Events::GameRender.new graphics
end
def publish(event)
event_runner.publish event
end
def current_player
players.first
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/game_window.rb | lib/scorched_earth/game_window.rb | include Java
import java.awt.event.WindowEvent
import java.awt.image.BufferStrategy
import javax.swing.JFrame
import java.awt.Canvas
import java.awt.Dimension
import javax.swing.JPanel
import java.awt.Color
require 'scorched_earth/events/mouse_pressed'
require 'scorched_earth/events/mouse_released'
require 'scorched_earth/events/mouse_moved'
module ScorchedEarth
class GameWindow
include java.awt.event.MouseMotionListener
include java.awt.event.MouseListener
attr_reader :buffer_strategy, :canvas, :game
def initialize(width, height, game)
@game = game
@container = JFrame.new
@canvas = Canvas.new
@panel = @container.get_content_pane
@container.set_default_close_operation JFrame::EXIT_ON_CLOSE
@panel.set_preferred_size Dimension.new width, height
@panel.set_layout nil
@container.set_cursor nil
@panel.add @canvas
@container.pack
@container.set_resizable false
@container.set_visible true
@canvas.set_bounds 0, 0, width, height
@canvas.add_mouse_listener self
@canvas.add_mouse_motion_listener self
@canvas.set_ignore_repaint true
@canvas.create_buffer_strategy 2
@buffer_strategy = @canvas.get_buffer_strategy
end
def run
last_time = Time.now
game.setup
loop do
delta = Time.now - last_time
last_time = Time.now
graphics = buffer_strategy.get_draw_graphics
game.update delta
game.render graphics
graphics.dispose
buffer_strategy.show
sleep 1.0 / 60
end
end
private
def mouse_moved(event)
x = event.point.x
y = event.point.y
game.publish Events::MouseMoved.new x, y
end
def mouse_dragged(*args); end
def mouse_pressed(event)
x = event.point.x
y = event.point.y
game.publish Events::MousePressed.new x, y
end
def mouse_released(event)
x = event.point.x
y = event.point.y
game.publish Events::MouseReleased.new x, y
end
def mouse_clicked(*args); end
def mouse_entered(*args); end
def mouse_exited(*args); end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/helpers.rb | lib/scorched_earth/helpers.rb | module ScorchedEarth
module Helpers
def normalize_degrees(degrees)
(degrees + 360 * 2e10) % 360
end
def angle(x, y)
normalize_degrees radians_to_degrees Math.atan2(y, x)
end
def radians_to_degrees(radians)
radians * (180 / Math::PI)
end
def degrees_to_radians(degrees)
degrees / 180 * Math::PI
end
def offset_x(degrees, radius)
Math.sin(degrees_to_radians(degrees)) * radius
end
def offset_y(degrees, radius)
- Math.cos(degrees_to_radians(degrees)) * radius
end
def circle(radius)
return enum_for(:circle, radius) unless block_given?
x = -radius
loop do
break unless x <= radius
y = Math.sqrt radius**2 - x**2
yield x, y
x += 1
end
end
def inside_radius?(x, y, radius)
x**2 + y**2 < radius**2
end
module_function :angle, :circle, :inside_radius?, :radians_to_degrees,
:degrees_to_radians, :normalize_degrees, :offset_x, :offset_y
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/services/wave.rb | lib/scorched_earth/services/wave.rb | module ScorchedEarth
module Services
class Wave
attr_reader :width, :height, :phases
def initialize(width, height, phases)
@width = width
@height = height
@phases = phases
end
def each
return enum_for(:each) unless block_given?
width.times do |index|
yield Math.sin(index.to_f / width * phases) * height / 4 + (height / 4)
end
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/services/color_palette.rb | lib/scorched_earth/services/color_palette.rb | include Java
import java.awt.Color
require 'scorched_earth/services/cie94'
module ScorchedEarth
module Services
class ColorPalette
include Enumerable
attr_reader :cache, :colors, :strategy
def initialize(*colors)
@cache = {}
@colors = colors
@strategy = Strategies::TriadMixing
end
def get(key)
cache[key] ||= begin
first
end
end
def each
return enum_for(:each) unless block_given?
loop do
color = strategy.color colors
yield color unless already_exists?(color)
end
end
def already_exists?(color)
cache.values.any? do |color2|
delta_e94 = Services::CIE94.new.call color, color2
delta_e94 < 750 # MAX: 10_0000 e.g. black vs. white
end
end
module Strategies
module TriadMixing
def self.color(colors)
sum = 0.0
colors.map do |color|
sum += ratio = rand
[color, ratio]
end.inject(Color.new(0, 0, 0)) do |mix, (color, ratio)|
scale = ratio / sum
Color.new(
(mix.red + color.red * scale).to_i,
(mix.green + color.green * scale).to_i,
(mix.blue + color.blue * scale).to_i
)
end
end
end
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/services/deform.rb | lib/scorched_earth/services/deform.rb | require 'scorched_earth/helpers'
module ScorchedEarth
module Services
class Deform
include Helpers
attr_reader :array
def initialize(array)
@array = array
end
def call(center_x, radius, center_y = array[center_x])
new_array = array.dup
circle(radius) do |offset_x, offset_y|
x = center_x + offset_x
y = array[x]
next unless y
z = offset_y * 2
q = center_y - offset_y
q = y if q > y
new_array[x] = [y - z, q, 0].max
end
new_array
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/services/cie94.rb | lib/scorched_earth/services/cie94.rb | include Java
import java.awt.Color
module ScorchedEarth
module Services
# https://github.com/halostatue/color/blob/master/lib/color/rgb.rb
class CIE94
def call(color_1, color_2, weighting_type = :graphic_arts)
color_1 = to_lab(color_1)
color_2 = to_lab(color_2)
case weighting_type
when :graphic_arts
k_1 = 0.045
k_2 = 0.015
k_L = 1
when :textiles
k_1 = 0.048
k_2 = 0.014
k_L = 2
else
raise ArgumentError, "Unsupported weighting type #{weighting_type}."
end
k_C = k_H = 1
l_1, a_1, b_1 = color_1.values_at(:L, :a, :b)
l_2, a_2, b_2 = color_2.values_at(:L, :a, :b)
delta_a = a_1 - a_2
delta_b = b_1 - b_2
c_1 = Math.sqrt((a_1**2) + (b_1**2))
c_2 = Math.sqrt((a_2**2) + (b_2**2))
delta_L = color_1[:L] - color_2[:L]
delta_C = c_1 - c_2
delta_H2 = (delta_a**2) + (delta_b**2) - (delta_C**2)
s_L = 1
s_C = 1 + k_1 * c_1
s_H = 1 + k_2 * c_1
composite_L = (delta_L / (k_L * s_L))**2
composite_C = (delta_C / (k_C * s_C))**2
composite_H = delta_H2 / ((k_H * s_H)**2)
Math.sqrt(composite_L + composite_C + composite_H)
end
private
def to_xyz(color, _color_space = :sRGB)
r, g, b = [color.red, color.green, color.blue].map do |v|
if v > 0.04045
(((v + 0.055) / 1.055)**2.4) * 100
else
(v / 12.92) * 100
end
end
# Convert using the RGB/XYZ matrix at:
# http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html#WSMatrices
{
x: (r * 0.4124564 + g * 0.3575761 + b * 0.1804375),
y: (r * 0.2126729 + g * 0.7151522 + b * 0.0721750),
z: (r * 0.0193339 + g * 0.1191920 + b * 0.9503041)
}
end
def to_lab(color, _color_space = :sRGB, reference_white = [95.047, 100.00, 108.883])
xyz = to_xyz color
xr = xyz[:x] / reference_white[0]
yr = xyz[:y] / reference_white[1]
zr = xyz[:z] / reference_white[2]
epsilon = (216 / 24_389.0)
kappa = (24_389 / 27.0)
fx, fy, fz = [xr, yr, zr].map do |t|
if t > epsilon
t**(1.0 / 3)
else # t <= epsilon
((kappa * t) + 16) / 116.0
end
end
{
L: ((116 * fy) - 16),
a: (500 * (fx - fy)),
b: (200 * (fy - fz))
}
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/renders/shot.rb | lib/scorched_earth/renders/shot.rb | include Java
import java.awt.Color
import java.awt.BasicStroke
import java.awt.geom.GeneralPath
require 'scorched_earth/renders/trajectory'
module ScorchedEarth
module Renders
class Shot
attr_reader :shot
def initialize(shot)
@shot = shot
end
def call(graphics, *_args)
ScorchedEarth::Renders::Trajectory.new(shot.trajectory).call(graphics, *_args)
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/renders/mouse.rb | lib/scorched_earth/renders/mouse.rb | include Java
import java.awt.BasicStroke
module ScorchedEarth
module Renders
class Mouse
attr_reader :mouse, :player
def initialize(mouse, player)
@mouse = mouse
@player = player
end
def call(graphics, color_palette)
return unless mouse.x && mouse.y
color = color_palette.get(player.x)
height = graphics.destination.height
graphics.set_color color
graphics.setStroke BasicStroke.new 3
graphics.draw_line mouse.x, mouse.y, player.x, height - player.y
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/renders/player.rb | lib/scorched_earth/renders/player.rb | module ScorchedEarth
module Renders
class Player
attr_reader :player
def initialize(player)
@player = player
end
def call(graphics, color_palette)
color = color_palette.get(player.x)
height = graphics.destination.height
y = height - player.y - radius / 2
graphics.set_color color
graphics.fill_oval x, y, radius, radius
end
private
def x
player.x - radius / 2
end
def radius
25
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/renders/trajectory.rb | lib/scorched_earth/renders/trajectory.rb | include Java
import java.awt.Color
import java.awt.BasicStroke
import java.awt.geom.GeneralPath
module ScorchedEarth
module Renders
class Trajectory
attr_reader :trajectory
def initialize(trajectory)
@trajectory = trajectory
end
def call(graphics, *_args)
height = graphics.destination.height
path = GeneralPath.new GeneralPath::WIND_NON_ZERO
first, *remaining = trajectory
path.move_to first[0], height - first[1]
remaining.each do |x, y|
path.line_to x, height - y
end
graphics.set_stroke BasicStroke.new 3.0, BasicStroke::CAP_ROUND, BasicStroke::JOIN_ROUND, 10.0, [10.0].to_java(:float), 0.0
graphics.set_color Color::WHITE
graphics.draw path
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/renders/explosion.rb | lib/scorched_earth/renders/explosion.rb | module ScorchedEarth
module Renders
class Explosion
attr_reader :explosion
def initialize(explosion)
@explosion = explosion
end
def call(graphics, *_args)
height = graphics.destination.height
y = height - explosion.y - radius / 2
graphics.set_color color
graphics.fill_oval x, y, radius, radius
end
private
def color
Color::WHITE
end
def radius
explosion.radius
end
def x
explosion.x - radius / 2
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/renders/map.rb | lib/scorched_earth/renders/map.rb | include Java
import java.awt.Transparency
import java.awt.Image
module ScorchedEarth
module Renders
class Map
module Cache
def to_image(graphics, color_palette)
cache(key) do
super
end
end
private
def key
array.join
end
def cache(key)
@@cache ||= {}
if value = @@cache[key]
value
else
@@cache = {}
@@cache[key] ||= begin
yield
end
end
end
end
prepend Cache
attr_reader :array
def initialize(array)
@array = array
end
def call(graphics, color_palette)
graphics.draw_image to_image(graphics, color_palette), 0, 0, nil
end
private
def to_image(graphics, color_palette)
height = graphics.destination.height
color = color_palette.get(array.class.name)
image = graphics
.get_device_configuration
.create_compatible_image width, height, java.awt.Transparency::TRANSLUCENT
image.set_acceleration_priority 1
array.each_with_index do |y, x|
image.graphics.tap do |image_graphics|
image_graphics.set_color color
image_graphics.draw_line x, height - y, x, height
end
end
image
end
def width
array.size
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/events/game_update.rb | lib/scorched_earth/events/game_update.rb | module ScorchedEarth
module Events
GameUpdate = Struct.new(:delta)
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/events/mouse_moved.rb | lib/scorched_earth/events/mouse_moved.rb | module ScorchedEarth
module Events
MouseMoved = Struct.new(:x, :y)
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/events/game_render.rb | lib/scorched_earth/events/game_render.rb | module ScorchedEarth
module Events
GameRender = Struct.new(:graphics)
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/events/mouse_pressed.rb | lib/scorched_earth/events/mouse_pressed.rb | module ScorchedEarth
module Events
MousePressed = Struct.new(:x, :y)
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/events/hit.rb | lib/scorched_earth/events/hit.rb | module ScorchedEarth
module Events
Hit = Struct.new(:object, :radius)
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/events/mouse_released.rb | lib/scorched_earth/events/mouse_released.rb | module ScorchedEarth
module Events
MouseReleased = Struct.new(:x, :y)
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/events/game_over.rb | lib/scorched_earth/events/game_over.rb | module ScorchedEarth
module Events
GameOver = Struct.new(:time)
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/subscribers/mouse_moved.rb | lib/scorched_earth/subscribers/mouse_moved.rb | module ScorchedEarth
module Subscribers
module MouseMoved
def setup
super
event_runner.subscribe(Events::MouseMoved) do |event|
@mouse = Mouse.new event.x, event.y, mouse.pressed_at
end
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/subscribers/game_render.rb | lib/scorched_earth/subscribers/game_render.rb | module ScorchedEarth
module Subscribers
module GameRender
def setup
super
event_runner.subscribe(Events::GameRender) do |event|
graphics = event.graphics
graphics.set_color color_palette.get('sky')
graphics.fill_rect 0, 0, width, height
Renders::Mouse.new(mouse, current_player).call(graphics, color_palette)
objects.each { |object| Renders.find(object).call(graphics, color_palette) }
players.each { |player| Renders.find(player).call(graphics, color_palette) }
Renders::Map.new(array).call(graphics, color_palette)
end
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/subscribers/mouse_pressed.rb | lib/scorched_earth/subscribers/mouse_pressed.rb | module ScorchedEarth
module Subscribers
module MousePressed
def setup
super
event_runner.subscribe(Events::MousePressed) do |_event|
@mouse = Mouse.new mouse.x, mouse.y, Time.now
end
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/subscribers/mouse_released/next_player.rb | lib/scorched_earth/subscribers/mouse_released/next_player.rb | module ScorchedEarth
module Subscribers
module NextPlayer
def setup
super
event_runner.subscribe(Events::MouseReleased) do |_event|
@players = players.rotate!
end
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/subscribers/mouse_released/fire.rb | lib/scorched_earth/subscribers/mouse_released/fire.rb | module ScorchedEarth
module Subscribers
module Fire
def setup
super
event_runner.subscribe(Events::MouseReleased) do |_event|
if mouse.pressed_at && mouse.x && mouse.y
shot = Shot.new current_player.x, array[current_player.x], velocity_x, velocity_y
objects << shot
end
end
end
private
def delta
(Time.now - mouse.pressed_at) * 1000 + 1000
end
def degrees
angle(height - current_player.y - mouse.y, current_player.x - mouse.x) + 180
end
def velocity_x
offset_x(degrees, delta)
end
def velocity_y
offset_y(degrees, delta)
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/subscribers/game_update/delta.rb | lib/scorched_earth/subscribers/game_update/delta.rb | module ScorchedEarth
module Subscribers
module Delta
def setup
super
event_runner.subscribe(Events::GameUpdate) do |event|
@objects = objects.map { |object| object.update event.delta }.compact
end
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/subscribers/game_update/collisions.rb | lib/scorched_earth/subscribers/game_update/collisions.rb | module ScorchedEarth
module Subscribers
module Collisions
def setup
super
event_runner.subscribe(Events::GameUpdate) do
objects
.select { |object| object.is_a? Shot }
.select { |object| array.fetch(object.x, 0) > object.y }
.each { |object| event_runner.publish Events::Hit.new(object, radius = 50) }
.each { |object| objects << object.trajectory }
.each { |object| objects.delete object }
end
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/subscribers/hit/effect.rb | lib/scorched_earth/subscribers/hit/effect.rb | require 'scorched_earth/events/hit'
module ScorchedEarth
module Subscribers
module Effect
def setup
super
event_runner.subscribe(Events::Hit) do |event|
objects << Explosion.new(event.object.x, event.object.y)
end
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/subscribers/hit/deform.rb | lib/scorched_earth/subscribers/hit/deform.rb | require 'scorched_earth/events/hit'
module ScorchedEarth
module Subscribers
module Deform
def setup
super
event_runner.subscribe(Events::Hit) do |event|
if event.object.x < array.size && event.object.x > 0
@array = Services::Deform.new(array).call(event.object.x, event.radius)
@players = players.map { |player| Player.new player.x, array[player.x] }
end
end
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/subscribers/hit/radius.rb | lib/scorched_earth/subscribers/hit/radius.rb | require 'scorched_earth/events/hit'
module ScorchedEarth
module Subscribers
module Radius
def setup
super
event_runner.subscribe(Events::Hit) do |event|
if players.any? { |player| inside_radius? event.object.x - player.x, 0, event.radius }
event_runner.publish Events::GameOver.new(Time.now + 0.25)
end
end
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/subscribers/game_over/timeout.rb | lib/scorched_earth/subscribers/game_over/timeout.rb | require 'scorched_earth/events/game_over'
module ScorchedEarth
module Subscribers
module Timeout
def setup
super
event_runner.subscribe(Events::GameOver) do |event|
event.time < Time.now ? setup : event_runner.publish(event)
end
end
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/objects/shot.rb | lib/scorched_earth/objects/shot.rb | module ScorchedEarth
class Shot
class Trajectory < Array
def initialize(*args)
super
freeze
end
def update(*_args)
self
end
end
attr_reader :x, :y, :velocity_x, :velocity_y, :trajectory
def initialize(x, y, velocity_x, velocity_y, trajectory = Trajectory.new)
@x = x
@y = y
@velocity_x = velocity_x
@velocity_y = velocity_y
@trajectory = Trajectory.new trajectory + [[x, y]]
freeze
end
def update(delta)
self.class.new(
x + velocity_x * delta,
y + velocity_y * delta,
velocity_x,
velocity_y - gravity * delta,
trajectory
)
end
def gravity
2000
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/objects/mouse.rb | lib/scorched_earth/objects/mouse.rb | module ScorchedEarth
class Mouse
attr_reader :x, :y, :pressed_at
def initialize(x = nil, y = nil, pressed_at = nil)
@x = x
@y = y
@pressed_at = pressed_at
freeze
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/objects/player.rb | lib/scorched_earth/objects/player.rb | module ScorchedEarth
class Player
attr_reader :x, :y
def initialize(x, y)
@x = x
@y = y
freeze
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
jamesmoriarty/scorched_earth | https://github.com/jamesmoriarty/scorched_earth/blob/3be74974891f26f00c96b9a9fb5696270e4fcb6a/lib/scorched_earth/objects/explosion.rb | lib/scorched_earth/objects/explosion.rb | module ScorchedEarth
class Explosion
attr_reader :x, :y, :radius
def initialize(x, y, radius = 25)
@x = x
@y = y
@radius = radius
freeze
end
def update(_delta)
self.class.new(x, y, radius + 25) if radius < 125
end
end
end
| ruby | MIT | 3be74974891f26f00c96b9a9fb5696270e4fcb6a | 2026-01-04T17:51:41.140983Z | false |
pelargir/auto-session-timeout | https://github.com/pelargir/auto-session-timeout/blob/0125651d4b310d270aab21e02c71ee7583e46023/test/test_helper.rb | test/test_helper.rb | require 'rubygems'
require 'minitest/autorun'
require 'logger'
require 'action_controller'
require File.expand_path(File.dirname(__FILE__) + '/../lib/auto-session-timeout')
| ruby | MIT | 0125651d4b310d270aab21e02c71ee7583e46023 | 2026-01-04T17:51:45.260070Z | false |
pelargir/auto-session-timeout | https://github.com/pelargir/auto-session-timeout/blob/0125651d4b310d270aab21e02c71ee7583e46023/test/auto_session_timeout_test.rb | test/auto_session_timeout_test.rb | require File.dirname(__FILE__) + '/test_helper'
describe AutoSessionTimeout do
it "tests something" do
assert true
end
end
| ruby | MIT | 0125651d4b310d270aab21e02c71ee7583e46023 | 2026-01-04T17:51:45.260070Z | false |
pelargir/auto-session-timeout | https://github.com/pelargir/auto-session-timeout/blob/0125651d4b310d270aab21e02c71ee7583e46023/test/auto_session_timeout_helper_test.rb | test/auto_session_timeout_helper_test.rb | require File.dirname(__FILE__) + '/test_helper'
describe AutoSessionTimeoutHelper do
class StubView
include AutoSessionTimeoutHelper
include ActionView::Helpers::JavaScriptHelper
include ActionView::Helpers::TagHelper
def timeout_path
"/timeout"
end
def active_path
"/active"
end
end
subject { StubView.new }
describe "#auto_session_timeout_js" do
it "returns correct JS" do
js = subject.auto_session_timeout_js
assert js.include?("window.location.href = '/timeout'")
assert js.include?("request.open('GET', '/active', true)")
assert js.include?("setTimeout(PeriodicalQuery, (60 * 1000))")
end
it "uses custom frequency when given" do
assert_match %r{120}, subject.auto_session_timeout_js(frequency: 120)
end
it "uses 60 when custom frequency is nil" do
assert_match %r{60}, subject.auto_session_timeout_js(frequency: nil)
end
it "accepts attributes" do
assert_match %r{data-turbolinks-eval="false"}, subject.auto_session_timeout_js(attributes: { 'data-turbolinks-eval': 'false' })
end
end
end
| ruby | MIT | 0125651d4b310d270aab21e02c71ee7583e46023 | 2026-01-04T17:51:45.260070Z | false |
pelargir/auto-session-timeout | https://github.com/pelargir/auto-session-timeout/blob/0125651d4b310d270aab21e02c71ee7583e46023/lib/auto_session_timeout_helper.rb | lib/auto_session_timeout_helper.rb | module AutoSessionTimeoutHelper
def auto_session_timeout_js(options={})
frequency = options[:frequency] || 60
attributes = options[:attributes] || {}
code = <<JS
function PeriodicalQuery() {
var request = new XMLHttpRequest();
request.onload = function (event) {
var status = event.target.status;
var response = event.target.response;
if (status === 200 && (response === false || response === 'false' || response === null)) {
window.location.href = '#{timeout_path}';
}
};
request.open('GET', '#{active_path}', true);
request.responseType = 'json';
request.send();
setTimeout(PeriodicalQuery, (#{frequency} * 1000));
}
setTimeout(PeriodicalQuery, (#{frequency} * 1000));
JS
javascript_tag(code, attributes)
end
end
ActionView::Base.send :include, AutoSessionTimeoutHelper
| ruby | MIT | 0125651d4b310d270aab21e02c71ee7583e46023 | 2026-01-04T17:51:45.260070Z | false |
pelargir/auto-session-timeout | https://github.com/pelargir/auto-session-timeout/blob/0125651d4b310d270aab21e02c71ee7583e46023/lib/auto-session-timeout.rb | lib/auto-session-timeout.rb | require 'auto_session_timeout'
require 'auto_session_timeout_helper' | ruby | MIT | 0125651d4b310d270aab21e02c71ee7583e46023 | 2026-01-04T17:51:45.260070Z | false |
pelargir/auto-session-timeout | https://github.com/pelargir/auto-session-timeout/blob/0125651d4b310d270aab21e02c71ee7583e46023/lib/auto_session_timeout.rb | lib/auto_session_timeout.rb | module AutoSessionTimeout
def self.included(controller)
controller.extend ClassMethods
end
module ClassMethods
def auto_session_timeout(seconds=nil)
prepend_before_action do |c|
if session_expired?(c) && !signing_in?(c)
handle_session_reset(c)
else
unless c.request.original_url.start_with?(c.send(:active_url))
offset = seconds || (current_user.respond_to?(:auto_timeout) ? current_user.auto_timeout : nil)
c.session[:auto_session_expires_at] = Time.now + offset if offset && offset > 0
end
end
end
end
def auto_session_timeout_actions
define_method(:active) { render_session_status }
define_method(:timeout) { render_session_timeout }
end
end
def render_session_status
response.headers["Etag"] = nil # clear etags to prevent caching
render plain: !!current_user, status: 200
end
def render_session_timeout
flash[:notice] = t("devise.failure.timeout", default: "Your session has timed out.")
redirect_to sign_in_path
end
private
def handle_session_reset(c)
c.send :reset_session
end
def signing_in?(c)
c.request.env["PATH_INFO"] == sign_in_path && c.request.env["REQUEST_METHOD"] == "POST"
end
def session_expired?(c)
c.session[:auto_session_expires_at].try(:<, Time.now)
end
def sign_in_path
user_session_path
rescue
"/login"
end
end
ActionController::Base.send :include, AutoSessionTimeout
| ruby | MIT | 0125651d4b310d270aab21e02c71ee7583e46023 | 2026-01-04T17:51:45.260070Z | false |
pelargir/auto-session-timeout | https://github.com/pelargir/auto-session-timeout/blob/0125651d4b310d270aab21e02c71ee7583e46023/lib/auto/session/timeout.rb | lib/auto/session/timeout.rb | require "auto/session/timeout/version"
module Auto
module Session
module Timeout
# Your code goes here...
end
end
end
| ruby | MIT | 0125651d4b310d270aab21e02c71ee7583e46023 | 2026-01-04T17:51:45.260070Z | false |
pelargir/auto-session-timeout | https://github.com/pelargir/auto-session-timeout/blob/0125651d4b310d270aab21e02c71ee7583e46023/lib/auto/session/timeout/version.rb | lib/auto/session/timeout/version.rb | module Auto
module Session
module Timeout
VERSION = "1.3"
end
end
end
| ruby | MIT | 0125651d4b310d270aab21e02c71ee7583e46023 | 2026-01-04T17:51:45.260070Z | false |
picatz/shodanz | https://github.com/picatz/shodanz/blob/134eac5265d700efe1b6eec004dc3c25270cbc6c/spec/rest_api_spec.rb | spec/rest_api_spec.rb | require "spec_helper"
RSpec.describe Shodanz::API::REST do
include_context Async::RSpec::Reactor
before do
@client = Shodanz.api.rest.new
end
before(:each) do
# try to avoid rate limit
sleep 3
end
describe '#scan' do
it 'should be able to scan a host on the internet' do
resp = @client.scan("1.1.1.1").wait
expect(resp).to be_a(Hash)
expect(resp["count"]).to be_a(Integer)
expect(resp["count"]).to eq(1)
expect(resp["id"]).to be_a(String)
expect(resp["credits_left"]).to be_a(Integer)
end
it 'should be able to scan multiple hosts on the internet' do
resp = @client.scan("1.1.1.1", "8.8.8.8").wait
expect(resp).to be_a(Hash)
expect(resp["count"]).to be_a(Integer)
expect(resp["count"]).to eq(2)
expect(resp["id"]).to be_a(String)
expect(resp["credits_left"]).to be_a(Integer)
end
end
describe '#info' do
it 'returns info about the underlying token' do
resp = @client.info.wait
expect(resp).to be_a(Hash)
end
end
describe '#host' do
let(:ip) { "8.8.8.8" }
it 'returns all services that have been found on the given host IP' do
resp = @client.host(ip).wait
expect(resp).to be_a(Hash)
end
end
describe '#host_count' do
let(:query) { "apache" }
it 'returns the total number of results that matches a given query' do
resp = @client.host_count(query).wait
expect(resp).to be_a(Hash)
end
end
describe '#host_search' do
let(:query) { "apache" }
it 'returns the total number of results that matches a given query' do
resp = @client.host_search(query).wait
expect(resp).to be_a(Hash)
end
end
describe '#host_search_tokens' do
let(:query) { "apache" }
it 'returns a parsed version of the query' do
resp = @client.host_search_tokens(query).wait
expect(resp).to be_a(Hash)
expect(resp['attributes']).to be_a(Hash)
expect(resp['errors']).to be_a(Array)
expect(resp['filters']).to be_a(Array)
expect(resp['string']).to be_a(String)
expect(resp['string']).to eq(query)
end
end
describe '#ports' do
it 'returns a list of port numbers that the crawlers are looking for' do
resp = @client.ports.wait
expect(resp).to be_a(Array)
end
end
describe '#protocols' do
it 'returns all protocols that can be used when performing on-demand scans' do
resp = @client.protocols.wait
expect(resp).to be_a(Hash)
end
end
describe '#profile' do
it 'returns information about the shodan account' do
resp = @client.profile.wait
expect(resp).to be_a(Hash)
expect(resp["member"]).to be(true).or be(false)
expect(resp["credits"]).to be_a(Integer)
expect(resp["created"]).to be_a(String)
expect(resp.key?("display_name")).to be(true)
end
end
describe '#community_queries' do
it 'obtains a list of search queries that users have saved' do
resp = @client.community_queries.wait
expect(resp).to be_a(Hash)
expect(resp['total']).to be_a(Integer)
expect(resp['matches']).to be_a(Array)
example_match = resp['matches'].first
expect(example_match['votes']).to be_a(Integer)
expect(example_match['description']).to be_a(String)
expect(example_match['tags']).to be_a(Array)
expect(example_match['timestamp']).to be_a(String)
expect(example_match['title']).to be_a(String)
expect(example_match['query']).to be_a(String)
end
end
describe '#search_for_community_query' do
let(:query) { "apache" }
it 'search the directory of search queries that users have saved' do
resp = @client.search_for_community_query(query).wait
expect(resp).to be_a(Hash)
expect(resp['total']).to be_a(Integer)
expect(resp['matches']).to be_a(Array)
example_match = resp['matches'].first
expect(example_match['votes']).to be_a(Integer)
expect(example_match['description']).to be_a(String)
expect(example_match['tags']).to be_a(Array)
expect(example_match['timestamp']).to be_a(String)
expect(example_match['title']).to be_a(String)
expect(example_match['query']).to be_a(String)
end
end
describe '#resolve' do
let(:hostname) { "google.com" }
it 'resolves domains to ip addresses' do
resp = @client.resolve(hostname).wait
expect(resp).to be_a(Hash)
end
end
describe '#reverse_lookup' do
let(:ip) { '8.8.8.8' }
it 'resolves ip addresses to domains' do
resp = @client.reverse_lookup(ip).wait
expect(resp).to be_a(Hash)
expect('8.8.8.8').not_to be nil
end
end
describe '#http_headers' do
it 'shows the HTTP headers that your client sends when connecting to a webserver' do
resp = @client.http_headers.wait
expect(resp).to be_a(Hash)
expect(resp['Content-Length']).to be_a(String)
expect(resp['Content-Length']).to eq('')
# TODO maybe specify a content-type?
expect(resp['Content-Type']).to be_a(String)
expect(resp['Content-Type']).to eq('')
expect(resp['Host']).to be_a(String)
expect(resp['Host']).to eq('api.shodan.io')
end
end
describe '#my_ip' do
it 'shows the current IP address as seen from the internet' do
resp = @client.my_ip.wait
expect(resp).to be_a(String)
end
end
end
| ruby | MIT | 134eac5265d700efe1b6eec004dc3c25270cbc6c | 2026-01-04T17:51:46.633447Z | false |
picatz/shodanz | https://github.com/picatz/shodanz/blob/134eac5265d700efe1b6eec004dc3c25270cbc6c/spec/exploits_api_spec.rb | spec/exploits_api_spec.rb | require "spec_helper"
RSpec.describe Shodanz::API::Exploits do
include_context Async::RSpec::Reactor
before do
@client = Shodanz.api.exploits.new
end
before(:each) do
# try to avoid rate limit
sleep 3
end
describe '#search' do
it 'should search across a variety of data sources for exploits' do
resp = @client.search("SQL", port: 443).wait
expect(resp).to be_a(Hash)
end
end
end
| ruby | MIT | 134eac5265d700efe1b6eec004dc3c25270cbc6c | 2026-01-04T17:51:46.633447Z | false |
picatz/shodanz | https://github.com/picatz/shodanz/blob/134eac5265d700efe1b6eec004dc3c25270cbc6c/spec/shodanz_spec.rb | spec/shodanz_spec.rb | require "spec_helper"
RSpec.describe Shodanz do
it "has a version number" do
expect(Shodanz::VERSION).not_to be nil
end
end
| ruby | MIT | 134eac5265d700efe1b6eec004dc3c25270cbc6c | 2026-01-04T17:51:46.633447Z | false |
picatz/shodanz | https://github.com/picatz/shodanz/blob/134eac5265d700efe1b6eec004dc3c25270cbc6c/spec/streaming_api_spec.rb | spec/streaming_api_spec.rb | require "spec_helper"
RSpec.describe Shodanz::API::Streaming do
include_context Async::RSpec::Reactor
before do
@client = Shodanz.api.streaming.new
end
before(:each) do
# try to avoid rate limit
sleep 1
end
describe '#banners' do
it "should stream any banner data Shodan collects" do
@client.banners(limit: 1) do |banner|
expect(banner).to be_a(Hash)
end
end
end
end
| ruby | MIT | 134eac5265d700efe1b6eec004dc3c25270cbc6c | 2026-01-04T17:51:46.633447Z | false |
picatz/shodanz | https://github.com/picatz/shodanz/blob/134eac5265d700efe1b6eec004dc3c25270cbc6c/spec/spec_helper.rb | spec/spec_helper.rb | require "bundler/setup"
require "async/rspec"
require "shodanz"
require "pry"
require "readline"
RSpec.configure do |config|
# Enable flags like --only-failures and --next-failure
config.example_status_persistence_file_path = ".rspec_status"
# Disable RSpec exposing methods globally on `Module` and `main`
config.disable_monkey_patching!
config.expect_with :rspec do |c|
c.syntax = :expect
end
end
| ruby | MIT | 134eac5265d700efe1b6eec004dc3c25270cbc6c | 2026-01-04T17:51:46.633447Z | false |
picatz/shodanz | https://github.com/picatz/shodanz/blob/134eac5265d700efe1b6eec004dc3c25270cbc6c/examples/async_host_search_example.rb | examples/async_host_search_example.rb | $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
require 'async'
require 'shodanz'
client = Shodanz.client.new
webservers = ['apache', 'nginx', 'caddy', 'lighttpd', 'cherokee']
# we can use methods sequentially
started = Time.now.sec
webservers.each do |webserver|
# make HTTP request
client.rest_api.host_search(webserver)
# print webserver to STDOUT
puts webserver
end
puts "Sequential took #{Time.now.sec - started} seconds"
# we can also use methods asyncronously
started = Time.now.sec
Async do
webservers.each do |webserver|
# make HTTP request
client.rest_api.host_search(webserver)
# print webserver to STDOUT
puts webserver
end
end
puts "Asyncronous took #{Time.now.sec - started} seconds"
| ruby | MIT | 134eac5265d700efe1b6eec004dc3c25270cbc6c | 2026-01-04T17:51:46.633447Z | false |
picatz/shodanz | https://github.com/picatz/shodanz/blob/134eac5265d700efe1b6eec004dc3c25270cbc6c/examples/async_honeypot_detector.rb | examples/async_honeypot_detector.rb | # frozen_string_literal: true
$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
require 'async'
require 'shodanz'
client = Shodanz.client.new
client.streaming_api.banners do |banner|
if ip = banner['ip_str']
Async do
score = client.rest_api.honeypot_score(ip).wait
puts "#{ip} has a #{score * 100}% chance of being a honeypot"
rescue Shodanz::Errors::RateLimited
sleep rand
retry
rescue StandardError # any other errors
next
end
end
end
| ruby | MIT | 134eac5265d700efe1b6eec004dc3c25270cbc6c | 2026-01-04T17:51:46.633447Z | false |
picatz/shodanz | https://github.com/picatz/shodanz/blob/134eac5265d700efe1b6eec004dc3c25270cbc6c/examples/debug.rb | examples/debug.rb | $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
require 'shodanz'
require 'pry'
# rest_api = Shodanz.api.rest.new
# streaming_api = Shodanz.api.streaming.new
# exploits_api = Shodanz.api.exploits.new
client = Shodanz.client.new
binding.pry
| ruby | MIT | 134eac5265d700efe1b6eec004dc3c25270cbc6c | 2026-01-04T17:51:46.633447Z | false |
picatz/shodanz | https://github.com/picatz/shodanz/blob/134eac5265d700efe1b6eec004dc3c25270cbc6c/examples/top_10_countries_running.rb | examples/top_10_countries_running.rb | $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
require 'shodanz'
require 'command_lion'
require 'yaml'
require 'pry'
module Top10
@rest_api = Shodanz.api.rest.new
def self.check(product)
begin
@rest_api.host_count(product: product, facets: { country: 10 })["facets"]["country"].collect { |x| x.values }.to_h.invert
rescue
puts "Unable to succesffully check the Shodan API."
exit 1
end
end
end
CommandLion::App.run do
name "Top 10 Countires Running a Product Using Shodan"
command :product do
description "Search for this given product."
type :string
flag "--product"
# Check is Shodan Enviroemnt Variable Set
before do
unless ENV['SHODAN_API_KEY']
puts "Need to set the 'SHODAN_API_KEY' enviroment variable before using this app!"
exit 1 # [ ╯´･ω･]╯︵┸━┸)
end
if argument.empty?
puts "What kind of nonsense is this?! You need to provide some argument..."
exit 1 # [ ╯ ﾟ▽ﾟ]╯︵┻━┻)
end
end
# Do stuff.
action do
result = Top10.check(argument)
if options[:json].given?
puts JSON.pretty_generate(result)
elsif options[:yaml].given?
puts result.to_yaml
else
result.each do |country, count|
puts "#{country}\t#{count}"
end
end
end
option :json do
description "Use JSON as the format to output to STDOUT."
flag "--json"
end
option :yaml do
description "Use YAML as the format to output to STDOUT."
flag "--yaml"
end
end
end
| ruby | MIT | 134eac5265d700efe1b6eec004dc3c25270cbc6c | 2026-01-04T17:51:46.633447Z | false |
picatz/shodanz | https://github.com/picatz/shodanz/blob/134eac5265d700efe1b6eec004dc3c25270cbc6c/examples/streaming_banner_product_stats.rb | examples/streaming_banner_product_stats.rb | $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
require 'shodanz'
# clean CTRL+C exit
trap "SIGINT" do
exit 0
end
# streaming API client
streaming_api = Shodanz.api.streaming.new
# every key's value starts at zero
stats = Hash.new(0)
# collect banners
streaming_api.banners do |banner|
product = banner['product']
next if product.nil?
puts "#{stats[product] += 1} #{product}"
end
| ruby | MIT | 134eac5265d700efe1b6eec004dc3c25270cbc6c | 2026-01-04T17:51:46.633447Z | false |
picatz/shodanz | https://github.com/picatz/shodanz/blob/134eac5265d700efe1b6eec004dc3c25270cbc6c/examples/async_stream_example.rb | examples/async_stream_example.rb | $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
require 'pry'
require 'async'
require 'shodanz'
client = Shodanz.client.new
stats = Hash.new(0)
ports = [21, 22, 80, 443]
services = ['ftp', 'ssh', 'http', 'https']
ports_with_service_names = ports.zip(services)
Async do
# collect banners for ports
ports_with_service_names.each do |port, service|
client.streaming_api.banners_on_port(port) do |banner|
if ip = banner['ip_str']
Async do
resp = client.rest_api.honeypot_score(ip).wait
binding.pry if resp.nil?
puts "#{ip} has a #{resp *100}% chance of being a honeypot"
rescue Shodanz::Errors::RateLimited
sleep 1
retry
rescue => error
binding.pry
end
end
end
end
end
| ruby | MIT | 134eac5265d700efe1b6eec004dc3c25270cbc6c | 2026-01-04T17:51:46.633447Z | false |
picatz/shodanz | https://github.com/picatz/shodanz/blob/134eac5265d700efe1b6eec004dc3c25270cbc6c/examples/top_10_countries_running_apache_chart.rb | examples/top_10_countries_running_apache_chart.rb | $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
require "shodanz"
require "chart_js"
module Top10
@rest_api = Shodanz.api.rest.new
def self.check(product)
begin
@rest_api.host_count(product: product, facets: { country: 10 })["facets"]["country"].collect { |x| x.values }.to_h.invert
rescue
puts "Unable to succesffully check the Shodan API."
exit 1
end
end
end
results = Top10.check("apache")
ChartJS.bar do
file "top_10_apache.html"
data do
labels results.keys
dataset "Countries" do
color :random
data results.values
end
end
end
| ruby | MIT | 134eac5265d700efe1b6eec004dc3c25270cbc6c | 2026-01-04T17:51:46.633447Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.