test-runner 0.9.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1a7128fa65cf1e03aeb992c6e20a26ae50a3d1bc
+  data.tar.gz: cd3992292f6c60cb9916877f7512095c22a536fc
+SHA512:
+  metadata.gz: e2971ffd2f61a4315928da41273c2c55f9c9a113ac90f27b2133425dbbf7e0897203886b25a0f447c98e9f06270c1f93e77617a05e319be73c5038ae7c353842
+  data.tar.gz: 226c1c6b629d0ccd23d43ed502b97dd232d9c0043dea6dded2f0469976b7a5b591e4d48e4cbd97fd57357937df13cf2c53ab60a65f9ff6d88ba83230419c0ca2

data/bin/test-runner

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+lib_path = File.join Dir.pwd, "lib"
+if File.directory? lib_path and not $LOAD_PATH.include? lib_path
+  $LOAD_PATH << lib_path
+end
+require "test_runner"
+TestRunner::CLI.run ARGV

data/lib/test_runner.rb

@@ -0,0 +1,38 @@
+require "logger"
+require "logger/logging"
+
+module TestRunner
+  autoload :Assert, "test_runner/assert"
+  autoload :BacktraceFilter, "test_runner/backtrace_filter"
+  autoload :ColoredLogger, "test_runner/colored_logger"
+  autoload :Config, "test_runner/config"
+  autoload :CLI, "test_runner/cli"
+  autoload :Runner, "test_runner/runner"
+  autoload :Util, "test_runner/util"
+
+  # TestRunner can be included in scripts as a mixin, e.g.
+  #
+  # require "test_runner"
+  # include TestRunner
+  #
+  # logger.info "hi"
+  # assert true
+  #
+  # You can also require "test_runner/script" to automatically include TestRunner
+  def logger
+    Config.logger
+  end
+
+  # Describe, context, it, and specify can help break up a larger test script
+  # into chunks. Blocks are run # immediately; this is cosmetic enhancement
+  # that also enables some degree of compatibility with other frameworks.
+  %i(context describe it specify).each do |method_name|
+    define_method method_name do |msg, &blk|
+      blk.() if blk
+    end
+  end
+
+  def self.included target
+    Assert::Syntax.infect target
+  end
+end

data/lib/test_runner/assert.rb

@@ -0,0 +1,15 @@
+require_relative "assert/assertion"
+require_relative "assert/check"
+require_relative "assert/checks"
+require_relative "assert/errors"
+require_relative "assert/syntax"
+
+module TestRunner
+  module Assert
+    def self.inspect object, truncate = 100
+      raw = object.inspect
+      return raw if raw.size <= truncate
+      "#{raw[0..truncate - 2]} …\""
+    end
+  end
+end

data/lib/test_runner/assert/assertion.rb

@@ -0,0 +1,116 @@
+module TestRunner
+  module Assert
+    class Assertion
+      attr_reader :fails
+      attr_reader :passes
+      attr_accessor :source
+
+      def initialize subject_proc, checks
+        @subject_proc = subject_proc
+        @checks = checks
+        @passes = []
+        @fails  = []
+        @trace = caller_locations
+      end
+
+      def call
+        perform_checks
+        freeze
+        raise to_error if failed?
+        subject
+      end
+
+      def build_checks
+        @checks.map do |check_name, argument|
+          TestRunner::Config.internal_logger.debug "Resolving check #{check_name.inspect}, arg=#{argument.inspect}"
+          resolve_check check_name, argument
+        end
+      end
+
+      def failed?
+        fails.any?
+      end
+
+      def file
+        @trace[0].path
+      end
+
+      def freeze
+        passes.freeze
+        fails.freeze
+      end
+
+      def line
+        @trace[0].lineno
+      end
+
+      def passed?
+        not failed?
+      end
+
+      def perform_checks
+        build_checks.each do |check|
+          check.evaluate
+          ary = if check.passed? then passes else fails end
+          ary.push check
+        end
+      end
+
+      def resolve_check check_name, argument
+        check = Checks.resolve check_name do
+          check_name = :include if check_name == :includes
+          argument = [check_name, *argument]
+          Checks[:predicate]
+        end
+        check.new subject_thunk, argument
+      end
+
+      def subject
+        subject_thunk.call
+      end
+
+      def subject_thunk
+        @subject_thunk ||= SubjectThunk.new @subject_proc
+      end
+
+      def to_error
+        AssertionFailed.new self
+      end
+
+      def trace
+        BacktraceFilter.(@trace)
+      end
+
+      class Refutation < Assertion
+        def build_checks
+          super.each &:negate
+        end
+      end
+
+      class SubjectThunk
+        def initialize block
+          @block = block
+        end
+
+        def call
+          return @subject if subject_resolved?
+          @subject = @block.call
+        end
+
+        def expect_error
+          raise "called after initially fetched" if subject_resolved?
+          @block.call
+          nothing_raised = true
+        rescue => error
+          @subject = error
+        ensure
+          raise NothingRaised.new if nothing_raised
+        end
+
+        def subject_resolved?
+          instance_variable_defined? :@subject
+        end
+      end
+    end
+  end
+end

