quarry 0.3.0 → 0.4.0

data/work/deprecated/spec.rb

@@ -0,0 +1,195 @@
+require 'quarry/assertion'
+
+module Quarry
+
+  class << self
+    def specification(description, &specification)
+      Design.specification(description, &specification)
+    end
+
+    alias_method :spec, :specification
+  end
+
+  module Design
+
+    class << self
+      def specifications
+        @specifications ||= []
+      end
+
+      def specification(description, &specification)
+        specifications << Spec.new(description, nil, &specification)
+      end
+      alias_method :spec, :specification
+
+      # TODO: make output compatible with unit_diff ?
+
+      def check
+        specifications.each do |specification|
+          Runner.new(specification).check
+        end
+      end
+
+      def outline
+        specifications.each do |specification|
+          Runner.new(specification).outline
+        end
+      end
+    end
+
+    # = Spec
+    #
+    class Spec
+      #undef_method *instance_methods.select{|m| m.to_s !~ /^(__|instance_|object_)/}
+
+      # Specification description.
+      attr :description
+
+      # Parent specification (if any).
+      attr :parent
+
+      #
+      attr :given
+
+      #
+      attr :before
+
+      #
+      attr :after
+
+      # Subspecifications
+      attr :specs
+
+      # Steps in specification proof.
+      attr :steps
+
+      #
+      def initialize(description, parent, &block)
+        #@relation       = relation
+        @description = description
+        @parent      = parent
+
+        @given  = nil
+        @before = nil
+        @after  = nil
+
+        @specs = []
+        @steps = []
+
+        instance_eval(&block)
+      end
+
+      #
+      def given(&block)
+        block ? @given = block : @given
+      end
+
+      #
+      def before(&block)
+        block ? @before = block : @before
+      end
+
+      #
+      def after(&block)
+        block ? @after = block : @after
+      end
+
+      def context(description, &block)
+        specs << Spec.new(description, self, &block)
+      end
+
+      #
+      def prove(description, &block)
+        steps << Step.new(description, self, &block)
+      end
+
+      alias_method :it,  :prove
+      alias_method :its, :prove
+
+      #
+      #def method_missing(relation, *description, &specification)
+      #  if description.size > 1
+      #    super
+      #  else
+      #    specifications << Specification.new(relation, description.first, self, &specification)
+      #  end
+      #end
+    end #class Context
+
+    #
+    class Step
+      attr :description
+      attr :parent
+      attr :code
+
+      def initialize(description, parent, &code)
+        @description = description
+        @parent      = parent
+        @code        = code
+      end
+    end
+
+  end #module Desgin
+
+end #module Quarry
+
+#at_exit { Quarry::Design.check unless $no_autocheck }
+
+
+=begin demo
+
+  Quarry::Design.specification "Example Specification" do
+
+    context "demonstrate basic assertions" do
+
+      specify "fail if should is false" do
+        4.assert == 3
+      end
+
+      specify "fail if should_not is true" do
+        4.assert! == 4
+      end
+
+      specify "fail on should raise" do
+        lambda{raise ArgumentError}.assert.raise? SyntaxError
+      end
+
+    end
+
+  end
+
+  $no_autocheck = true
+
+  Quarry::Design.outline
+
+=end
+
+
+if __FILE__ == $0
+
+  Quarry::Design.spec "Example Specification" do
+
+    it "demontrates basic assertions" do
+
+      it "eg. 4 == 3 fails" do
+        4.assert == 3
+      end
+
+      it "eg. 4 != 4 fails" do
+        4.assert! == 4
+      end
+
+      it "eg. raises an ArgumentError does not raise a SyntaxError" do
+        lambda{raise ArgumentError}.assert.raise? SyntaxError
+      end
+
+    end
+
+  end
+
+  $no_autocheck = true
+
+  Quarry::Design.outline
+
+end
+

data/work/deprecated/stub/stub.0.rb

