quarry 0.4.0 → 0.5.0

data/work/sandbox/iface_scanner.rb

@@ -1,102 +0,0 @@
-
-module Quarry
-
-module Documentation
-
-  class RubyCollector
-
-    def initialize(*paths)
-      @classes = []
-      @modules = []
-    end
-
-    def collect
-      ObjectSpace.each_object(Class) do |reference|
-        @classes << ClassSpecification.new(reference)
-      end
-
-      ObjectSpace.each_object(Module) do |reference|
-        @modules << ModuleSpecification.new(reference)
-      end
-    end
-
-    def to_xml
-      inner = []
-      inner << to_xml_for_modules
-      inner << to_xml_for_classes
-      inner = inner.join("\n")
-
-      xml = %{<ruby-program>\n#{inner}\n</ruby-program>}
-    end
-
-    def to_xml_for_classes
-      template = <<-END
-        <class name="%s">
-        </class>
-      END
-      inner = []
-      @classes.each do
-        inner << template % [ reference.name ]
-      end
-      inner = inner.join("\n")
-      classes_xml = %{<classes>\n#{inner}\n</classes>}
-    end
-
-    def to_xml_for_modules
-      template = <<-END
-        <module name="%s">
-        </module>
-      END
-      inner = []
-      @modules.each do
-        inner << template % [ reference.name ]
-      end
-      inner = inner.join("\n")
-      classes_xml = %{<modules>\n#{inner}\n</modules>}
-    end
-
-  end
-
-  #
-
-  class ModuleSpecification
-    attr :reference
-
-    def initialize(reference)
-      @reference = reference
-    end
-
-    def public_instance_methods
-      reference.public_instance_methods(false)
-    end
-
-    def private_instance_methods
-      reference.private_instance_methods(false)
-    end
-
-    def protected_instance_methods
-      reference.protected_instance_methods(false)
-    end
-
-    def public_methods
-      reference.public_methods(false)
-    end
-
-    def private_methods
-      reference.private_methods(false)
-    end
-
-    def protected_methods
-      reference.protected_methods(false)
-    end
-
-  end
-
-  #
-
-  class ClassSpecification < ModuleSpecification
-  end
-
-end
-
-end

data/work/sandbox/testunit/assertions/assert_has_keys.rb

@@ -1,38 +0,0 @@
-require 'facets/core/hash/has_keys'
-
-class Hash
-
-  # Returns true is hash has the given keys,
-  # otherwise throws an ArgumentError.
-  #
-  #   h = { :a => 1, :b => 2 }
-  #   h.assert_has_keys( :a )   #=> true
-  #   h.assert_has_keys( :c )   #=> ArgumentError
-  #
-  def assert_has_keys(*check_keys)
-    raise(ArgumentError, "does not have key(s)") unless has_keys?(*check_keys)
-  end
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCHash < Test::Unit::TestCase
-
-    def test_assert_has_keys
-      assert_nothing_raised { { :a=>1,:b=>2,:c=>3 }.assert_has_keys(:a,:b) }
-      assert_raises( ArgumentError ) { { :a=>1,:b=>2,:c=>3 }.assert_has_keys(:d) }
-    end
-
-  end
-
-=end

data/work/sandbox/testunit/assertions/assert_has_only_keys.rb

@@ -1,38 +0,0 @@
-require 'facets/core/hash/has_only_keys'
-
-class Hash
-
-  # Returns true is hash has only then given keys,
-  # otherwise throws an ArgumentError.
-  #
-  #   h = { :a => 1, :b => 2 }
-  #   h.assert_has_only_keys( :a, :b )   #=> true
-  #   h.assert_has_only_keys( :a )       #=> ArgumentError
-  #
-  def assert_has_only_keys(*check_keys)
-    raise(ArgumentError, "has unexpected key(s)") unless has_only_keys?(*check_keys)
-  end
-
-end
-
-
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
-=begin test
-
-  require 'test/unit'
-
-  class TCHash < Test::Unit::TestCase
-
-    def test_assert_has_only_keys
-      assert_nothing_raised {  { :a=>1,:b=>2,:c=>3 }.assert_has_only_keys(:a,:b,:c) }
-      assert_raises( ArgumentError ) { { :a=>1,:b=>2,:c=>3 }.assert_has_only_keys(:a,:b) }
-    end
-
-  end
-
-=end

data/work/sandbox/testunit/unit.rb

@@ -1,104 +0,0 @@
-#
-# Totally minimal (hopefully) drop-in replacement for test/unit
-#
-
-# TODO: document minimal core methods needed for this to work
-
-at_exit { Test::Unit.autotest }
-
-module Test #:nodoc: all
-  class Assertion < Exception; end
-
-  class Unit
-    VERSION = "1.0.0"
-
-    def self.autotest
-      ObjectSpace.each_object(Class) do |klass|
-        next unless klass < Test::Unit::TestCase
-        inst = klass.new
-        klass.public_instance_methods(true).each do |meth|
-          next unless meth.index("test") == 0
-          begin
-            inst.setup
-            inst.send meth.intern
-            inst.teardown
-          rescue Exception => e
-            # TODO: make output compatible with unit_diff
-            print "\n", (Test::Assertion === e ? "Failure: " : "Error: ")
-            puts "#{klass}.#{meth}: #{e}"
-            puts e.backtrace
-          end
-        end
-      end
-    end
-
-    class TestCase
-      def setup; end
-      def teardown; end
-
-      def assert(test, msg="failed assertion (no message given)")
-        raise Test::Assertion, msg unless test
-      end
-
-      def assert_equal(exp, act, msg=nil)
-        assert exp == act, msg || "Expected #{act.inspect} to be equal to #{exp.inspect}"
-      end
-
-      def assert_in_delta(exp, act, delta, msg=nil)
-        assert((exp.to_f - act.to_f).abs <= delta.to_f, msg || "Expected #{exp} to be within #{delta} of #{act}")
-      end
-
-      def assert_instance_of(cls, obj, msg=nil)
-        assert cls === obj, msg || "Expected #{obj} to be a #{cls}"
-      end
-
-      def assert_kind_of(cls, obj, msg=nil)
-        assert obj.kind_of?(cls), msg || "Expected #{obj.inspect} to be a kind of #{cls}"
-      end
-
-      def assert_match(exp, act, msg=nil)
-        assert act =~ exp, msg || "Expected #{act.inspect} to match #{exp.inspect}"
-      end
-
-      def assert_nil(obj, msg=nil)
-        assert obj.nil?, msg || "Expected #{obj.inspect} to be nil"
-      end
-
-      def assert_not_equal(exp, act, msg=nil)
-        assert exp != act, msg || "Expected #{act.inspect} to not be equal to #{exp.inspect}"
-       end
-
-      def assert_not_nil(obj, msg=nil)
-        assert ! obj.nil?, msg || "Expected #{obj.inspect} to not be nil"
-      end
-
-      def assert_not_same(exp, act, msg=nil)
-        assert ! exp.equal?(act), msg || "Expected #{act.inspect} to not be the same as #{exp.inspect}"
-      end
-
-      def assert_raises(exp, msg=nil)
-        begin
-          yield
-          assert false, "Expected #{exp} to be raised"
-        rescue Exception => e
-          assert exp === e, msg || "Expected #{exp} to be raised, but got #{e.class}"
-          return e
-        end
-      end
-      alias :assert_raise :assert_raises
-
-      def assert_same(exp, act, msg=nil)
-        assert exp.equal?(act), msg || "Expected #{act.inspect} to be the same as #{exp.inspect}"
-      end
-
-      def assert_operator(o1, op, o2, msg="")
-        assert o1.__send__(op, o2), msg || "Expected #{o1}.#{op}(#{o2}) to be true"
-      end
-
-      def assert_nothing_raised; yield; end
-
-    end # class TestCase
-  end # class Unit
-end # module Test
-
-

data/work/sandbox/unitspec.rb

@@ -1,54 +0,0 @@
-=begin
-
-The idea here is that unit tests should reflect
-the model of the class and method it is testing.
-To do this we want to achieve a kind of AOP-like
-system to monitor the original. So for instance,
-given:
-
-  class Hash
-
-    # Push a pair onto the
-    #
-    #
-    def #<<(pair)
-      self.store(*pair)
-    end
-
-  end
-
-We could construct:
-
-  require 'quarry/unitspec'
-
-  module Quarry::UnitSpecs
-
-    class Hash << ::Hash
-
-      def #<<(pair)
-        r = super
-        self[pair[0]].assert == pair[1]
-        r
-      end
-
-    end
-
-    h = Hash.new
-    h << [:a, 1]
-
-  end
-
-To make this more convenient.
-
-  Quarry.unitspec(Hash) do
-
-    unit(:<<) do |pair|
-      r = super
-      self[pair[0]].assert == pair[1]
-      r
-    end
-
-  end
-
-=end
-