qed 1.0.0 → 1.1.0

data/lib/qed/assertion.rb

@@ -1,23 +0,0 @@
-module QED
-
-  # = Assertion
-  #
-  # This is the core class of the whole specification system.
-  #
-  class Assertion < Exception
-
-    def initialize(message, backtrace=nil)
-      super(message)
-      set_backtrace(backtrace) if backtrace
-    end
-
-    def to_str
-      message.to_s.strip
-    end
-
-  end
-
-end
-
-# Copyright (c) 2008 Tiger Ops
-

data/lib/qed/doubles/mock.rb

@@ -1,94 +0,0 @@
-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

@@ -1,191 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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
-