qed 1.0.0

data/lib/qed/doubles/mock.rb

@@ -0,0 +1,94 @@
+module QED
+
+  # = Mock
+  #
+  class Mock < Module
+    attr :object
+
+    def initialize
+      super()
+      @table = {}
+    end
+
+    #
+    def __table__ ; @table ; end
+
+    # TODO: Ruby has retry, but I need continue!
+    def method_missing(meth, *args, &block)
+      table     = @table
+      interface = [meth, args, block_given?]
+
+      table[interface] = nil
+
+      define_method(meth) do |*args|
+        result = super
+        result.assert == table[interface]
+        return result
+      end
+
+      Setter.new(table, interface)
+    end
+
+    #
+    class Setter
+      def initialize(table, interface)
+        @table     = table
+        @interface = interface
+      end
+
+      def ==(result)
+        @table[@interface] = result
+      end
+    end
+
+    # = Mock::Delegator
+    #
+    class Delegator
+      instance_methods(true).each{ |m| protected m unless m.to_s =~ /^__/ }
+
+      def initialize(object, mock_module)
+        @instance_delegate = object
+        extend(mock_module)
+      end
+
+      def method_missing(s, *a, &b)
+        @instance_delegate.__send__(s, *a, &b)
+      end
+    end#class Delegator
+
+  end#class Mock
+
+  class ::Object
+    # Create mock object.
+    def mock(mock_module=nil)
+      if mock_module
+        Mock::Delegator.new(self, mock_module)
+      else
+        @_mock ||= Mock.new
+        extend(@_mock)
+        @_mock
+      end
+    end
+
+    # We can't remove the module per-say.  So we have to
+    # just neuter it. This is a very weak solution, but
+    # it will suffice for the moment.
+    #--
+    # TODO: Use Carats for #unmix.
+    #++
+    def remove_mock(mock_module=nil)
+      mock_module ||= @_mock
+      obj = self
+      mod = Module.new
+      mock_module.__table__.each do |interface, result|
+        meth = interface[0]
+        mod.module_eval do
+          define_method(meth, &obj.class.instance_method(meth).bind(obj))
+        end
+      end
+      extend(mod)
+    end
+  end#class ::Object
+
+end#module Quarry
+

data/lib/qed/doubles/spy.rb