data/lib/test_runner/assert/check.rb

@@ -0,0 +1,53 @@
+module TestRunner
+  module Assert
+    class Check
+      singleton_class.send :attr_reader, :block, :name
+
+      attr :argument
+
+      def initialize subject_thunk, argument
+        @argument = argument
+        @subject_thunk = subject_thunk
+      end
+
+      def evaluate
+        self.class.block.call self, @argument
+        freeze
+      end
+
+      def expect_error
+        @subject_thunk.expect_error
+      end
+
+      def fail message
+        passed = negated? ^ yield
+        @fail_message = message unless passed
+      end
+
+      def fail_message
+        "expected #{Assert.inspect subject} to#{" not" if negated?} #{@fail_message}"
+      end
+
+      def failed?
+        @fail_message ? true : false
+      end
+
+      def negated?
+        @negated ? true : false
+      end
+
+      def negate
+        @negated = !@negated
+      end
+
+      def passed?
+        not failed?
+      end
+
+      def subject
+        @expected_error or @subject_thunk.call
+      end
+
+    end
+  end
+end

data/lib/test_runner/assert/checks.rb

@@ -0,0 +1,76 @@
+module TestRunner
+  module Assert
+    module Checks
+      require_relative "checks/registry"
+      extend Registry
+
+      register :equals do |check, object|
+        obj_inspect = Assert.inspect object
+
+        if Assert.inspect(check.subject) == obj_inspect and not check.negated?
+          fail_message = "equal other object (no difference in #inspect output)"
+        else
+          fail_message = "equal #{obj_inspect}"
+        end
+
+        check.fail fail_message do check.subject == object end
+      end
+
+      register :included_in do |check, list|
+        check.fail "be included in #{Assert.inspect list}" do
+          list.include? check.subject
+        end
+      end
+
+      register :kind_of do |check, type|
+        check.fail "be a kind of #{type}" do
+          check.subject.kind_of? type
+        end
+      end
+
+      register :matches do |check, matcher|
+        check.fail "match #{Assert.inspect matcher}" do
+          check.subject.match matcher
+        end
+      end
+
+      register :predicate do |check, argument|
+        name, *args = argument
+        method_name =  "#{name}?"
+        method = check.subject.method method_name
+
+        if method.arity == 0
+          expect_truth = args.all?
+          message = "be #{name}"
+          result = check.subject.public_send method_name
+          result = result ^ !expect_truth
+        else
+          result = check.subject.public_send method_name, *args
+          args = args.map &Assert.method(:inspect)
+          message = "#{name} #{args * ', '}"
+        end
+
+        check.fail message do result end
+      end
+
+      register :raises do |check, error_type|
+        check.expect_error
+        check.fail "be a #{Assert.inspect error_type}" do
+          check.subject.is_a? error_type
+        end
+      end
+
+      register :responds_to do |check, method_name|
+        check.fail "respond to ##{method_name}" do
+          check.subject.respond_to? method_name
+        end
+      end
+
+      register :truthy do |check, arg|
+        check.fail "be #{arg ? "truthy" : "falsey"}" do
+          !arg ^ check.subject
+        end
+      end
+    end
+  end
+end

