quarry 0.3.0 → 0.4.0

data/work/sandbox/iface_scanner.rb

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

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

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

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

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