ftest 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2d6ee01d44002fef117aa809c2817d9ff81eeac2
+  data.tar.gz: d13bf0a4ba5502a3a671ca0752ea20bc88ffb508
+SHA512:
+  metadata.gz: 1d5ecd73d2435c9624d95837193d05b287f36186c91a5ad074518c2d86ecb7a1aefc905c202e39a153c92773bd4d048963b6b55d9d597d01562eac8ea767d81c
+  data.tar.gz: d6aec2df76647153cd02ccaf21f9e5757bb99bbbd660ab0f8d8c1b19bae14e49e6995b9458eafa11d4b23e29839c93efe59f415e1785ac2deb5e392512e24d3b

data/bin/ftest

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+lib_path = File.expand_path "../../lib", __FILE__
+$LOAD_PATH << lib_path unless $LOAD_PATH.include? lib_path
+require "ftest"
+FTest::CLI.run ARGV

data/lib/ftest.rb

@@ -0,0 +1,25 @@
+require "logger"
+
+module FTest
+  autoload :Assert, "ftest/assert"
+  autoload :ColoredLogger, "ftest/colored_logger"
+  autoload :Config, "ftest/config"
+  autoload :CLI, "ftest/cli"
+  autoload :Runner, "ftest/runner"
+  autoload :Util, "ftest/util"
+
+  # FTest can be included in scripts as a mixin, e.g.
+  #
+  # require "ftest"
+  # include FTest
+  #
+  # logger.info "hi"
+  # assert true
+  def logger
+    Config.logger
+  end
+
+  def self.included target
+    Assert::Syntax.infect target
+  end
+end

data/lib/ftest/assert.rb

@@ -0,0 +1,37 @@
+require_relative "assert/assertion"
+require_relative "assert/check"
+require_relative "assert/checks"
+require_relative "assert/errors"
+require_relative "assert/syntax"
+
+module FTest
+  module Assert
+    extend self
+
+    def inspect object, truncate = 100
+      raw = object.inspect
+      return raw if raw.size <= truncate
+      "#{raw[0..truncate - 2]} …\""
+    end
+
+    def filter_trace trace
+      return trace unless Config.trim_backtrace
+
+      entry_point = trace.last
+      ftest_root = File.expand_path "../..", __FILE__
+
+      first_pass = trace.drop_while do |location|
+        full_path = File.expand_path location.path
+        full_path.start_with? ftest_root
+      end
+
+      second_pass = first_pass.take_while do |location|
+        full_path = File.expand_path location.path
+        not full_path.start_with? ftest_root
+      end
+
+      second_pass << entry_point unless second_pass.last == entry_point
+      second_pass
+    end
+  end
+end

data/lib/ftest/assert/assertion.rb

@@ -0,0 +1,116 @@
+module FTest
+  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|
+          FTest.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
+        Assert.filter_trace @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/ftest/assert/check.rb

@@ -0,0 +1,53 @@
+module FTest
+  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/ftest/assert/checks.rb

@@ -0,0 +1,76 @@
+module FTest
+  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/ftest/assert/checks/registry.rb

@@ -0,0 +1,31 @@
+module FTest
+  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/ftest/assert/errors.rb

@@ -0,0 +1,46 @@
+module FTest
+  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/ftest/assert/syntax.rb

@@ -0,0 +1,94 @@
+module FTest
+  module Assert
+    class Syntax < Module
+      MISSING = :__ftest_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/ftest/cli.rb