@@ -0,0 +1,191 @@
+raise "Spy class is under construction"
+
+module QED
+
+  # = Spy
+  #
+  # Spy (aka DuckHunter) is a decoy object which is dropped into
+  # methods which records the calls made against it --hence a method probe.
+  # Of course, it is not perfect --an inescapable matter it seems for any
+  # internal probe. There are a couple of issues related to conditionals.
+  # Since the method test for a certain condition against the decoy, how
+  # is the decoy to respond? Thus ceratin paths in the code may never get
+  # exceuted and thus go unmapped. If Ruby had better conditional reflection
+  # (i.e. if 'if', 'case', 'unless', 'when', etc. were true methods) then
+  # this could be fixed by making the Probe reentrant, mapping out variant
+  # true/false/nil replies. The likely insurmountable problem though is the
+  # Halting problem. A probe can cause some methods to complete execution.
+  # It's pretty rare, but it can happen and little can be done about it (I think).
+  #
+  # Note, the alternative to this kind of probe is a program that examines, rather
+  # then executes, the code. This would circumvent the above problems, but run
+  # into difficulties with dynamic evals. It would also be more complicated,
+  # but might prove a better means in the future.
+  #
+  # This script is provided for experimetnal purposes. Please inform the author
+  # if you find ways to improve it or put it to an interesting use.
+  #
+  # == Synopsis
+  #
+  #   require 'methodprobe'
+  #
+  #   def amethod(x)
+  #     x + 1
+  #   end
+  #
+  #   p method(:amethod).signiture
+  #   p method(:amethod).signiture(:class)
+  #   p method(:amethod).signiture(:pretty)
+  #
+  # produces
+  #
+  #   [["+"]]
+  #   [{"+"=>[["Fixnum"]]}]
+  #   [["+( Fixnum )"]]
+  #
+  class Spy
+
+    def self.duckcall
+      begin
+        yield
+      rescue TypeError => e
+        self.send(e.message)
+        retry
+      end
+    end
+
+    attr_reader :ducks, :decoys
+
+    def initialize
+      @ducks, @decoys = {}, {}
+    end
+
+    def initialize_copy(from)
+      initialize
+    end
+
+    def method_missing(aSym, *args)
+      aSymStr = aSym.to_s
+
+      # This will happen the first time
+      @ducks[aSymStr] ||= [] #unless @ducks[aSymStr]
+      @ducks[aSymStr] << args.collect { |a| "#{a.class}" }
+
+      decoy = self.dup
+
+      @decoys[aSymStr] ||= [] #unless @decoys[aSymStr]
+      @decoys[aSymStr] << decoy
+
+      # build proxy?
+      #begin
+      #  d = <<-HERE
+      #    def self.#{aSymStr}(*args)
+      #      # This will happen the subsequent times
+      #      @ducks["#{aSymStr}"] << args.collect { |a| #{'"#{a.class}"'} }
+      #      @ducks["#{aSymStr}"].uniq!
+      #      decoy = self.dup
+      #      @decoys["#{aSymStr}"] = [] unless @decoys["#{aSymStr}"]
+      #      @decoys["#{aSymStr}"] << decoy
+      #      decoy
+      #    end
+      #  HERE
+      #  instance_eval d
+      #rescue SyntaxError
+      #  puts "This error may be avoidable by returning the failing duck type as the error message."
+      #  raise
+      #end
+
+      decoy
+    end
+
+  end # class MethodProbe
+
+end
+
+
+class ::Method
+
+  # Outputs migration information.
+  def migration
+    parameters = []; argc = self.arity
+    if argc > 0
+      argc.times { parameters << Quarry::Probe.new }
+      Probe.duckcall { self.call(*parameters) }
+    elsif argc < 0
+      raise "(NYI) method takes unlimited arguments"
+    end
+    return parameters
+  end
+  private :migration
+
+  # Outputs signiture information.
+  def signature(detail=nil)
+    ds = []
+    case detail
+    when :complete, :all, :full
+      ds = migration
+    when :class, :with_class
+      migration.each { |dh| ds << dh.ducks }
+    when :pp, :pretty, :prettyprint, :pretty_print
+      migration.each do |dh|
+        responders = []
+        dh.ducks.each do |responder, argss|
+          argss.each { |args| responders << "#{responder}( #{args.join(',')} )" }
+        end
+        ds << responders
+      end
+    else
+      migration.each { |dh| ds << dh.ducks.keys }
+    end
+    return ds
+  end
+
+end
+
+
+
+
+
+=begin test
+
+  require 'test/unit'
+
+  # " I am a Duck Hunter ! "
+
+  class TC_MethodProbe < Test::Unit::TestCase
+
+    # fixture
+    def amethod(x)
+      x + 1
+    end
+
+    def test_signiture_default
+      assert_nothing_raised {
+        method(:amethod).signature
+      }
+    end
+
+    def test_signiture_with_class
+      assert_nothing_raised {
+        method(:amethod).signature(:class)
+      }
+    end
+
+    def test_signiture_pp
+      assert_nothing_raised {
+        method(:amethod).signature(:pp)
+      }
+    end
+
+    def test_signiture_all
+      assert_nothing_raised {
+        method(:amethod).signature(:complete)
+      }
+    end
+
+  end
+
+=end
+
+# Copyright (c) 2004,2008 Thomas Sawyer
+

data/lib/qed/doubles/stub.rb

@@ -0,0 +1,94 @@
+module QED
+
+  # = Stub
+  #
+  class Stub < Module
+    attr :object
+
+    def initialize
+      super()
+      @table = {}
+    end
+
+    #
+    def __table__ ; @table ; end
+
+    #
+    def method_missing(meth, *args, &block)
+      table     = @table
+      interface = [meth, args, block_given?]
+
+      table[interface] = nil
+
+      define_method(meth) do |*args|
+        table[interface]
+      end
+
+      Setter.new(table, interface)
+    end
+
+    #
+    class Setter
+      def initialize(table, interface)
+        @table     = table
+        @interface = interface
+      end
+
+      def ==(result)
+        @table[@interface] = result
+      end
+    end#class Setter
+
+    # = Stub::Delegator
+    #
+    class Delegator
+      instance_methods(true).each{ |m| protected m unless m.to_s =~ /^__/ }
+
+      def initialize(object, stub_module)
+        @instance_delegate = object
+        extend(stub_module)
+      end
+
+      def method_missing(s, *a, &b)
+        @instance_delegate.__send__(s, *a, &b)
+      end
+    end
+
+  end#class Stub
+
+  class ::Object
+
+    # Create a new stub.
+    def stub(stub_module=nil)
+      if stub_module
+        Stub::Delegator.new(self, stub_module)
+      else
+        @_stub ||= Stub.new
+        extend(@_stub)
+        @_stub
+      end
+    end
+
+    # We can't remove the module per-say.  So we have to
+    # just neuter it. This is a very weak solution, but
+    # it will suffice for the moment.
+    #--
+    # TODO: Use Carats for #unmix.
+    #++
+    def remove_stub(stub_module=nil)
+      stub_module ||= @_stub
+      obj = self
+      mod = Module.new
+      stub_module.__table__.each do |interface, result|
+        meth = interface[0]
+        mod.module_eval do
+          define_method(meth, &obj.class.instance_method(meth).bind(obj))
+        end
+      end
+      extend(mod)
+    end
+
+  end#class ::Object
+
+end#module Quarry
+

