quarry 0.4.0 → 0.5.0

data/lib/quarry/grammar/legacy/assert.rb

@@ -0,0 +1,280 @@
+module Quarry
+
+  module Grammar #:nodoc:
+
+    module Legacy #:nodoc:
+
+      # = Test::Unit Legacy Assertions
+      #
+      # This module provides a compatibility layer for Test::Unit.
+      # This is an optional module and is intended for providing
+      # an easier transition from Test::Unit::TestCase to Quarry
+      # Specifications.
+      #
+      # Note that two methods are not provided, +#assert_nothing_raised+,
+      # and +#assert_nothing_thrown+.
+      #
+      module Assertions
+
+        # The assertion upon which all other assertions are based.
+        #
+        #   assert [1, 2].include?(5)
+        #
+        def assert(test=nil, msg=nil)
+          if test
+            msg = "failed assertion (no message given)") unless msg
+            raise Excpectation.new(:message=>msg) unless test
+          else
+            Expectation.new(:delegate=>self)
+          end
+        end
+
+        # Passes if the block yields true.
+        #
+        # assert_block "Couldn't do the thing" do
+        #   do_the_thing
+        # end
+        #
+        def assert_block(msg=nil) # :yields: 
+          test = ! yield
+          msg = "assertion failed" unless msg
+          assert(test, msg)
+        end
+
+        # Passes if expected == +actual.
+        #
+        # Note that the ordering of arguments is important,
+        # since a helpful error message is generated when this
+        # one fails that tells you the values of expected and actual.
+        #
+        #   assert_equal 'MY STRING', 'my string'.upcase
+        #
+        def assert_equal(exp, act, msg=nil)
+          test = (exp == act)
+          msg  = "Expected #{act.inspect} to be equal to #{exp.inspect}" unless msg
+          assert(test, msg)
+        end
+
+        # Passes if expected_float and actual_float are equal within delta tolerance.
+        #
+        #   assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
+        #
+        def assert_in_delta(exp, act, delta, msg=nil)
+          test = (exp.to_f - act.to_f).abs <= delta.to_f
+          msg  = "Expected #{exp} to be within #{delta} of #{act}" unless msg
+          assert(test, msg)
+        end
+
+        # Passes if object .instance_of? klass
+        #
+        #   assert_instance_of String, 'foo'
+        #
+        def assert_instance_of(cls, obj, msg=nil)
+          test = (cls === obj)
+          msg  = "Expected #{obj} to be a #{cls}" unless msg
+          assert(test, msg)
+        end
+
+        # Passes if object .kind_of? klass
+        #
+        #   assert_kind_of Object, 'foo'
+        #
+        def assert_kind_of(cls, obj, msg=nil)
+          test = obj.kind_of?(cls)
+          msg  = "Expected #{obj.inspect} to be a kind of #{cls}" unless msg
+          assert(test, msg)
+        end
+
+        # Passes if string =~ pattern.
+        #
+        #   assert_match(/\d+/, 'five, 6, seven')
+        #
+        def assert_match(exp, act, msg=nil)
+          test = (act =~ exp)
+          msg  = "Expected #{act.inspect} to match #{exp.inspect}" unless msg
+          assert(test, msg)
+        end
+
+        # Passes if object is nil.
+        #
+        #   assert_nil [1, 2].uniq!
+        #
+        def assert_nil(obj, msg=nil)
+          test = obj.nil?
+          msg  = "Expected #{obj.inspect} to be nil" unless msg
+          assert(test, msg)
+        end
+
+        # Passes if regexp !~ string
+        #
+        #   assert_no_match(/two/, 'one 2 three')
+        #
+        def assert_no_match(exp, act, msg=nil)
+          test = (act !~ exp)
+          msg  = "Expected #{act.inspect} to match #{exp.inspect}" unless msg
+          assert(test, msg)
+        end
+
+        # Passes if expected != actual
+        #
+        #  assert_not_equal 'some string', 5
+        #
+        def assert_not_equal(exp, act, msg=nil)
+          test = (exp != act)
+          msg  = "Expected #{act.inspect} to not be equal to #{exp.inspect}" unless msg
+          assert(test, msg)
+        end
+
+        # Passes if ! object .nil?
+        #
+        #   assert_not_nil '1 two 3'.sub!(/two/, '2')
+        #
+        def assert_not_nil(obj, msg=nil)
+          test = ! obj.nil?
+          msg  = "Expected #{obj.inspect} to not be nil" unless msg
+          assert(test, msg)
+        end
+
+        # Passes if ! actual .equal? expected
+        #
+        #   assert_not_same Object.new, Object.new
+        #
+        def assert_not_same(exp, act, msg=nil)
+          test = ! exp.equal?(act)
+          msg  = "Expected #{act.inspect} to not be the same as #{exp.inspect}" unless msg
+          assert(test, msg)
+        end
+
+        # Compares the +object1+ with +object2+ using operator.
+        #
+        # Passes if object1.send(operator, object2) is true.
+        #
+        #   assert_operator 5, :>=, 4
+        #
+        def assert_operator(o1, op, o2, msg="")
+          test = o1.__send__(op, o2)
+          msg = "Expected #{o1}.#{op}(#{o2}) to be true" unless msg
+          assert(test, msg)
+        end
+
+        # Passes if the block raises one of the given exceptions.
+        #
+        #   assert_raise RuntimeError, LoadError do
+        #     raise 'Boom!!!'
+        #   end
+        #
+        def assert_raises(*args)
+          if msg = (Module === args.last ? nil : args.pop)
+          begin
+            yield
+            msg = "Expected #{exp} to be raised" unless msg
+            assert false, msg
+          rescue Exception => e
+            test = (exp === e)
+            msg  = "Expected #{exp} to be raised, but got #{e.class}" unless msg
+            assert test, msg
+            return e
+          end
+        end
+        alias_method :assert_raise, :assert_raises
+
+        # Provides a way to assert that a procedure
+        # <i>does not</i> raise an exception.
+        #
+        #   refute_raises(StandardError){ raise }
+        #
+        #def assert_raises!(exception, &block)
+        #  begin
+        #    block.call(*a)
+        #  rescue exception
+        #    raise Assertion
+        #  end
+        #end
+        #alias_method :refute_raises, :assert_raises!
+
+        # Passes if +object+ respond_to? +method+.
+        #
+        #   assert_respond_to 'bugbear', :slice
+        #
+        def assert_respond_to(obj, meth, msg=nil)
+          msg  = "Expected #{obj} (#{obj.class}) to respond to ##{meth}" unless msg
+          #flip = (Symbol === obj) && ! (Symbol === meth) # HACK for specs
+          #obj, meth = meth, obj if flip
+          test = obj.respond_to?(meth)
+          assert(test, msg)
+        end
+
+        # Passes if +actual+ .equal? +expected+ (i.e. they are the same instance).
+        #
+        #   o = Object.new
+        #   assert_same(o, o)
+        #
+        def assert_same(exp, act, msg=nil)
+          msg  = "Expected #{act.inspect} to be the same as #{exp.inspect}" unless msg
+          test = exp.equal?(act)
+          assert(test, msg)
+        end
+
+        # Passes if the method send returns a true value.
+        # The parameter +send_array+ is composed of:
+        #
+        # * A receiver
+        # * A method
+        # * Arguments to the method
+        #
+        # Example:
+        #
+        #   assert_send [[1, 2], :include?, 4]
+        #
+        def assert_send(send_array, msg=nil)
+          r, m, *args = *send_array
+          test = r.__send__(m, *args)
+          msg  = "Expected #{r}.#{m}(*#{args.inspect}) to return true" unless msg
+          assert(test, msg)
+        end
+
+        # Passes if the block throws expected_symbol
+        #
+        #   assert_throws :done do
+        #     throw :done
+        #   end
+        #
+        def assert_throws(sym, msg=nil)
+          msg  = "Expected #{sym} to have been thrown" unless msg
+          test = true
+          catch(sym) do
+            begin
+              yield
+            rescue ArgumentError => e     # 1.9 exception
+              default += ", not #{e.message.split(/ /).last}"
+            rescue NameError => e         # 1.8 exception
+              default += ", not #{e.name.inspect}"
+            end
+            test = false
+          end
+          assert(test, msg)
+        end
+
+        # Flunk always fails.
+        #
+        #   flunk 'Not done testing yet.'
+        #
+        def flunk(msg=nil)
+          assert(false, msg)
+        end
+
+      end #module Assertions
+
+    end #module Legacy
+
+  end #module Grammar
+
+  # This could be in Object, but since they will only be needed in
+  # the context of a, well, Context...
+  #
+  class Context #:nodoc:
+    include Grammar::Legacy::Assertions
+  end
+
+end #module Quarry
+