@@ -0,0 +1,172 @@
+require "optparse"
+
+module FTest
+  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)
+      options.color if @stdout.tty?
+      setup_config
+      Runner.(resolve_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_stack_traces = options.reverse_stack_traces?
+      Config.trim_backtrace = !options.full_backtrace?
+    end
+
+    def build_logger
+      cls = if options.color? then ColoredLogger else Logger end
+      logger = cls.new @stdout
+      logger.level = options.log_level
+      logger
+    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
+      attr_reader :child_count
+      attr_reader :log_level
+      attr_reader :paths
+
+      def initialize
+        @paths = []
+        @log_level = Logger::WARN
+        @child_count = 2
+      end
+
+      def add_path path
+        paths << path
+      end
+
+      def child_count= number
+        @child_count = number.to_i
+      end
+
+      def color
+        @color = !@color
+      end
+
+      def color?
+        @color
+      end
+
+      def fail_fast
+        @fail_fast = !@fail_fast
+      end
+
+      def fail_fast?
+        @fail_fast
+      end
+
+      def full_backtrace
+        @full_backtrace = !@full_backtrace
+      end
+
+      def full_backtrace?
+        @full_backtrace
+      end
+
+      def quiet
+        @log_level += 1
+      end
+
+      def reverse_stack_traces
+        @reverse_stack_traces = !@reverse_stack_traces
+      end
+
+      def reverse_stack_traces?
+        @reverse_stack_traces
+      end
+
+      def verbose
+        @log_level -= 1
+      end
+    end
+
+    class ArgvParser
+      def self.call argv
+        options = Options.new
+        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] [PATH]
+
+If no PATH is specified, ./tests is assumed
+
+          BANNER
+
+          opts.on "-b", "--full-backtrace", "Do not filter assertion stack traces" do
+            @options.full_backtrace
+          end
+          opts.on "-c", "--color", "Enable/disable colored output" do
+            @options.color
+          end
+          opts.on "-f", "--fail-fast", "When any test script fails, exit immediately" do
+            @options.fail_fast
+          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_stack_traces
+          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/ftest/colored_logger.rb

@@ -0,0 +1,54 @@
+module FTest
+  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=).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|
+        colored_msg = format log_level, msg
+        @logger.public_send log_level, colored_msg
+      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/ftest/config.rb

@@ -0,0 +1,35 @@
+module FTest
+  module Config
+    extend self
+
+    attr_writer :child_count
+    attr_writer :fail_fast
+    attr_writer :logger
+    attr_writer :reverse_stack_traces
+    attr_writer :trim_backtrace
+
+    def child_count
+      @child_count or 1
+    end
+
+    def fail_fast
+      @fail_fast or false
+    end
+
+    def logger
+      @logger or default_logger
+    end
+
+    def default_logger
+      @default_logger ||= Logger.new $stdout
+    end
+
+    def reverse_stack_traces
+      @reverse_stack_traces or false
+    end
+
+    def trim_backtrace
+      @trim_backtrace or false
+    end
+  end
+end

data/lib/ftest/runner.rb

@@ -0,0 +1,138 @@
+module FTest
+  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.logger.debug "ftest found #{files.size} files: #{files * ", "}"
+      return if files.empty?
+      result = run_all
+      Config.logger.info "finished executing files; success=#{result.inspect}"
+      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.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
+
+          lines = locations.map do |loc| "\tfrom #{loc}" end
+          lines.unshift "#{final_location}: #{error.message}"
+
+          lines.reverse! if Config.reverse_stack_traces
+          Config.logger.error "Exception:\n#{lines * "\n"}"
+        end
+
+        def finish
+          fd.read 1
+          _, status = ::Process.wait2 pid
+          status = status.exitstatus
+          Config.logger.debug "finished script #{@file}; status=#{status.inspect}"
+          status == 0
+        end
+      end
+    end
+  end
+end

data/lib/ftest/util.rb

@@ -0,0 +1,66 @@
+module FTest
+  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,58 @@
+--- !ruby/object:Gem::Specification
+name: ftest
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nathan Ladd
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-22 00:00:00.000000000 Z
+dependencies: []
+description: Fork based runner for tests written as simple ruby scripts
+email: nathanladd+github@gmail.com
+executables:
+- ftest
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/ftest
+- lib/ftest.rb
+- lib/ftest/assert.rb
+- lib/ftest/assert/assertion.rb
+- lib/ftest/assert/check.rb
+- lib/ftest/assert/checks.rb
+- lib/ftest/assert/checks/registry.rb
+- lib/ftest/assert/errors.rb
+- lib/ftest/assert/syntax.rb
+- lib/ftest/cli.rb
+- lib/ftest/colored_logger.rb
+- lib/ftest/config.rb
+- lib/ftest/runner.rb
+- lib/ftest/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: []