data/lib/qed/expectation.rb

@@ -0,0 +1,60 @@
+module QED
+
+  require 'qed/assertion'
+
+  # = Expectation
+  #
+  # Expectation is an Assertion Functor.
+  #
+  class Expectation
+
+    hide = instance_methods.select{ |m| m.to_s !~ /^__/ }
+    hide.each{ |m| protected m  }
+
+    private
+
+    # New Expectation.
+    #
+    def initialize(delegate, ioc={}) #, backtrace)
+      @delegate  = delegate
+      @negate    = ioc[:negate]
+      @message   = ioc[:message]
+      @backtrace = ioc[:backtrace] || caller #[1..-1]
+    end
+
+    # Converts missing method into an Assertion.
+    #
+    def method_missing(sym, *a, &b)
+      test = @delegate.__send__(sym, *a, &b)
+
+      if (@negate ? test : !test)
+        msg   = @message || __msg__(sym, *a, &b)
+        error = Assertion.new(msg)
+        error.set_backtrace(@backtrace)
+        raise error
+      end
+    end
+
+    # Puts together a suitable error message.
+    #
+    def __msg__(m, *a, &b)
+      if @negate
+        "! #{@delegate.inspect} #{m} #{a.collect{|x| x.inspect}.join(',')}"
+      else
+        "#{@delegate.inspect} #{m} #{a.collect{|x| x.inspect}.join(',')}"
+      end
+      #self.class.message(m)[@delegate, *a] )
+    end
+
+    # TODO: Ultimately better messages would be nice ?
+    #
+    #def self.message(op,&block)
+    #  @message ||= {}
+    #  block ? @message[op.to_sym] = block : @message[op.to_sym]
+    #end
+    #
+    #message(:==){ |*a| "Expected #{a[0].inspect} to be equal to #{a[1].inspect}" }
+  end
+
+end
+

data/lib/qed/grammar/assert.rb

@@ -0,0 +1,104 @@
+module QED
+
+  require 'qed/expectation'
+
+  module Grammar
+
+    # = Assert Nomenclature
+    #
+    module Assert
+
+      # Assert a operational relationship.
+      #
+      #   4.assert == 3
+      #
+      # If only a single test argument is given then
+      # #assert simple validates that it evalutate to true.
+      # An optional message argument can be given in this
+      # case which will be used instead of the deafult message.
+      #
+      #   assert(4==3, "not the same thing")
+      #
+      # In block form, #assert ensures the block evalutes
+      # truthfully, i.e. not as nil or false.
+      #
+      #   assert{ 4==3 }
+      #
+      # If an argument is given with a block, #assert compares
+      # the argument to the result of evaluating the block.
+      #
+      #   assert(4){ 3 }
+      #
+      # #assert compares the expected value and the actual
+      # value with regular equality <code>#==</code>.
+      #
+      def assert(test=Exception, msg=nil, &block)
+        if block
+          act = block.call
+          if test == Exception
+            raise Assertion.new(msg, caller) unless act
+          else
+            yes = (test == act)
+            msg = "#{exp}.equate? #{act}" unless msg
+            raise Assertion.new(msg, caller) unless yes
+          end
+        elsif test != Exception
+          msg = "failed assertion (no message given)" unless msg
+          raise Assertion.new(msg, caller) unless test
+        else
+          return Expectation.new(self, :backtrace=>caller)
+        end
+      end
+
+      # Assert not an operational relationship.
+      # Read it as "assert not".
+      #
+      #   4.assert! == 4
+      #
+      # See #assert.
+      #
+      # AUHTOR'S NOTE: This method would not be necessary
+      # if Ruby would allow +!=+ to be define as a method,
+      # or at least +!+ as a unary method.
+      #
+      def assert!(test=Exception, msg=nil, &block)
+        if block
+          act = block.call
+          if test == Exception
+            raise Assertion.new(msg, caller) if act
+          else
+            yes = (test == act)
+            msg = "#{exp}.equate? #{act}" unless msg
+            raise Assertion.new(msg, caller) if yes
+          end
+        elsif test != Exception
+          msg = "failed assertion (no message given)" unless msg
+          raise Assertion.new(msg, caller) if test
+        else
+          return Expectation.new(self, :negate=>true, :backtrace=>caller)
+        end
+
+        if test
+          msg = "failed assertion (no message given)" unless msg
+          raise Assertion.new(msg, caller) if test
+        else
+          return Expectation.new(self, :negate=>true, :backtrace=>caller)
+        end
+      end
+
+      # Same as #assert!.
+      #
+      # 4.refute == 4  #=> Assertion Error
+      #
+      alias_method :refute, :assert!
+
+    end
+
+  end
+
+  class ::Object #:nodoc:
+    include Grammar::Assert
+  end
+
+end
+