data/lib/quarry/grammar/should.rb

@@ -0,0 +1,50 @@
+module Quarry
+
+  module Grammar
+
+    # = Should Nomenclature
+    #
+    # The term *should* has become the defacto standard for
+    # BDD assertions, so Quarry supports this nomenclature. 
+    #
+    module Should
+
+      # Same as #expect but only as a functor.
+      #
+      #   4.should == 3  #=> Expectation Error
+      #
+      def should
+        return Expectation.new(:delegate=>self, :backtrace=>caller)
+      end
+
+      # Designate a negated expectation via a *functor*.
+      # Read this as "should not".
+      #
+      #   4.should! == 4  #=> Expectation Error
+      #
+      # See also #expect!
+      #
+      def should!
+        return Expectation.new(:delagte=>self, :negate=>true, :backtrace=>caller)
+      end
+
+      # See #should! method.
+      #
+      alias_method :should_not, :should!
+
+      #
+      #alias_method :should_raise, :assert_raises
+
+      #
+      #alias_method :should_not_raise, :assert_raises!
+
+    end
+
+  end
+
+  class ::Object #:nodoc:
+    include Grammar::Should
+  end
+
+end
+

data/lib/quarry/grammar.rb

@@ -0,0 +1,4 @@
+require 'quarry/grammar/expect'
+require 'quarry/grammar/assert'
+require 'quarry/grammar/should'
+