data/lib/test_runner/assert/checks/registry.rb

@@ -0,0 +1,31 @@
+module TestRunner
+  module Assert
+    module Checks
+      module Registry
+        def self.extended base
+          base.instance_variable_set :@registry, {}
+        end
+
+        def self.define check_name, block
+          klass = Class.new Check
+          klass.instance_variable_set :@block, block
+          constant_name = Util.to_camel_case check_name
+          const_set constant_name, klass
+          klass
+        end
+
+        attr :registry
+
+        def register check_name, &block
+          registry[check_name] = Registry.define check_name, block
+        end
+
+        def resolve check_name, &block
+          block ||= -> * do raise MissingCheck.new check_name end
+          registry.fetch check_name, &block
+        end
+        alias_method :[], :resolve
+      end
+    end
+  end
+end

data/lib/test_runner/assert/errors.rb

@@ -0,0 +1,46 @@
+module TestRunner
+  module Assert
+    Error = Class.new StandardError
+
+    class AssertionFailed < Error
+      attr :assertion
+
+      def initialize assertion
+        @assertion = assertion
+      end
+
+      def backtrace
+        assertion.trace.map &:to_s
+      end
+
+      def to_s
+        failures = assertion.fails.map do |failed_check|
+          failed_check.fail_message
+        end
+        if failures.size > 1
+          "Assertion failure:\n\n    * #{failures * "\n    * "}\n"
+        else
+          "Assertion failure: #{failures * ", "}"
+        end
+      end
+    end
+
+    class MissingCheck < Error
+      attr :check_name
+
+      def initialize check_name
+        @check_name = check_name
+      end
+
+      def to_s
+        "could not resolve check #{check_name.inspect}"
+      end
+    end
+
+    class NothingRaised < Error
+      def to_s
+        "expected subject block to raise an error"
+      end
+    end
+  end
+end

data/lib/test_runner/assert/syntax.rb

@@ -0,0 +1,94 @@
+module TestRunner
+  module Assert
+    class Syntax < Module
+      MISSING = :__test_runner_assert_arg_missing__
+
+      class << self
+        def infect target
+          instance = new
+          if target.is_a? Class
+            target.send :include, instance
+          else
+            target.extend instance
+          end
+        end
+
+        # Public: assert is designed to be called a number of different ways,
+        # from 0 to 2 positional arguments, and maybe a block.
+        #
+        # subject_or_checks - the first optional argument passed in
+        # checks - the second optional argument passed in
+        # block - the &block parameter
+        #
+        # Valid examples:
+        #
+        #   assert :raises => Error do … end
+        #   assert "foo"
+        #   assert 3, :included_in => [6, 3]
+        #   assert [6, 3], :includes => 3
+        #   assert :equal => 4 do 2 + 2 end
+        #
+        # Invalid examples:
+        #
+        #   # Can't determine if the block or 2 is the subject
+        #   assert 2, :equals => 4 do ̒… end 
+        #   # There's no subject at all
+        #   assert :incuded_in => 4
+        #
+        # Returns two arguments, the subject, and a checks hash. If the checks
+        # would be empty, returns { :truthy => true }. The subject will always be
+        # a Proc that gets lazy evaluated when the assertion is checked.
+        def decode_assert_arguments subject_or_checks, checks, block
+          if checks == MISSING
+            if subject_or_checks == MISSING
+              missing_subject! unless block
+              subject_thunk = block
+              checks = { :truthy => true }
+            elsif block
+              ambiguous_subject! unless subject_or_checks.is_a? Hash
+              subject_thunk = block
+              checks = subject_or_checks
+            else
+              subject_thunk = -> do subject_or_checks end
+              checks = { :truthy => true }
+            end
+          else
+            ambiguous_subject! if block
+            subject_thunk = -> do subject_or_checks end
+          end
+          [subject_thunk, checks]
+        end
+
+        def ambiguous_subject!
+          raise ArgumentError, "cannot supply a block subject *and* a positional subject"
+        end
+
+        def missing_subject!
+          raise ArgumentError, "must supply either a positional subject *or* a block subject (but not both)"
+        end
+      end
+
+      def extended base
+        graft base.singleton_class
+      end
+
+      def included base
+        graft base
+      end
+
+      def graft base
+        method_body = -> method_name, assertion_class, syntax do
+          define_method method_name do |arg1 = MISSING, arg2 = MISSING, &block|
+            subject_thunk, checks = syntax.decode_assert_arguments arg1, arg2, block
+            assertion = assertion_class.new subject_thunk, checks
+            assertion.source = self
+            assertion.()
+          end
+        end
+
+        base.class_exec :assert, Assertion, self.class, &method_body
+        base.class_exec :refute, Assertion::Refutation, self.class, &method_body
+      end
+    end
+  end
+end

