quarry 0.3.0 → 0.4.0

data/meta/created

@@ -0,0 +1 @@
+2006-12-16

data/meta/homepage

@@ -0,0 +1 @@
+http://quarry.rubyforge.org

data/meta/requires

@@ -0,0 +1 @@
+clio

data/meta/summary

@@ -0,0 +1 @@
+Ruby Development Libraries

data/spec/basic.rd

@@ -0,0 +1,20 @@
+= Example of Ruby Quarry Specification
+
+Notice this file is just a RDoc formatted text file.
+It could just as well be a Markdown file, or nearly any
+other markup format.
+
+Okay. Lets try out some code.
+
+  (2 + 2).assert == 4
+
+Now something that will fail:
+
+  (2 + 2).assert == 5
+
+And some that will raise an error:
+
+  nobody_knows_method
+
+QED.
+

data/spec/complex.rd

@@ -0,0 +1,50 @@
+= Before and After in a Quarry Specification
+
+Quarry supports before and after clauses in specifications through
+the use of *BEFORE:* and *AFTER:* indicators. Before and after
+clauses are executed at the beginning and at the end of each test
+step.
+
+BEFORE: We use a before clause if we want to setup some code at the
+start of each step.
+ 
+  #puts "Starting step..."
+
+AFTER: And an after clause to teardown objects after a step.
+
+  #puts "Finished!"
+
+There can only be one before or after clause at a time. So if
+we define a new BEFORE: or AFTER: section later in the specification,
+it will replace the current clause in use.
+
+Only use before and after claues when necessary --specifications
+are typically more readible without them. In fact, some developers
+make a policy of avoiding them altogether. YMMV.
+
+Macros, and any other non-testable code, can be designated using the
+*MACRO:* indicator. Because the context in which a specification
+is run is a self-extended module, macros are just method definitions.
+
+MACRO: Macro's contain code to execute but not tested.
+
+  def assert_integer(x)
+    x.assert.is_a? Integer
+  end
+
+Okay. Now lets try out some code.
+
+  (2 + 2).assert == 4
+
+  assert_integer(4)
+
+Now something that will fail:
+
+  (2 + 2).assert == 5
+
+And some that will raise an error:
+
+  nobody_knows_method
+
+QED.
+

data/spec/mock.rd

@@ -0,0 +1,53 @@
+= Quarry's Mocking Facility
+
+Require mock.rb library.
+
+  require 'quarry/stub/mock'
+
+
+== Delegation Approach
+
+   obj = "hello"
+
+   @mck = Quarry::Mock.new
+
+   @mck.upcase == "HeLLo"
+
+   alt = obj.mock(@mck)
+
+   lambda{ alt.upcase }.assert_raises(Assertion)
+
+   obj.upcase.assert == "HELLO"
+
+
+== Singleton Approach
+
+   obj = "hi"
+
+   obj.extend(@mck)
+
+   @mck.upcase == "hI"
+
+   lambda{ obj.upcase }.assert_raises(Assertion)
+
+   obj.remove(@mck)
+
+   obj.upcase.assert == "HI"
+
+
+== Quick Extend Stubs
+
+   obj = "hey"
+
+   # implict obj.extend(obj.mock) here
+   obj.mock.upcase == "HeY"
+
+   lambda{ obj.upcase }.assert_raises(Assertion)
+
+   obj.remove  # imples obj.remove(obj.stub)
+
+   obj.upcase.assert == "HEY"
+
+QED.
+
+

data/spec/stub.rd

@@ -0,0 +1,61 @@
+= Quarry's Stubbing Facility
+
+Require stub.rb library.
+
+  require 'quarry/stub/stub'
+
+
+== Delegation Approach
+
+We will stub-out a simple string.
+
+   obj = "hello"
+
+We can create a reusable stub module.
+
+   @stb = Quarry::Stub.new
+   @stb.upcase == "HeLLo"
+
+Appy the stub module to the object we want to stub.
+
+   alt = obj.stub(@stb)
+
+And get teh newly stubbed output.
+
+   alt.upcase.assert == "HeLLo"
+
+Teh original is still intact.
+
+   obj.upcase.assert == "HELLO"
+
+
+== Singleton Approach
+
+   obj = "hi"
+
+   obj.extend(@stb)
+
+   @stb.upcase == "hI"
+
+   obj.upcase.assert == "hI"
+
+   obj.remove(@stb)
+
+   obj.upcase.assert == "HI"
+
+
+== Quick Extend Stubs
+
+   obj = "hey"
+
+   # implict obj.extend(obj.stub) here
+   obj.stub.upcase == "HeY"
+
+   obj.upcase.assert == "HeY"
+
+   obj.remove  # imples obj.remove(obj.stub)
+
+   obj.upcase.assert == "HEY"
+
+QED.
+

