quarry 0.4.0 → 0.5.0

data/work/deprecated/build.rb

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

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

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

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

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

data/work/deprecated/spec.rb

@@ -1,195 +0,0 @@
-require 'quarry/assertion'
-
-module Quarry
-
-  class << self
-    def specification(description, &specification)
-      Design.specification(description, &specification)
-    end
-
-    alias_method :spec, :specification
-  end
-
-  module Design
-
-    class << self
-      def specifications
-        @specifications ||= []
-      end
-
-      def specification(description, &specification)
-        specifications << Spec.new(description, nil, &specification)
-      end
-      alias_method :spec, :specification
-
-      # TODO: make output compatible with unit_diff ?
-
-      def check
-        specifications.each do |specification|
-          Runner.new(specification).check
-        end
-      end
-
-      def outline
-        specifications.each do |specification|
-          Runner.new(specification).outline
-        end
-      end
-    end
-
-    # = Spec
-    #
-    class Spec
-      #undef_method *instance_methods.select{|m| m.to_s !~ /^(__|instance_|object_)/}
-
-      # Specification description.
-      attr :description
-
-      # Parent specification (if any).
-      attr :parent
-
-      #
-      attr :given
-
-      #
-      attr :before
-
-      #
-      attr :after
-
-      # Subspecifications
-      attr :specs
-
-      # Steps in specification proof.
-      attr :steps
-
-      #
-      def initialize(description, parent, &block)
-        #@relation       = relation
-        @description = description
-        @parent      = parent
-
-        @given  = nil
-        @before = nil
-        @after  = nil
-
-        @specs = []
-        @steps = []
-
-        instance_eval(&block)
-      end
-
-      #
-      def given(&block)
-        block ? @given = block : @given
-      end
-
-      #
-      def before(&block)
-        block ? @before = block : @before
-      end
-
-      #
-      def after(&block)
-        block ? @after = block : @after
-      end
-
-      def context(description, &block)
-        specs << Spec.new(description, self, &block)
-      end
-
-      #
-      def prove(description, &block)
-        steps << Step.new(description, self, &block)
-      end
-
-      alias_method :it,  :prove
-      alias_method :its, :prove
-
-      #
-      #def method_missing(relation, *description, &specification)
-      #  if description.size > 1
-      #    super
-      #  else
-      #    specifications << Specification.new(relation, description.first, self, &specification)
-      #  end
-      #end
-    end #class Context
-
-    #
-    class Step
-      attr :description
-      attr :parent
-      attr :code
-
-      def initialize(description, parent, &code)
-        @description = description
-        @parent      = parent
-        @code        = code
-      end
-    end
-
-  end #module Desgin
-
-end #module Quarry
-
-#at_exit { Quarry::Design.check unless $no_autocheck }
-
-
-=begin demo
-
-  Quarry::Design.specification "Example Specification" do
-
-    context "demonstrate basic assertions" do
-
-      specify "fail if should is false" do
-        4.assert == 3
-      end
-
-      specify "fail if should_not is true" do
-        4.assert! == 4
-      end
-
-      specify "fail on should raise" do
-        lambda{raise ArgumentError}.assert.raise? SyntaxError
-      end
-
-    end
-
-  end
-
-  $no_autocheck = true
-
-  Quarry::Design.outline
-
-=end
-
-
-if __FILE__ == $0
-
-  Quarry::Design.spec "Example Specification" do
-
-    it "demontrates basic assertions" do
-
-      it "eg. 4 == 3 fails" do
-        4.assert == 3
-      end
-
-      it "eg. 4 != 4 fails" do
-        4.assert! == 4
-      end
-
-      it "eg. raises an ArgumentError does not raise a SyntaxError" do
-        lambda{raise ArgumentError}.assert.raise? SyntaxError
-      end
-
-    end
-
-  end
-
-  $no_autocheck = true
-
-  Quarry::Design.outline
-
-end
-

data/work/deprecated/stub/stub.0.rb