data/lib/test_runner/backtrace_filter.rb

@@ -0,0 +1,25 @@
+module TestRunner
+  module BacktraceFilter
+    extend self
+
+    def call trace
+      return trace unless Config.trim_backtraces
+
+      entry_point = trace.last
+      test_runner_root = File.expand_path "../..", __FILE__
+
+      first_pass = trace.drop_while do |location|
+        full_path = File.expand_path location.to_s
+        full_path.start_with? test_runner_root
+      end
+
+      second_pass = first_pass.take_while do |location|
+        full_path = File.expand_path location.to_s
+        not full_path.start_with? test_runner_root
+      end
+
+      second_pass << entry_point unless second_pass.last == entry_point
+      second_pass
+    end
+  end
+end

data/lib/test_runner/cli.rb

@@ -0,0 +1,196 @@
+require "optparse"
+
+module TestRunner
+  class CLI
+    def self.run argv
+      instance = new argv, $stdout
+      instance.()
+    end
+
+    attr_reader :options
+
+    def initialize argv, stdout
+      @argv   = argv
+      @stdout = stdout
+    end
+
+    def call
+      @options = ArgvParser.(@argv)
+      setup_config
+      Runner.(filter_files) or exit 1
+    end
+
+    def setup_config
+      Config.child_count = options.child_count
+      Config.fail_fast = options.fail_fast?
+      Config.logger = build_logger
+      Config.reverse_backtraces = options.reverse_backtraces?
+      Config.trim_backtraces = options.trim_backtraces?
+    end
+
+    def build_logger
+      logger = Logger.new @stdout
+      logger.level = options.log_level
+      logger.progname = "test_runner"
+      logger
+    end
+
+    def filter_files
+      resolve_files.reject do |path|
+        path.end_with? "init.rb"
+      end
+    end
+
+    def resolve_files
+      options.paths.flat_map do |path|
+        if path.end_with? ".rb"
+          [path]
+        else
+          Dir[File.join path, "**/*.rb"]
+        end
+      end
+    end
+
+    class Options
+      def self.build
+        if ENV["TEST_RUNNER_VERBOSE"]
+          log_level = Logger::DEBUG
+        else
+          log_level = Logger::INFO
+        end
+        new log_level
+      end
+
+      attr_reader :child_count
+      attr_reader :log_level
+      attr_reader :paths
+
+      def initialize log_level
+        @paths = []
+        @log_level = log_level
+      end
+
+      def add_path path
+        paths << path
+      end
+
+      def child_count= number
+        @child_count = number.to_i
+      end
+
+      def fail_fast
+        @fail_fast = !@fail_fast
+      end
+
+      def fail_fast?
+        @fail_fast
+      end
+
+      def full_backtrace
+        @full_backtrace = !@full_backtrace
+      end
+
+      def trim_backtraces?
+        return nil if @full_backtrace.nil?
+        not @full_backtrace
+      end
+
+      def quiet
+        @log_level += 1
+      end
+
+      def reverse_backtraces
+        @reverse_backtraces = !@reverse_backtraces
+      end
+
+      def reverse_backtraces?
+        @reverse_backtraces
+      end
+
+      def verbose
+        @log_level -= 1
+      end
+    end
+
+    class ArgvParser
+      def self.call argv
+        options = Options.build
+        parser = ArgvParser.new argv, options
+        parser.()
+        options
+      end
+
+      def initialize argv, options
+        @argv = argv
+        @options = options
+      end
+
+      def call
+        parse_options
+        add_paths
+      end
+
+      def add_paths
+        @argv << "tests" if @argv.empty?
+        @argv.each do |path|
+          @options.add_path path
+        end
+      end
+
+      def parse_options
+        OptionParser.new do |opts|
+          opts.banner = <<-BANNER
+Usage: #{program_name} [options] [PATH1] [PATH2] … [PATHn]
+
+If no PATH(s) are specified, ./tests is assumed
+
+          BANNER
+
+          opts.on "-b", "--full-backtrace", "Do not filter assertion stack traces" do
+            @options.full_backtrace
+          end
+
+          opts.on "-f", "--fail-fast", "When any test script fails, exit immediately" do
+            @options.fail_fast
+          end
+
+          opts.on "-h", "--help", "Print this message and exit successfully" do
+            puts opts
+            exit 0
+          end
+
+          opts.on "-m", "--monkeypatch", "Turn on monkeypatching (equivalent to `require \"test_runner/script\"'" do
+            require "test_runner/script"
+          end
+
+          opts.on "-n", "--num=COUNT", "Max number of sub processes to run concurrently" do |num|
+            @options.child_count = num
+          end
+
+          opts.on "-q", "--quiet", "Reduces log verbosity" do
+            @options.quiet
+          end
+
+          opts.on "-r", "--reverse-traces", "Reverse the order of stack traces" do
+            @options.reverse_backtraces
+          end
+
+          opts.on "-V", "--version", "Print version and exit successfully" do
+            spec = Gem.loaded_specs["test_runner"]
+            version = if spec then spec.version else "(local)" end
+            puts "Version: #{version}"
+            exit 0
+          end
+
+          opts.on "-v", "--verbose", "Increases log verbosity" do
+            @options.verbose
+          end
+        end.parse! @argv
+      end
+
+      def program_name
+        File.basename $PROGRAM_NAME
+      end
+    end
+  end
+end

