quarry 0.4.0 → 0.5.0

data/work/sandbox/build/test.rb

@@ -1,521 +0,0 @@
-require 'quarry/build'
-
-require 'facets/hash/rekey'
-require 'facets/string/tabs'
-require 'facets/progressbar'
-
-
-module Quarry
-
-  #
-
-  class Test < Build
-
-    attr_accessor :live
-    attr_accessor :libpath
-    attr_accessor :tests
-    attr_accessor :requires
-
-    def defaults
-      @libpath = "lib"
-      @tests   = 'test/**/test_*.rb'
-    end
-
-    def loadpath
-      @loadpath ||= ["lib"]
-    end
-
-    def test_files
-      Dir.glob(tests)
-    end
-
-    # Basic unit test run.
-
-    def unit_test(options)
-      options = TestOptions.new(configuration['test'], options)
-
-      live    = options.live
-      libpath = options.libpath
-
-      unless live
-        libpath.each do |lp|
-          $LOAD_PATH.unshift(File.expand_path(lp))
-        end
-      end
-
-      if find = argv[0]
-        unless file?(find)
-          find = File.join(find, '**', 'test_*.rb')
-        end
-      else
-        find = 'test/**/test_*.rb'
-      end
-
-      Dir.glob(find).each do |file|
-        next if dir?(file)
-        load file
-      end
-    end
-
-    #alias_method :call, :run
-
-    # Run unit-tests. Each test is run in a separate interpretor
-    # to prevent script clash. This makes for a more robust test
-    # facility and prevents potential conflicts between test scripts.
-    #
-    #   tests     Test files (eg. test/tc_**/*.rb) [test/**/*]
-    #   libs      Directories to include in load path.
-    #             ('./lib' is always included)
-    #   live      Deactive use of local libs and test against install.
-    #   reqs      List of files to require prior to running tests.
-    #   extract   Extract embedded tests first? [false]
-    #
-    # To isolate tests this tool marshals test results across a
-    # stdout->stdin shell pipe. This prevents interfence of one
-    # script's tests on another. But consequently it is not always
-    # possible to send debug info to stdout in the tests themselves
-    # (eg. #p and #puts).
-
-    def solo #(config)
-      require 'test/unit/ui/testrunnermediator' #require 'test/unit'
-      ::Test::Unit.run = true # Don't autorun tests!
-
-      #tests   = config['files'] || 'test/unit/**/test_*.rb'
-      #libs    = libpath #config['libpath']
-      reqs    = requires #config['require']
-      #live    = config['live']
-      #extract = config['extract']
-
-      tests = [ tests() ].flatten
-      libs  = [ libpath() ].flatten
-
-      #files = [ @files ].flatten
-      #extract_tests if extract
-
-      results  = TestResults.new #(style)
-
-      # get test files
-      test_libs  = libs.join(':')
-      test_files = Dir.multiglob( *tests )
-      if test_files.empty?
-        puts "Tests        [NONE]"
-        return
-      end
-
-      # run tests
-
-      if trace?
-        pbar = nil
-        size = test_files.collect{|f| f.size}.max + 5
-        dots = '.' * size
-      else
-        pbar = Console::ProgressBar.new( 'Testing', test_files.size )
-        pbar.inc
-      end
-
-      test_files.each do |test_file|
-        pbar.inc if pbar
-        if ! File.file?(test_file)
-          next #r = nil
-        else
-          unless pbar
-            print test_file + dots[test_file.size..-1]
-            $stdout.flush
-          end
-          r = fork_test( test_file, :libs=>libs, :reqs=>reqs, :live=>live )
-          unless pbar
-            puts r.passed? ? "[PASS]" : "[FAIL]"
-          end
-        end
-        results << r
-      end
-
-      pbar.finish if pbar
-
-      # display results
-      puts results
-
-      fails, errrs = results.failure_count, results.error_count
-      #CHECKLIST << :test if fails > 0
-      #CHECKLIST << :test if errrs > 0
-      return (fails + errrs > 0)
-    end
-
-    # run cross comparison tests
-    #
-    # This tool runs unit tests in pairs to make
-    # sure there is cross library compatibility.
-    #
-    # Run unit-tests. Each test is run in a separate interpretor
-    # to prevent script clash. This makes for a more robust test
-    # facility and prevents potential conflicts between test scripts.
-    #
-    #   tests     Test files (eg. test/tc_**/*.rb) [test/**/*]
-    #   libs      Directories to include in load path.
-    #             ('./lib' is always included)
-    #   live      Deactive use of local libs and test against install.
-    #   reqs      List of files to require prior to running tests.
-    #   extract   Extract embedded tests first? [false]
-    #
-    # To isolate tests this tool marshals test results across a
-    # stdout->stdin shell pipe. This prevents interfence of one
-    # script's tests on another. But consequently it is not always
-    # possible to send debug info to stdout in the tests themselves
-    # (eg. #p and #puts).
-
-    def cross #(config)
-      require 'test/unit/ui/testrunnermediator' #require 'test/unit'
-      ::Test::Unit.run = true # Don't autorun tests!
-
-      #tests   = config['tests'] || 'test/**/test_*.rb'
-      reqs    = requires #config['require']
-      #libs    = config['libpath']
-      #live    = config['live']
-      #extract = info['extract']
-
-      tests = [ tests() ].flatten
-      libs  = [ libpath() ].flatten
-
-      results  = TestResults.new #(style)
-
-      # get test files
-      test_libs  = libs.join(':')
-      test_files = Dir.multiglob( *tests )
-      if test_files.empty?
-        puts "Tests        [NONE]"
-        return
-      end
-
-      # run tests
-
-      if trace?
-        pbar = nil
-        size = test_files.collect{|f| f.size}.max * 2 + 5
-        dots = '.' * size
-      else
-        pbar = Console::ProgressBar.new('Testing', test_files.size ** 2)
-        pbar.inc
-      end
-
-      test_files.each do |test_file|
-        next unless File.file?(test_file)
-
-        test_files.each do |test_file_x|
-          next unless File.file?(test_file_x)
-          next if test_file == test_file_x
-
-          pbar.inc if pbar
-          unless pbar
-            out = test_file +' : ' + test_file_x
-            print out + dots[out.size..-1]
-            $stdout.flush
-          end
-
-          r = fork_crosstest( test_file, test_file_x, :libs=>libs, :reqs=>reqs, :live=>live )
-
-          unless pbar
-            puts r.passed? ? "[PASS]" : "[FAIL]"
-          end
-
-          results << r
-        end
-      end
-
-      pbar.finish if pbar
-
-      # display results
-      puts results
-
-      fails, errrs = results.failure_count, results.error_count
-      #CHECKLIST << :test if fails > 0
-      #CHECKLIST << :test if errrs > 0
-      return (fails + errrs > 0)
-    end
-
-    private
-
-    # Run a test in a separate process.
-    #
-    # Currently send program output to null device.
-    # Could send to a logger in future version.
-    #
-    # Key parameters are libs, reqs, live.
-
-    def fork_crosstest( file, xfile, keys )
-      keys = keys.rekey(:to_s)
-
-      libs = keys['lib'] || []
-      reqs = keys['req'] || []
-      live = keys['live']
-
-      src = ''
-
-      unless live
-        l = File.join( Dir.pwd, 'lib' )
-        if File.directory?( l )
-          src << %{$:.unshift('#{l}')\n}
-        end
-        libs.each { |r| src << %{$:.unshift('#{r}')\n} }
-      end
-
-      src << %{
-        #require 'test/unit'
-        require 'test/unit/collector'
-        require 'test/unit/collector/objectspace'
-        require 'test/unit/ui/testrunnermediator'
-      }
-
-      reqs.each do |fix|
-        src << %Q{
-          require '#{fix}'
-        }
-      end
-
-      src << %{
-        def warn(*null); end  # silence warnings
-
-        output = STDOUT.dup
-        STDOUT.reopen( PLATFORM =~ /mswin/ ? "NUL" : "/dev/null" )
-
-        load('#{file}')
-        load('#{xfile}')
-
-        tests = Test::Unit::Collector::ObjectSpace.new.collect
-        runner = Test::Unit::UI::TestRunnerMediator.new( tests )
-        result = runner.run_suite
-
-        begin
-          marshalled = Marshal.dump(result)
-        rescue TypeError => e
-          $stderr << "MARSHAL ERROR\n"
-          $stderr << "TEST: #{file}\n"
-          $stderr << "XTEST: #{xfile}\n"
-          $stderr << "DATA:" << result.inspect
-          exit -1
-        end
-        output << marshalled
-
-        STDOUT.reopen(output)
-        output.close
-      }
-
-      result = IO.popen("ruby","w+") do |ruby|
-        ruby.puts src
-        ruby.close_write
-        ruby.read
-      end
-
-      begin
-        marsh = Marshal.load(result)
-      rescue ArgumentError
-        $stderr << "\nCannot load marshalled test data.\n"
-        $stderr << result << "\n"
-        exit -1
-      end
-
-      return marsh
-    end
-
-    # Run a test in a separate process.
-    #
-    # Currently send program output to null device.
-    # Could send to a logger in future version.
-    #
-    # Key parameters are libs, reqs, live.
-
-    def fork_test( file, keys )
-      keys = keys.rekey(:to_s)
-
-      libs = keys['lib'] || []
-      reqs = keys['req'] || []
-      live = keys['live']
-
-      src = ''
-
-      unless live
-        l = File.join( Dir.pwd, 'lib' )
-        if File.directory?( l )
-          src << %{$:.unshift('#{l}')\n}
-        end
-        libs.each { |r| src << %{$:.unshift('#{r}')\n} }
-      end
-
-      src << %{
-        #require 'test/unit'
-        require 'test/unit/collector'
-        require 'test/unit/collector/objectspace'
-        require 'test/unit/ui/testrunnermediator'
-      }
-
-      reqs.each do |fix|
-        src << %Q{
-          require '#{fix}'
-        }
-      end
-
-      src << %{
-        def warn(*null); end  # silence warnings
-
-        output = STDOUT.dup
-        STDOUT.reopen( PLATFORM =~ /mswin/ ? "NUL" : "/dev/null" )
-
-        load('#{file}')
-
-        tests = Test::Unit::Collector::ObjectSpace.new.collect
-        runner = Test::Unit::UI::TestRunnerMediator.new( tests )
-        result = runner.run_suite
-
-        begin
-          marshalled = Marshal.dump(result)
-        rescue TypeError => e
-          $stderr << "MARSHAL ERROR\n"
-          $stderr << "TEST: #{file}\n"
-          $stderr << "DATA:" << result.inspect
-          exit -1
-        end
-        output << marshalled
-
-        STDOUT.reopen(output)
-        output.close
-      }
-
-      result = IO.popen("ruby","w+") do |ruby|
-        ruby.puts src
-        ruby.close_write
-        ruby.read
-      end
-
-      begin
-        marsh = Marshal.load(result)
-      rescue ArgumentError
-        $stderr << "\nCannot load marshalled test data.\n"
-        $stderr << result << "\n"
-        exit -1
-      end
-
-      return marsh
-    end
-
-    # = Test Results
-    #
-    # Support class for collecting test results.
-
-    class TestResults
-      attr_reader :assertion_count,
-                  :run_count,
-                  :failure_count,
-                  :error_count
-
-      attr_accessor :style
-
-      def initialize( style=nil )
-        @style = style
-
-        @results = []
-
-        @assertion_count = 0
-        @run_count = 0
-        @failure_count = 0
-        @error_count = 0
-      end
-
-      # Add a result to the results collection.
-
-      def <<( result )
-        @results << result
-
-        @assertion_count += result.assertion_count
-        @run_count += result.run_count
-        @failure_count += result.failure_count
-        @error_count += result.error_count
-      end
-
-      #
-
-      def errors
-        errors = []
-        @results.each do |r|
-          unless r.passed?
-            errors << r.instance_variable_get('@errors')
-          end
-        end
-        errors.reject! { |e| e == [] }
-        errors
-      end
-
-      #
-
-      def failures
-        failures = []
-        @results.each do |r|
-          unless r.passed?
-            failures << r.instance_variable_get('@failures')
-          end
-        end
-        failures.reject! { |e| e == [] }
-        failures
-      end
-
-      # Output format for test results.
-
-      def to_s
-        return @results.to_s if style == 'pease'
-
-        s = []
-        # Display failures
-        unless failures.empty?
-          s << ''
-          s << "FAILURES:"
-          failures.reverse.each do |fails|
-            fails.reverse.each do |failure|
-              #puts
-              s << %{  - test      : #{failure.test_name}}
-              s << %{    location  : #{failure.location}}
-              if failure.message.index("\n")
-                s << %{    message   : >}
-                s << failure.message.tabto(6)
-              else
-                s << %{    message   : #{failure.message}}
-              end
-            end
-          end
-        end
-
-        # Display errors
-        unless errors.empty?
-          s << ''
-          s << "ERRORS:"
-          errors.reverse.each do |errs|
-            errs.reverse.each do |err|
-              s << ''
-              s << %{  - test      : #{err.test_name}}
-              s << %{    message   : #{err.exception.message}}
-              s << %{    backtrace :}
-              err.exception.backtrace[0...-1].each { |bt| s << %Q{      - #{bt}} }
-            end
-          end
-        end
-
-        # Display final results
-        s << ''
-        s << "Summary:"
-        s << "  Tests      : #{@run_count}"
-        s << "  Assertions : #{@assertion_count}"
-        s << "  Failures   : #{@failure_count}"
-        s << "  Errors     : #{@error_count}"
-        s << ''
-        s << ''
-
-        return s.join("\n")
-      end
-
-      # Delegate missing call to the results array.
-
-      def method_missing(*a,&b)
-        @results.send(*a,&b)
-      end
-    end
-
-  end
-
-end

data/work/sandbox/design.rb

@@ -1,200 +0,0 @@
-#require 'facet/kernel/within?'
-require 'ratchets/test/assert'
-
-at_exit { Ratchets::Design.check unless $no_autocheck }
-
-
-module Ratchets
-
-  # Design module. Hold all contexts.
-
-  module Design
-
-    self.specifications
-      @specificaitons = []
-    end
-
-    def self.specification(desc, &block)
-      contexts << Specificaiton.new(desc, &block)
-    end
-
-    class Context
-
-      self.contexts
-        @contexts = []
-      end
-
-      def self.context(desc, &block)
-        contexts << Context.new(desc, &block)
-      end
-
-      def self.check
-        contexts.each do |context|
-          context.check
-        end
-      end
-
-      def self.outline
-        contexts.each do |context|
-          puts "= " + context.description
-          context.specifications.each do |spec|
-            puts "* " + spec
-          end
-        end
-      end
-
-  end
-
-  # Design Context. Context contains unit specifications.
-
-  class Design::Context
-    attr :description
-    attr :specifications
-
-    def initialize(name, description, &block)
-      @description = description
-      @context     = block
-      @specifications = []
-
-      #@context_class = Class.new do
-      #  def setup; end
-      #  def teardown; end
-      #end
-
-      instance_eval(&block)
-    end
-
-    def setup(&setup_block)
-      @context_class.instance_eval do
-        define_method(:setup, &setup_block)
-      end
-    end
-
-    def teardown(&teardown_block)
-      @context_class.instance_eval do
-        define_method(:teardown, &teardown_block)
-      end
-    end
-
-    #def specify(desc, &spec_block)
-    #  @specifications << desc
-    #  @context_class.instance_eval do
-    #    define_method(desc, &spec_block)
-    #  end
-    #end
-
-    def method_missing(name, *args, &block)
-      @specifications << Specification.new(name, args[0], &block)
-    end
-
-
-    def check
-      @specifications.each do |spec|
-        begin
-          context = @context_class.new
-          context.setup
-          context.send(spec)
-          context.teardown
-        rescue Exception => e
-          # TODO: make output compatible with unit_diff
-          print "\n", (Assertion === e ? "Failure: " : "Error: ")
-          puts "#{spec}: \n #{e}"
-          puts e.backtrace
-        end
-      end
-    end
-
-  end
-
-  #
-
-  class Specification
-    attr :relation, :description, :specification
-
-    def initialize(relation, decription, &specification)
-      @relation      = relation
-      @description   = description
-      @specificaiton = specification
-    end
-  end
-
-
-#   # Unit of design specification.
-#
-#   class Design::Context::Specification
-#     attr :description
-#     attr :check_routine
-#
-#     def initialize(desc, &check)
-#       @description = desc
-#       @check_routine = check
-#     end
-#
-#     def to_proc
-#       @check_routine
-#     end
-#   end
-
-end #module Ratchets
-
-
-
-
-# EXAMPLE
-
-if __FILE__ == $0
-
-  Ratchets::Design.specification "Example Specification" do
-
-    context "demonstrate basic assertions" do
-
-      specify "fail if should is false" do
-        4.should == 3
-      end
-
-      specify "fail if should_not is true" do
-        4.should_not == 4
-      end
-
-      specify "fail on should raise" do
-        lambda{raise ArgumentError}.should.raise? SyntaxError
-      end
-
-    end
-
-  end
-
-  $no_autocheck = true
-
-  Ratchets::Design.outline
-
-end
-
-
-if __FILE__ == $0
-
-  Ratchets::Design.specification "Example Specification" do
-
-    demonstrate "demonstrate basic assertions" do
-
-      that "4.must == 3 fails" do
-        4.should == 3
-      end
-
-      that "4.must_not == 4 fails" do
-        4.should_not == 4
-      end
-
-      that "raise ArgumentError does not raise a SyntaxError" do
-        lambda{raise ArgumentError}.should.raise? SyntaxError
-      end
-
-    end
-
-  end
-
-  $no_autocheck = true
-
-  Ratchets::Design.outline
-
-end