@@ -1,180 +0,0 @@
-module Quarry
-  require 'ostruct'
-
-  # = Stub
-  #
-  # A straightfoward stubbing facility. Typically used in test cases.
-  # The Stub class offers a few constructors for quickly building
-  # of stubs.
-  #
-  #   stat - Returns a static reponse.
-  #   echo - Returns the arguments passed-in.
-  #   spin - Returns a rotation of responses.
-  #   keys - Returns an index of responses.
-  #
-  # Stub classes can be built from sratch or partially framed
-  # against other classes.
-  #
-  # === Usage
-  #
-  #   class ContextStub < Stub
-  #     stat :response_headers, {}
-  #     spin :host_url, ['http://www.nitrohq.com','http://www.rubyforge.com']
-  #   end
-  #
-  #   ctx = ContextStub.new
-  #   ctx.response_headers['location'] = url
-  #   ctx.host_url   #=> "http://www.nitrohq.com"
-  #   ctx.host_url   #=> "http://www.rubyforge.com"
-  #
-  # === Note
-  #
-  # Quarry doesn't have Mocks, and may never. You can combine
-  # Stubs and Assertions fairly effectively to do essentailly
-  # what Mocks do, without having to learn yet another DSL
-  # for describing object behaviors.
-  # 
-  class Stub < OpenStruct
-
-    # 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 stubbed, ever!)
-    #
-    UnstubbedMethods = %r{^(
-      |inspect
-      |kind_of\?|is_a\?|instance_of\?|class
-      |method|send|respond_to\?
-      |hash
-      |__
-    )}x
-
-    class << self
-      attr :realclass
-
-      def stubbed_methods
-        self.methods(false)
-      end
-
-      # Returns a static response.
-      def stat(sym, val)
-        define_method(sym){|*args| val}
-      end
-
-# This one is dumb.
-      # Responds with input.
-      def echo(sym)
-        define_method(sym){|*args| args}
-      end
-
-# This is probably dumb.
-      # 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
-
-    alias :__class :class
-
-    # Delegate #class method.
-    def class # :nodoc:
-      return __class.realclass
-    end
-
-    # Delegate #instance_of? method.
-    def instance_of?(klass) # :nodoc:
-      self.class == klass
-    end
-
-    # Delegate #kind_of? method.
-    def kind_of?(klass) # :nodoc:
-      self.class <= klass
-    end
-
-    # Delegate #is_a? method.
-    alias_method :is_a?, :kind_of?
-
-  end # class Stub
-
-  ### Factory method for automatically creating semi-functional
-  ### stub classes given a real class. It looks like a constant
-  ### for purposes of syntactic sugar.
-  ###
-  ###   class MyStub < Stub(X)
-  ###      ...
-  ###   end
-  ###
-  def self.Stub(realclass)
-
-    stubclass = Class.new(Stub)
-
-    stubclass.instance_eval{ @realclass = realclass }
-
-    # Provide an accessor to class instance var that holds the class
-    # object we're faking
-    class << stubclass
-      # The actual class being mocked
-      attr_reader :realclass
-
-      # Propagate the mocked class ivar to derivatives so it can be
-      # called like:
-      #   class MockFoo < Mock(RealClass)
-      def inherited(subclass)
-        rc = self.realclass
-        subclass.instance_eval{ @realclass = rc }
-      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 =~ Quarry::Stub::UnstubbedMethods
-
-      # 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{|n| args << "arg#{n+1}"}
-      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 stubclass class
-    stubclass.class_eval imethods.join( "\n" )
-
-    return stubclass
-  end
-
-end
-

data/work/deprecated/stub/stub.1.rb

@@ -1,114 +0,0 @@
-require 'quarry/stub/overlay'
-
-module Quarry
-
-=begin
-  class Stub
-    def initialize(object)
-      @instance_delegate = object
-    end
-
-    def method_missing(s, *a, &b)
-      @instance_delegate.__send__(s, *a, &b)
-    end
-  end
-=end
-
-  # Quarry's Stubbing facility.
-  #
-  #   obj = "hello"
-  #
-  #   obj.stub.upcase == "HeLLo"
-  #
-  #   obj.upcase  #=> "HeLLo"
-  #
-  #   obj.stubless!
-  #
-  #   obj.upcase  #=> "HELLO"
-  #
-  class Stub < Module
-    attr :object
-
-    def initialize(object)
-      super()
-      @object  = object
-      @table   = {}
-      @overlay = Overlay.new
-    end
-
-    def __table__ ; @table ; end
-
-    def method_missing(meth, *args, &block)
-      table     = @table
-      interface = [meth, args, block_given?]
-
-      table[interface] = nil
-
-      @overlay.define_method(meth) do |*args|
-        table[interface]
-      end
-
-      @overlay.append_features((class << @object; self; 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 stub
-      @_stub ||= Stub.new(self)
-    end
-
-    def remove_stubs
-      stub.instance_eval do
-        @overlay.remove_features((class << @object; self; end))
-      end
-      #stub.__table__.each do |interface, result|
-      #  meth = interface[0]
-      #  stub.module_eval do
-      #    remove_method(meth)
-      #  end
-      #end
-    end
-
-  end
-
-end
-
-if $0 == __FILE__
-
-   # Only one possible stub definition per object?
-
-   obj = "hello"
-
-   obj.stub.upcase == "HeLLo"
-
-   p obj.upcase  #=> "HeLLo"
-
-   # We could always copy it.
-
-   obj2 = obj.copy
-
-   # Eek that means we need to copy stub too (FIXME: initialize_copy)
-
-   obj.remove_stubs
-
-   p obj.upcase  #=> "HELLO"
-
-end
-