data/lib/test_runner/colored_logger.rb

@@ -0,0 +1,62 @@
+module TestRunner
+  class ColoredLogger
+    ANSI_COLORS = %i(black red green yellow blue magenta cyan white)
+
+    DEFAULT_PALETTE = {
+      :unknown => -> msg { bg(:blue, :bright, fg(:white, :bright, msg)) },
+      :fatal   => -> msg { bg(:red, :bright, fg(:white, :bright, msg)) },
+      :error   => -> msg { fg(:red, :bright, msg) },
+      :warn    => -> msg { fg(:yellow, :bright, msg) },
+      :info    => -> msg { fg(:default, :normal, msg) },
+      :debug   => -> msg { fg(:cyan, :bright, msg) },
+    }
+
+    attr_reader :palette
+
+    def initialize io, palette = DEFAULT_PALETTE
+      @logger  = Logger.new io
+      @palette = palette
+    end
+
+    %i(level= progname=).each do |method_name|
+      define_method method_name do |*args, &block|
+        @logger.public_send method_name, *args, &block
+      end
+    end
+
+    %i(unknown fatal error warn info debug).each do |log_level|
+      define_method log_level do |msg_or_progname = nil, &orig_block|
+        colored_msg = format log_level, msg_or_progname
+
+        if orig_block
+          progname = colored_msg
+          block = -> do format log_level, orig_block.() end
+        else
+          block = -> do colored_msg end
+        end
+
+        @logger.public_send log_level, progname, &block
+      end
+    end
+
+    def format log_level, msg
+      formatter = palette.fetch log_level
+      instance_exec msg, &formatter
+    end
+
+    def fg *args
+      col :fg, *args
+    end
+
+    def bg *args
+      col :bg, *args
+    end
+
+    def col fgbg, color_code, intensity_code, str
+      color_num = ANSI_COLORS.index color_code
+      intensity_num = { :normal => 0, :bright => 1 }.fetch intensity_code
+      fgbg_num = { :fg => 3, :bg => 4 }.fetch fgbg
+      "\e[#{fgbg_num}#{color_num};#{intensity_num}m#{str}\e[0m"
+    end
+  end
+end