data/lib/quarry/{spec → markup}/step.rb

@@ -1,6 +1,6 @@
 module Quarry
 
-  module Spec
+  class Markup #:nodoc:
 
     # = Step
     #
@@ -73,6 +73,7 @@ module Quarry
       alias_method :macro?, :type
     end
 
-  end#module Spec
+  end #class Markup
+
+end #module Quarry
 
-end#module Quarry

data/lib/quarry/markup.rb

@@ -0,0 +1,70 @@
+require 'quarry/markup/step'
+
+module Quarry
+
+  # = Specification Markup
+  #
+  class Markup
+
+    attr :file
+    attr :steps
+
+    #
+    def initialize(file)
+      @file  = file
+      @steps = []
+      parse
+    end
+
+    #
+    def parse
+      lineno = 0
+      text   = ''
+      File.open(file, 'r') do |f|
+        f.readlines.each_with_index do |line, lineno|
+          case line
+          when /^\s*$/
+            parse_section(text, lineno)
+            text = ''
+          else
+            text << line
+          end
+        end
+      end
+    end
+
+    #
+    def parse_section(text, lineno)
+      return if text.strip == ''
+      case text
+      when /\A[-=].*?$/, /[-=]\s*\Z/
+        #text << line
+        steps << Header.new(self, text, lineno)
+      when /^\s+/
+        last = steps.last
+        case last
+        when Step, Macro
+          last.code << "\n\n#{text.rstrip}"
+        when Comment
+          if last.macro?
+            steps << Macro.new(self, text, lineno, last.type)
+          else
+            steps << Step.new(self, text, lineno)
+          end
+        else
+          steps << Step.new(self, text, lineno)
+        end
+      else
+        steps << Comment.new(self, text, lineno)
+      end
+    end
+
+    #
+    def description
+      File.basename(file)
+    end
+
+  end #class Markup
+
+end#module Quarry
+

data/lib/quarry/{stub/mock.rb → mock.rb}

@@ -76,7 +76,7 @@ module Quarry
     #-- 
     # TODO: Use Carats for #unmix.
     #++
-    def remove(mock_module=nil)
+    def remove_mock(mock_module=nil)
       mock_module ||= @_mock
       obj = self
       mod = Module.new

data/lib/quarry/{stub/probe.rb → probe.rb}

@@ -1,26 +1,3 @@
-# = methodprobe.rb
-#
-# == Copyright (c) 2004 Thomas Sawyer
-#
-#   Ruby License
-#
-#   This module is free software. You may use, modify, and/or redistribute this
-#   software under the same terms as Ruby.
-#
-#   This program is distributed in the hope that it will be useful, but WITHOUT
-#   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-#   FOR A PARTICULAR PURPOSE.
-#
-# == Author(s)
-#
-# * Thomas Sawyer
-
-# Author::    Thomas Sawyer
-# Copyright:: Copyright (c) 2006 Thomas Sawyer
-# License::   Ruby License
-
-#
-
 module Quarry
 
   # = Method Probe
@@ -64,10 +41,9 @@ module Quarry
   #   [{"+"=>[["Fixnum"]]}]
   #   [["+( Fixnum )"]]
   #
+  class Probe
 
-  class MethodProbe
-
-    def MethodProbe.duckcall
+    def self.duckcall
       begin
         yield
       rescue TypeError => e