@@ -0,0 +1,180 @@
+module Quarry
+  require 'ostruct'
+
+  # = Stub
+  #
+  # A straightfoward stubbing facility. Typically used in test cases.
+  # The Stub class offers a few constructors for quickly building
+  # of stubs.
+  #
+  #   stat - Returns a static reponse.
+  #   echo - Returns the arguments passed-in.
+  #   spin - Returns a rotation of responses.
+  #   keys - Returns an index of responses.
+  #
+  # Stub classes can be built from sratch or partially framed
+  # against other classes.
+  #
+  # === Usage
+  #
+  #   class ContextStub < Stub
+  #     stat :response_headers, {}
+  #     spin :host_url, ['http://www.nitrohq.com','http://www.rubyforge.com']
+  #   end
+  #
+  #   ctx = ContextStub.new
+  #   ctx.response_headers['location'] = url
+  #   ctx.host_url   #=> "http://www.nitrohq.com"
+  #   ctx.host_url   #=> "http://www.rubyforge.com"
+  #
+  # === Note
+  #
+  # Quarry doesn't have Mocks, and may never. You can combine
+  # Stubs and Assertions fairly effectively to do essentailly
+  # what Mocks do, without having to learn yet another DSL
+  # for describing object behaviors.
+  # 
+  class Stub < OpenStruct
+
+    # Certain methods are not mocked:
+    #   inspect       (tricky)
+    #   class         (delegated)
+    #   kind_of?      (delegated)
+    #   is_a?         (delegated)
+    #   instance_of?  (delegated)
+    #   method        (works as-is)
+    #   send          (works as-is)
+    #   respond_to?   (works as-is)
+    #   hash          (no way to mock)
+    #
+    #   __id__, __call__, etc. (not meant to be stubbed, ever!)
+    #
+    UnstubbedMethods = %r{^(
+      |inspect
+      |kind_of\?|is_a\?|instance_of\?|class
+      |method|send|respond_to\?
+      |hash
+      |__
+    )}x
+
+    class << self
+      attr :realclass
+
+      def stubbed_methods
+        self.methods(false)
+      end
+
+      # Returns a static response.
+      def stat(sym, val)
+        define_method(sym){|*args| val}
+      end
+
+# This one is dumb.
+      # Responds with input.
+      def echo(sym)
+        define_method(sym){|*args| args}
+      end
+
+# This is probably dumb.
+      # Reponds with a rotation of reponses.
+      def spin( sym, arr )
+        define_method( sym ) { |*args| arr.push(arr.shift) ; arr[-1] }
+      end
+
+      # Responds according to a mapping of input parameters.
+      def keys( sym, hsh )
+        define_method( sym ) { |*args| hsh[args] }
+      end
+    end
+
+    alias :__class :class
+
+    # Delegate #class method.
+    def class # :nodoc:
+      return __class.realclass
+    end
+
+    # Delegate #instance_of? method.
+    def instance_of?(klass) # :nodoc:
+      self.class == klass
+    end
+
+    # Delegate #kind_of? method.
+    def kind_of?(klass) # :nodoc:
+      self.class <= klass
+    end
+
+    # Delegate #is_a? method.
+    alias_method :is_a?, :kind_of?
+
+  end # class Stub
+
+  ### Factory method for automatically creating semi-functional
+  ### stub classes given a real class. It looks like a constant
+  ### for purposes of syntactic sugar.
+  ###
+  ###   class MyStub < Stub(X)
+  ###      ...
+  ###   end
+  ###
+  def self.Stub(realclass)
+
+    stubclass = Class.new(Stub)
+
+    stubclass.instance_eval{ @realclass = realclass }
+
+    # Provide an accessor to class instance var that holds the class
+    # object we're faking
+    class << stubclass
+      # The actual class being mocked
+      attr_reader :realclass
+
+      # Propagate the mocked class ivar to derivatives so it can be
+      # called like:
+      #   class MockFoo < Mock(RealClass)
+      def inherited(subclass)
+        rc = self.realclass
+        subclass.instance_eval{ @realclass = rc }
+      end
+    end
+
+    # Build method definitions for all the mocked class's instance
+    # methods, as well as those given to it by its superclasses, since
+    # we're not really inheriting from it.
+    imethods = realclass.instance_methods(true).collect do |name|
+      next if name =~ Quarry::Stub::UnstubbedMethods
+
+      # Figure out the argument list
+      arity = realclass.instance_method(name).arity
+      optargs = false
+
+      if arity < 0
+        optargs = true
+        arity = (arity+1).abs
+      end
+
+      args = []
+      arity.times{|n| args << "arg#{n+1}"}
+      args << "*optargs" if optargs
+
+      # Build a method definition. Some methods need special
+      # declarations.
+      argsj = args.join(',')
+      case name.intern
+      when :initialize
+        "def initialize(#{argsj}) ; super ; end"
+      else
+        "def #{name}(#{argsj}) ; self.send(#{name},#{argsj}) ; end"
+        #"def %s( %s ) ; self.__mockRegisterCall(%s) ; end" %
+        #  [ name, argstr, [":#{name}", *args].join(',') ]
+      end
+    end
+
+    # Now add the instance methods to the stubclass class
+    stubclass.class_eval imethods.join( "\n" )
+
+    return stubclass
+  end
+
+end
+