data/lib/test_runner/config.rb

@@ -0,0 +1,77 @@
+module TestRunner
+  module Config
+    extend self
+
+    extend Logger::Logging
+
+    attr_writer :child_count
+    attr_writer :fail_fast
+    attr_writer :internal_logger
+    attr_writer :reverse_backtraces
+    attr_writer :trim_backtraces
+
+    def child_count
+      Option::Number.evaluate @child_count do
+        ENV.fetch "TEST_RUNNER_CHILD_COUNT", 1
+      end
+    end
+
+    def fail_fast
+      Option::Boolean.evaluate @fail_fast do
+        ENV["TEST_RUNNER_FAIL_FAST"]
+      end
+    end
+
+    def internal_logger
+      if ENV["TEST_RUNNER_INTERNAL_LOGGING"]
+        logger
+      else
+        Logger::Logging::NullLogger
+      end
+    end
+
+    def reverse_backtraces
+      Option::Boolean.evaluate @reverse_backtraces do
+        ENV["TEST_RUNNER_REVERSE_BACKTRACES"]
+      end
+    end
+
+    def trim_backtraces
+      Option::Boolean.evaluate @trim_backtraces do
+        ENV.fetch "TEST_RUNNER_TRIM_BACKTRACES", true
+      end
+    end
+
+    class Option
+      def self.evaluate value, &block
+        instance = new value
+        instance.fetch &block
+      end
+
+      def initialize value
+        @value = value
+      end
+
+      def fetch
+        @value = yield unless set?
+        value
+      end
+
+      def set?
+        not @value.nil?
+      end
+
+      class Number < Option
+        def value
+          @value.to_i
+        end
+      end
+
+      class Boolean < Option
+        def value
+          not [nil, false, "", "0", "n", "no", "false"].include? @value
+        end
+      end
+    end
+  end
+end

data/lib/test_runner/runner.rb

@@ -0,0 +1,146 @@
+module TestRunner
+  class Runner
+    def self.call paths
+      instance = new paths
+      instance.call
+    end
+
+    attr_reader :files
+    attr_reader :pids
+
+    def initialize files
+      @files = files
+    end
+
+    def call
+      Config.internal_logger.debug "test_runner found #{files.size} files: #{files * ", "}"
+      return if files.empty?
+      result = run_all
+
+      log_msg = "finished executing files; success=#{result.inspect}"
+      if result
+        Config.logger.info log_msg
+      else
+        Config.logger.warn log_msg
+      end
+
+      result
+    end
+
+    def run_all
+      set = ProcessSet.new
+      Signal.trap "INT" do set.shutdown end
+      set << files.shift until files.empty?
+      set.finish
+    end
+
+    class ProcessSet
+      def initialize
+        @set     = []
+        @passed  = true
+      end
+
+      def << file
+        wait Config.child_count - 1
+        @set.<< spawn_child file
+      end
+
+      def finish
+        wait 0
+        @passed
+      end
+
+      def wait max_count
+        tick while @set.size > max_count
+      end
+
+      def tick
+        loop do
+          reads, _, _ = IO.select @set.map(&:fd), [], [], 1
+          return reap reads if reads
+        end
+      end
+
+      def spawn_child file
+        process = Process.new file
+        process.start
+        process
+      end
+
+      def reap reads
+        @set.delete_if do |process|
+          next unless reads.include? process.fd
+          Config.internal_logger.debug "Reaping #{process.file}:#{process.pid}"
+          process.finish or @passed = false
+          true
+        end
+
+        shutdown if failed? and Config.fail_fast
+      end
+
+      def shutdown
+        @set.each do |process|
+          ::Process.kill "TERM", process.pid
+        end
+        ::Process.waitall
+        exit 1
+      end
+
+      def failed?
+        not success?
+      end
+
+      def success?
+        @passed
+      end
+
+      class Process
+        attr_reader :fd
+        attr_reader :file
+        attr_reader :pid
+
+        def initialize file
+          @file = file
+        end
+
+        def start
+          @fd, wr = IO.pipe
+
+          @pid = fork do
+            @fd.close
+            begin
+              load file
+            rescue => error
+              print_stacktrace error
+              exit 1
+            ensure
+              wr.write "\x00"
+            end
+          end
+
+          freeze
+        end
+
+        def print_stacktrace error
+          locations = error.backtrace
+          final_location = locations.shift
+          locations = TestRunner::BacktraceFilter.(locations)
+
+          lines = locations.map do |loc| "\tfrom #{loc}" end
+          lines.unshift "#{final_location}: #{error.message} (#{error.class.name})"
+
+          lines.reverse! if Config.reverse_backtraces
+          Config.logger.error "Exception:\n#{lines * "\n"}"
+        end
+
+        def finish
+          fd.read 1
+          _, status = ::Process.wait2 pid
+          status = status.exitstatus
+          Config.internal_logger.debug "finished script #{@file}; status=#{status.inspect}"
+          status == 0
+        end
+      end
+    end
+  end
+end