@@ -125,13 +101,13 @@ module Quarry
 end
 
 
-class Method
+class ::Method
 
   # Outputs migration information.
   def migration
     parameters = []; argc = self.arity
     if argc > 0
-      argc.times { parameters << MethodProbe.new }
+      argc.times { parameters << Quarry::Probe.new }
       Probe.duckcall { self.call(*parameters) }
     elsif argc < 0
       raise "(NYI) method takes unlimited arguments"
@@ -167,14 +143,8 @@ end
 
 
 
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
 
-=begin testing
+=begin test
 
   require 'test/unit'
 
@@ -214,3 +184,6 @@ end
   end
 
 =end
+
+# Copyright (c) 2004,2008 Thomas Sawyer
+

data/lib/quarry/reporter/dotprogress.rb

@@ -0,0 +1,62 @@
+require 'quarry/reporter'
+
+module Quarry
+
+  class Reporter #:nodoc:
+
+    #
+    class DotProgress < Reporter
+
+      def report_intro
+        @start_time = Time.now
+        puts "Started"
+      end
+
+      def report_step(step)
+        super
+        if step.code
+          print "."
+          #str = "(%s) %s" % [count.join('.'), str.tab(6).strip]
+          #puts "* #{step.text.tab(2).strip}"
+          #puts "\n#{step.code}\n" if $VERBOSE
+        else
+          #puts "\n#{step.text}"
+        end
+      end
+
+      #def report(str)
+      #  count[-1] += 1 unless count.empty?
+      #  str = str.chomp('.') + '.'
+      #  str = count.join('.') + ' ' + str
+      #  puts str.strip
+      #end
+
+      def report_summary
+        puts "\nFinished in #{Time.now - @start_time} seconds.\n\n"
+
+        @error.each do |step, exception|
+          puts ANSICode.red("***** ERROR *****")
+          puts "#{exception}"
+          puts ":#{exception.backtrace[0]}:"
+          #puts ":#{exception.backtrace[1]}:"
+          #puts exception.backtrace[1..-1] if $VERBOSE
+          puts
+        end
+
+        @fail.each do |step, assertion|
+          puts ANSICode.red("***** FAIL *****")
+          puts ANSICode.bold("#{assertion}")
+          puts ":#{assertion.backtrace[2]}:"
+          #puts assertion if $VERBOSE
+          puts
+        end
+
+        puts "%s specs, %s steps, %s failures, %s errors" % [@specs, @steps, @fail.size, @error.size] #, @pass.size ]
+      end
+
+    end#class DotProgress
+
+  end#class Reporter
+
+end#module Quarry
+

data/lib/quarry/reporter/summary.rb

@@ -0,0 +1,70 @@
+require 'quarry/reporter'
+
+module Quarry
+
+  class Reporter #:nodoc:
+
+    # = Summary Reporter
+    #
+    # Similar to the Verbatim reporter, but does
+    # not display test code for passing tests.
+
+    class Summary < Reporter
+
+      def report_header(step)
+        puts ANSICode.bold(step.text)
+      end
+
+      def report_comment(step)
+        txt = step.text.tabto(2)
+        txt[0,1] = "*"
+        puts txt 
+      end
+
+      def report_macro(step)
+        txt = step.text.tabto(2)
+        txt[0,1] = "*"
+        puts txt 
+        #puts
+        #puts ANSICode.magenta("#{step.code}")
+      end
+
+      def report_pass(step)
+        #puts ANSICode.green("#{step.code}")
+      end
+
+      def report_fail(step, assertion)
+        msg = ''
+        msg << "  ##### FAIL #####\n"
+        msg << "  # " + assertion.to_s
+        msg = ANSICode.magenta(msg)
+        puts msg
+        #puts
+        puts ANSICode.red("#{step.code}")
+      end
+
+      def report_error(step, exception)
+        raise exception if $DEBUG
+        msg = ''
+        msg << "  ##### ERROR #####\n"
+        msg << "  # " + exception.to_s + "\n"
+        msg << "  # " + exception.backtrace[0]
+        msg = ANSICode.magenta(msg)
+        puts msg
+        #puts
+        puts ANSICode.red("#{step.code}")
+      end
+
+      #def report(str)
+      #  count[-1] += 1 unless count.empty?
+      #  str = str.chomp('.') + '.'
+      #  str = count.join('.') + ' ' + str
+      #  puts str.strip
+      #end
+
+    end #class Summary
+
+  end #class Reporter
+
+end #module Quarry
+