data/work/consider/fixture.rb

@@ -0,0 +1,153 @@
+require 'facets/core/kernel/constant'
+#require 'facets/more/ormsupport'
+require 'facets/more/settings'
+
+require 'nitro/template'
+
+module Quarry
+
+# A collection of helper methods.
+
+class Fixtures
+
+  # The directory where the fixtures are located.
+
+  setting :root_dir, :default => 'test/fixture', :doc => 'The directory where the fixtures are located'
+
+  @fixtures = {}
+
+  class << self
+
+    def load(*classes)
+      for klass in classes
+        f = Fixture.new(klass).load
+        @fixtures[f.name] = f
+      end
+    end
+
+    def [](klass)
+      @fixtures[klass]
+    end
+
+    def []=(klass, fixture)
+      @fixtures[klass] = fixture
+    end
+
+    def method_missing(sym)
+      if f = @fixtures[sym.to_s]
+        return f
+      end
+      super
+    end
+  end
+end
+
+# Fixtures is a fancy word for ‘sample data’. Fixtures allow you
+# to populate your database with predefined data. Fixtures are
+# typically used during testing or when providing initial data
+# (bootstrap data) for a live application.
+#
+# A Fixture is a collection (Hash) of objects.
+
+class Fixture < Hash
+
+  # The name of this Fixture.
+
+  attr_accessor :name
+
+  # The class that the Fixtures refer to.
+
+  attr_accessor :klass
+
+  # Used to keep the order.
+
+  attr_accessor :objects
+
+  def initialize(klass, options = { } )
+    @klass = klass
+    @name = class_to_name(klass)
+    @objects = []
+    load(options[:root_dir] || options[:root] || Fixtures.root_dir)
+  end
+
+  def load(root_dir = Fixtures.root_dir)
+    raise("The fixture root directory '#{root_dir}' doesn't exits") unless File.exist?(root_dir)
+
+    if path = "#{root_dir}/#{@name}.yml" and File.exist?(path)
+      parse_yaml(path)
+    end
+
+    if path = "#{root_dir}/#{@name}.yaml" and File.exist?(path)
+      parse_yaml(path)
+    end
+
+    if path = "#{root_dir}/#{@name}.csv" and File.exist?(path)
+      parse_csv(path)
+    end
+
+    return self
+  end
+
+  # Parse a fixture file in YAML format.
+
+  def parse_yaml(path)
+    require 'yaml'
+
+    str = Nitro::Template.new.render(File.read(path))
+
+    if yaml = YAML::load(str)
+      for name, data in yaml
+        self[name] = instantiate(data)
+      end
+    end
+
+    # sort the objects.
+
+    str.scan(/^(\w*?):$/).each do |key|
+      @objects << self[key.to_s]
+    end
+  end
+
+  # Parse a fixture file in CSV format. Many RDBM systems and
+  # Spreadsheets can export to CVS, so this is a rather useful
+  # format.
+
+  def parse_csv(path)
+    require 'csv'
+
+    str = Nitro::Template.new.render(File.read(path))
+
+    reader = CSV::Reader.create(str)
+    header = reader.shift
+
+    reader.each_with_index do |row, i|
+      data = {}
+      row.each_with_index do |cell, j|
+        data[header[j].to_s.strip] = cell.to_s.strip
+      end
+      self["#{@name}_#{i+1}"] = obj = instantiate(data)
+      @objects << obj
+    end
+  end
+
+private
+
+  # Instantiate an actual object from the Fixture data.
+
+  def instantiate(data)
+    obj = @klass.allocate
+
+    for key, value in data
+      obj.instance_variable_set("@#{key}", value)
+    end
+
+    return obj
+  end
+
+  def class_to_name(klass)
+    klass.to_s.demodulize.underscore
+  end
+
+end
+
+end

data/{lib/quarry → work/deprecated}/assert/must.rb

@@ -4,5 +4,6 @@ class Object
   alias_method :must, :assert
   alias_method :must!, :assert!
   alias_method :must_not, :assert!
+  alias_method :musnt, :assert!
 end
 

data/work/deprecated/build.rb