data/work/deprecated/stub/stub.1.rb

@@ -0,0 +1,114 @@
+require 'quarry/stub/overlay'
+
+module Quarry
+
+=begin
+  class Stub
+    def initialize(object)
+      @instance_delegate = object
+    end
+
+    def method_missing(s, *a, &b)
+      @instance_delegate.__send__(s, *a, &b)
+    end
+  end
+=end
+
+  # Quarry's Stubbing facility.
+  #
+  #   obj = "hello"
+  #
+  #   obj.stub.upcase == "HeLLo"
+  #
+  #   obj.upcase  #=> "HeLLo"
+  #
+  #   obj.stubless!
+  #
+  #   obj.upcase  #=> "HELLO"
+  #
+  class Stub < Module
+    attr :object
+
+    def initialize(object)
+      super()
+      @object  = object
+      @table   = {}
+      @overlay = Overlay.new
+    end
+
+    def __table__ ; @table ; end
+
+    def method_missing(meth, *args, &block)
+      table     = @table
+      interface = [meth, args, block_given?]
+
+      table[interface] = nil
+
+      @overlay.define_method(meth) do |*args|
+        table[interface]
+      end
+
+      @overlay.append_features((class << @object; self; end))
+
+      Setter.new(table, interface)
+    end
+
+    #
+    class Setter
+      def initialize(table, interface)
+        @table     = table
+        @interface = interface
+      end
+
+      def ==(result)
+        @table[@interface] = result
+      end
+    end
+
+  end
+
+  #
+  class ::Object
+
+    def stub
+      @_stub ||= Stub.new(self)
+    end
+
+    def remove_stubs
+      stub.instance_eval do
+        @overlay.remove_features((class << @object; self; end))
+      end
+      #stub.__table__.each do |interface, result|
+      #  meth = interface[0]
+      #  stub.module_eval do
+      #    remove_method(meth)
+      #  end
+      #end
+    end
+
+  end
+
+end
+
+if $0 == __FILE__
+
+   # Only one possible stub definition per object?
+
+   obj = "hello"
+
+   obj.stub.upcase == "HeLLo"
+
+   p obj.upcase  #=> "HeLLo"
+
+   # We could always copy it.
+
+   obj2 = obj.copy
+
+   # Eek that means we need to copy stub too (FIXME: initialize_copy)
+
+   obj.remove_stubs
+
+   p obj.upcase  #=> "HELLO"
+
+end
+

data/work/deprecated/stub/test_stub.rb

