quarry 0.3.0

data/lib/quarry/document.rb

@@ -0,0 +1,35 @@
+$_doc = []
+
+
+class Module
+
+  attr :docs
+
+  # The idea here is to have dynamic docs.
+  #
+  #   doc "X does such and such"
+  #   doc "it is very powerful"
+  #   class X
+  #     doc "f does such and such"
+  #     doc "it is where the power lies"
+  #     def f
+  #       ...
+  #     end
+  #   end
+  #
+  # One of the great things about doc, is that
+  # it can be used to "inherit" documentation.
+
+  def doc(str)
+    $_doc << string
+  end
+
+  def method_added(meth)
+    @docs ||= {}
+    @docs[self, meth] << $_doc
+    $_doc.clear
+    nil
+  end
+
+end
+

data/lib/quarry/loadmonitor.rb

@@ -0,0 +1,14 @@
+BEGIN {
+   module Kernel
+     h = Hash.new
+     define_method(:requiree) do
+       h
+     end
+
+     r = method :require
+     define_method(:require) do |a|
+       r.call a
+       h[a] = caller
+     end
+   end
+}

data/lib/quarry/methodprobe.rb

@@ -0,0 +1,216 @@
+# = 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
+  #
+  # Method::Probe (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 MethodProbe
+
+    def MethodProbe.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 << MethodProbe.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 testing
+
+  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

data/lib/quarry/mock/object.rb

@@ -0,0 +1,169 @@
+# = mock.rb
+#
+# == Copyright (c) 2005 Thomas Sawyer, Michael Granger
+#
+#   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.
+#
+# == Special Thanks
+#
+# Thanks goes to Michael Granger for Test::Unit::Mock on which
+# this library is partially based.
+#
+# == Author(s)
+#
+# * Thomas Sawyer
+# * Michael Granger
+
+require 'ostruct'
+
+module Quarry
+
+  module Mock
+
+    # = Mock Object
+    #
+    # A straightfoward mocking facility. Typically used in test cases.
+    # The Mock class offers a few constructors for quickly building
+    # mockups.
+    #
+    #   mock - Returns a static reponse.
+    #   echo - Returns the arguments passed-in.
+    #   spin - Returns a rotation of responses.
+    #   keys - Returns an index of responses.
+    #
+    # Mock classes can be built from sratch or partially framed
+    # against other classes.
+    #
+    # === Usage
+    #
+    #   class ContextMock < Mock
+    #     mock :response_headers, {}
+    #     spin :host_url, ['http://www.nitrohq.com','http://www.rubyforge.com']
+    #   end
+    #
+    #   ctx = ContextMock.new
+    #   ctx.response_headers['location'] = url
+    #   ctx.host_url   #=> "http://www.nitrohq.com"
+    #   ctx.host_url   #=> "http://www.rubyforge.com"
+    #
+    # Or
+    #
+    #   class ContextMock < Mock(Context)
+    #     ...
+    #   end
+    #
+    class Object < OpenStruct
+
+      # include these?
+      #include Test::Unit::Assertions
+
+      # 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 mocked, ever!)
+      #
+
+      UnmockedMethods = %r{^(
+        |inspect
+        |kind_of\?|is_a\?|instance_of\?|class
+        |method|send|respond_to\?
+        |hash
+        |__
+      )}x
+
+      class << self
+
+        attr :mocked_class
+
+        def mocks
+          self.methods(false)
+        end
+
+        # Mock a static repsonse.
+        def mock( sym, val )
+          define_method( sym ) { |*args| val }
+        end
+
+        # Responds with input.
+        def echo( sym )
+          define_method( sym ) { |*args| args }
+        end
+
+        # 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
+
+      # Delegate methods: #class, instance_of?, kind_of?, and is_a?
+
+      alias :__class :class
+
+      def class # :nodoc:
+        return __class.mocked_class
+      end
+
+      def instance_of?( klass ) # :nodoc:
+        self.class == klass
+      end
+
+      def kind_of?( klass ) # :nodoc:
+        self.class <= klass
+      end
+
+      alias_method :is_a?, :kind_of?
+
+    end
+
+  end
+
+end
+
+
+# TODO
+
+=begin #test
+
+  class MyMock < Mock::Object
+    mock :m, 10
+    echo :e
+    spin :s, [1,2,3]
+    keys :i, { [:foo] => 'Hello', [:boo] => 'Frog' }
+
+    def a(k) k+1 end
+  end
+
+  my = MyMock.new
+
+  p my.m
+  p my.e('hi')
+  p my.s
+  p my.s
+  p my.s
+  p my.i(:foo)
+  p my.i(:boo)
+  p my.a(1)
+
+=end
+

data/lib/quarry/mockery.rb

@@ -0,0 +1,85 @@
+# = mock.rb
+#
+# == Copyright (c) 2005 George Moschovitis
+#
+#   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)
+#
+# * George Moschovitis
+
+require 'ostruct'
+
+module Quarry
+
+  # Factory method for creating semi-functional mock object classes given the
+  # class which is to be mocked. It looks like a constant for purposes
+  # of syntactic sugar.
+  def Mockery( realclass )
+
+    mockclass = Class.new( Mock )
+
+    mockclass.instance_eval do @mocked_class = realclass end
+
+    # Provide an accessor to class instance var that holds the class
+    # object we're faking
+    class << mockclass
+      # The actual class being mocked
+      attr_reader :mocked_class
+
+      # Propagate the mocked class ivar to derivatives so it can be
+      # called like:
+      #   class MockFoo < Mock( RealClass )
+      def inherited( subclass )
+        mc = self.mockedClass
+        subclass.instance_eval do @mocked_class = mc end
+      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 =~ ::Mock::UnmockedMethods
+
+      # 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 do |n| args << "arg#{n+1}" end
+      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 mockclass class
+    mockclass.class_eval imethods.join( "\n" )
+
+    return mockclass
+  end
+
+end
+