data/lib/test_runner/script.rb

@@ -0,0 +1,2 @@
+require "test_runner"
+include TestRunner

data/lib/test_runner/util.rb

@@ -0,0 +1,66 @@
+module TestRunner
+  module Util
+    extend self
+
+    def extract_key_args hsh, *args
+      defaults, args = extract_hash args
+      unknown_args = hsh.keys - (args + defaults.keys)
+      missing_args = args - hsh.keys
+      unless unknown_args.empty? and missing_args.empty?
+        raise ArgumentError, key_arg_error(unknown_args, missing_args)
+      end
+      (args + defaults.keys).map do |arg|
+        hsh.fetch arg do defaults.fetch arg end
+      end
+    end
+
+    def extract_hash ary
+      if ary.last.is_a? Hash
+        hsh = ary.pop
+      else
+        hsh = {}
+      end
+      [hsh, ary]
+    end
+
+    def to_camel_case str
+      str = "_#{str}"
+      str.gsub!(%r{_[a-z]}) { |snake| snake.slice(1).upcase }
+      str.gsub!('/', '::')
+      str
+    end
+
+    def to_snake_case str
+      str = str.gsub '::', '/'
+      # Convert FOOBar => FooBar
+      str.gsub! %r{[[:upper:]]{2,}} do |uppercase|
+        bit = uppercase[0]
+        bit << uppercase[1...-1].downcase
+        bit << uppercase[-1]
+        bit
+      end
+      # Convert FooBar => foo_bar
+      str.gsub! %r{[[:lower:]][[:upper:]]+[[:lower:]]} do |camel|
+        bit = camel[0]
+        bit << '_'
+        bit << camel[1..-1].downcase
+      end
+      str.downcase!
+      str
+    end
+
+    private
+
+    def key_arg_error unknown, missing
+      str = "bad arguments. "
+      if unknown.any?
+        str.concat " unknown: #{unknown.join ', '}"
+        str.concat "; " if missing.any?
+      end
+      if missing.any?
+        str.concat " missing: #{missing.join ', '}"
+      end
+      str
+    end
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: test-runner
+version: !ruby/object:Gem::Version
+  version: 0.9.2
+platform: ruby
+authors:
+- Nathan Ladd
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: logger-logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Fork based runner for tests written as simple ruby scripts
+email: nathanladd+github@gmail.com
+executables:
+- test-runner
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/test-runner
+- lib/test_runner.rb
+- lib/test_runner/assert.rb
+- lib/test_runner/assert/assertion.rb
+- lib/test_runner/assert/check.rb
+- lib/test_runner/assert/checks.rb
+- lib/test_runner/assert/checks/registry.rb
+- lib/test_runner/assert/errors.rb
+- lib/test_runner/assert/syntax.rb
+- lib/test_runner/backtrace_filter.rb
+- lib/test_runner/cli.rb
+- lib/test_runner/colored_logger.rb
+- lib/test_runner/config.rb
+- lib/test_runner/runner.rb
+- lib/test_runner/script.rb
+- lib/test_runner/util.rb
+homepage: https://github.com/ntl/ftest
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Fork based runner for tests written as simple ruby scripts
+test_files: []