@@ -0,0 +1,82 @@
+# = TITLE:
+#
+#   Utils
+#
+# = COPYING:
+#
+#   Copyright (c) 2007 Tiger Ops
+#
+#   This file is part of the Reap program.
+#
+#   Reap is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   Reap 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.  See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with Reap.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'yaml'      # make it generally available
+require 'rbconfig'  # replace with facets/system?
+
+require 'quarry/support/options'
+require 'quarry/utils/fileutils'
+require 'quarry/utils/shellutils'
+require 'quarry/utils/netutils'
+#require 'reap/tasksystem'
+
+module Quarry
+
+  class Build
+    include ShellUtils
+    include FileUtils
+    include NetUtils
+
+    def initialize(*configs)
+      configs.each do |config|
+        next unless config
+        config.each do |key,value|
+          send("#{key}=", value) if respond_to?("#{key}=")
+        end
+      end
+    end
+
+    def initialize(options=nil)
+      options ||= {}
+      options.each do |k,v|
+        k = k.to_s.downcase
+        send("#{k}=", v) if respond_to?("#{k}=")
+      end
+    end
+
+    # General options.
+
+    attr_writer :dryrun, :trace, :force, :verbose
+
+    def dryrun?  ; @dryrun  ; end
+    def trace?   ; @trace   ; end
+    def force?   ; @force   ; end
+    def verbose? ; @verbose ; end
+    def debug?   ; @debug   ; end
+
+    alias_method :noharm=, :dryrun=
+    alias_method :noharm?, :dryrun?
+
+    def options
+      {
+        :dryrun  => dryrun?,
+        :trace   => trace?,
+        :force   => force?,
+        :verbose => verbose?,
+        :debug   => debug?
+      }
+    end
+
+  end
+
+end

data/work/deprecated/mock/file.rb

@@ -0,0 +1,11 @@
+# Mock File Class
+
+module Quarry
+module Mock
+
+  class File
+  end
+
+end
+end
+

data/work/deprecated/mock/mock.0.rb

@@ -0,0 +1,77 @@
+require 'quarry/assert'
+
+module Quarry
+
+  # Quarry's Mocking facility.
+  #
+  #   obj = "hello"
+  #
+  #   obj.mock.upcase == "HeLLo"
+  #
+  #   obj.upcase  #=> "HeLLo"
+  #
+  #   obj.mockless!
+  #
+  #   obj.upcase  #=> "HELLO"
+  #
+  class Mock < Module
+    attr :object
+
+    def initialize(object)
+      super()
+      @object = object
+      @table  = {}
+      object.extend(self)
+    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|
+        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
+
+  end
+
+  #
+  class ::Object
+
+    def mock
+      @_mock ||= Mock.new(self)
+    end
+
+    def mockless!
+      mock.__table__.each do |interface, result|
+        meth = interface[0]
+        mock.module_eval do
+          remove_method(meth)
+        end
+      end
+    end
+
+  end
+
+end
+

data/work/deprecated/overlay.rb

@@ -0,0 +1,64 @@
+module Quarry
+
+  # = Overlay
+  #
+  # The idea of the Overlay is to proved a convenient way to 
+  # create test stubs. You can take an original class and
+  # turn features on and off at your leasure, substituting
+  # in your choice of code piece meal.
+  #
+  #   class X
+  #     def a; 1; end
+  #     def b; a + 1; end
+  #   end
+  #
+  #   XO = Quarry::Overlay.new do
+  #     def_over(:a) do
+  #       2  
+  #     end
+  #   end
+  #
+  #   x = X.new
+  #   p x.a  #=> 1
+  #
+  #   XO.append_features(X)
+  #   p x.a  #=> 2
+  #
+  #   XO.remove_features(X)
+  #   p x.a  #=> 1
+  #
+  class Overlay
+
+    def initialize(&block)
+      @over  = {}
+      @cache = Hash.new{ |h,k| h[k]={} }
+      instance_eval(&block) if block_given?
+    end
+
+    def define_method(methname, &block)
+      @over[methname] = block
+    end
+
+    def append_features(base)
+      @over.each do |name, block|
+        next if base.instance_methods(true).include?("#{name}:#{base.__id__}:super")
+        if m = base.instance_methods(true).include?(name.to_s)
+          base.__send__(:alias_method, "#{name}:#{base.__id__}:super", name)
+          base.__send__(:define_method, name, &block)
+        end
+      end
+    end
+
+    def remove_features(base)
+      @over.each do |name, block|
+        next unless base.instance_methods(true).include?("#{name}:#{base.__id__}:super")
+        if m = base.instance_method("#{name}:#{base.__id__}:super")
+          base.__send__(:alias_method, name, "#{name}:#{base.__id__}:super")
+        end
+      end
+    end
+
+  end
+
+end
+