@@ -0,0 +1,66 @@
+require 'quarry/stub'
+require 'test/unit'
+
+class TC_Stub < Test::Unit::TestCase
+
+  class S < Quarry::Stub
+    stat :m, 10
+    echo :e
+    spin :s, [1,2,3]
+    keys :i, { [:foo] => 'Hello', [:boo] => 'Frog' }
+
+    def a(k) k+1 end
+  end
+
+  def setup
+    @s = S.new
+  end
+
+  def test_stat
+    assert_equal(10, @s.m)
+  end
+
+  def test_echo
+    assert_equal([:hi], @s.e(:hi))
+  end
+
+  def test_spin
+    assert_equal(1, @s.s)
+    assert_equal(2, @s.s)
+    assert_equal(3, @s.s)
+    assert_equal(1, @s.s)
+  end
+
+  def test_keys
+    assert_equal('Hello', @s.i(:foo))
+    assert_equal('Frog',  @s.i(:boo))
+  end
+
+  def assert_normal_method
+    assert_equal(2, @s.a(1))
+  end
+end
+
+class TC_Stub_Wrapper < Test::Unit::TestCase
+
+  class X
+    def a; "a"; end
+    def b; "b"; end
+    def c; "c"; end
+  end
+
+  class XS < Quarry::Stub(X)
+  end
+
+  def setup
+    @xs = XS.new
+  end
+
+  def test_responds
+    assert_equal(nil, @xs.a)
+    assert_equal(nil, @xs.b)
+    assert_equal(nil, @xs.c)
+  end
+
+end
+

data/work/deprecated/test/case.rb

@@ -0,0 +1,141 @@
+#require 'facet/kernel/within?'
+require 'quarry/assert'
+
+at_exit { Quarry::Test.autotest unless $no_autotest }
+
+module Quarry
+module Test
+
+  # TODO: make output compatible with unit_diff ?
+
+  def self.autotest
+    ::ObjectSpace.each_object(Suite) do |suite|
+      puts "Running test suite #{suite.description.upcase}:"
+      suite.cases.each do |kase|
+        puts "== #{kase.description.upcase}\n"
+        kase.units.each_with_index do |test, i|
+          kase.setup
+          begin
+            test.call
+
+          rescue Assertion => e
+            print "#{i+1}) #{test.description}"
+            print "\a  FAIL! "
+            puts "[" + e.backtrace[2] + "]"
+            puts "#{e}\n" if $VERBOSE
+
+          rescue Exception => e
+            print "#{i+1}) #{test.description}"
+            print "\a  ERROR! "
+            puts "[" + e.backtrace[2] + "]"
+            puts "#{e}\n" if $VERBOSE
+            #puts "#{klass}.#{meth}: #{e}"
+          ensure
+            kase.teardown
+          end
+        end
+      end
+    end
+  end
+
+  #
+
+  def self.suites
+    @suites ||= []
+  end
+
+  def self.suite(description, &testsuite)
+    suites << Suite.new(description, &testsuite)
+  end
+
+  # A test suite.
+
+  class Suite
+    attr :description
+
+    def initialize(description, &testsuite)
+      @description = description
+      @testsuite   = testsuite
+      @testcases   = []
+
+      instance_eval(&testsuite)
+    end
+
+    def cases
+      @testcases ||= []
+    end
+
+    def test_case(description, &testcase)
+      cases << Case.new(description, &testcase)
+    end
+  end
+
+  # A test case.
+
+  class Case
+    attr :description
+
+    def initialize(description, &testcase)
+      @description = description
+      @testcase    = testcase
+      @testunits   = []
+      instance_eval(&testcase)
+    end
+
+    def units
+      @testunits ||= []
+    end
+
+    def setup; end
+
+    def teardown; end
+
+    def test(description, &testunit)
+      units << Unit.new(description, &testunit)
+    end
+  end
+
+  # A test unit.
+
+  class Unit
+    attr :description
+
+    def initialize(description, &testunit)
+      @description = description
+      @testunit    = testunit
+    end
+
+    def call
+      @testunit.call
+    end
+  end
+
+end
+end
+
+
+# EXAMPLE
+
+if __FILE__ == $0
+
+  Quarry::Test.suite "example suite" do
+
+    test_case "example case" do
+
+      test "4 should equal 3" do
+        4.assert == 3
+      end
+
+      test "4 should not equal 4" do
+        4.assert_not == 4
+      end
+
+      test "raises syntax error" do
+        lambda{raise SyntaxError}.should.raise? SyntaxError
+      end
+
+    end
+
+  end
+
+end