quarry 0.3.0

data/doc/ri/Quarry/Mock/Object/keys-c.yaml

@@ -0,0 +1,12 @@
+--- !ruby/object:RI::MethodDescription 
+aliases: []
+
+block_params: 
+comment: 
+- !ruby/struct:SM::Flow::P 
+  body: Responds according to a mapping of input parameters.
+full_name: Quarry::Mock::Object::keys
+is_singleton: true
+name: keys
+params: ( sym, hsh )
+visibility: public

data/doc/ri/Quarry/Mock/Object/mock-c.yaml

@@ -0,0 +1,12 @@
+--- !ruby/object:RI::MethodDescription 
+aliases: []
+
+block_params: 
+comment: 
+- !ruby/struct:SM::Flow::P 
+  body: Mock a static repsonse.
+full_name: Quarry::Mock::Object::mock
+is_singleton: true
+name: mock
+params: ( sym, val )
+visibility: public

data/doc/ri/Quarry/Mock/Object/mocks-c.yaml

@@ -0,0 +1,10 @@
+--- !ruby/object:RI::MethodDescription 
+aliases: []
+
+block_params: 
+comment: 
+full_name: Quarry::Mock::Object::mocks
+is_singleton: true
+name: mocks
+params: ()
+visibility: public

data/doc/ri/Quarry/Mock/Object/spin-c.yaml

@@ -0,0 +1,12 @@
+--- !ruby/object:RI::MethodDescription 
+aliases: []
+
+block_params: 
+comment: 
+- !ruby/struct:SM::Flow::P 
+  body: Reponds with a rotation of reponses.
+full_name: Quarry::Mock::Object::spin
+is_singleton: true
+name: spin
+params: ( sym, arr )
+visibility: public

data/doc/ri/Quarry/Mock/cdesc-Mock.yaml

@@ -0,0 +1,15 @@
+--- !ruby/object:RI::ClassDescription 
+attributes: []
+
+class_methods: []
+
+comment: 
+constants: []
+
+full_name: Quarry::Mock
+includes: []
+
+instance_methods: []
+
+name: Mock
+superclass: 

data/doc/ri/Quarry/Mockery-i.yaml

@@ -0,0 +1,12 @@
+--- !ruby/object:RI::MethodDescription 
+aliases: []
+
+block_params: 
+comment: 
+- !ruby/struct:SM::Flow::P 
+  body: 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.
+full_name: Quarry#Mockery
+is_singleton: false
+name: Mockery
+params: ( realclass )
+visibility: public

data/doc/ri/Quarry/cdesc-Quarry.yaml

@@ -0,0 +1,17 @@
+--- !ruby/object:RI::ClassDescription 
+attributes: []
+
+class_methods: []
+
+comment: []
+
+constants: []
+
+full_name: Quarry
+includes: []
+
+instance_methods: 
+- !ruby/object:RI::MethodSummary 
+  name: Mockery
+name: Quarry
+superclass: 

data/doc/ri/created.rid

@@ -0,0 +1 @@
+Thu, 21 Aug 2008 13:19:31 -0400

data/lib/quarry/assert/must.rb

@@ -0,0 +1,8 @@
+require 'quarry/assertion'
+
+class Object
+  alias_method :must, :assert
+  alias_method :must!, :assert!
+  alias_method :must_not, :assert!
+end
+

data/lib/quarry/assert/should.rb

@@ -0,0 +1,9 @@
+require 'quarry/assertion'
+
+class Object
+  alias_method :should, :assert
+  alias_method :should!, :assert!
+  alias_method :should_not, :assert!
+  alias_method :shouldnt, :assert!
+end
+

data/lib/quarry/assertion.rb

@@ -0,0 +1,95 @@
+# Copyright (c) 2008 Tiger Ops
+
+class Object
+  # Assert a operational relationship.
+  #
+  # 4.assert == 3  #=> Assertion Error
+  #
+  def assert
+    return Assertion::True.new(self)
+  end
+
+  # Assert not an operational relationship.
+  #
+  # 4.assert! == 4  #=> Assertion Error
+  #
+  def assert!
+    return Assertion::False.new(self)
+  end
+end
+
+# Assertion object is a special subclass of Exception,
+# used to raise assertion errors.
+#
+class Assertion < Exception
+
+  #
+  class True
+    #
+    def self.message(msg,&block)
+      @messages ||= {}
+      if block
+        @messages[msg] = block
+      else
+        @messages[msg]
+      end
+    end
+
+    hide = instance_methods.reject { |m| m.to_s =~ /^__/ }
+    hide.each { |m| protected m  }
+
+    private
+
+    #
+    def initialize(delegate)
+      @delegate = delegate
+    end
+
+    #
+    def assert(assertion, msg="failed assertion (no message given)")
+      raise Assertion, msg unless assertion
+    end
+
+    #
+    message(:==){ |*a| "Expected #{a[0].inspect} to be equal to #{a[1].inspect}" }
+
+    #
+    def method_missing( sym, *a, &b )
+      case sym
+      when :raise?, :raises?
+        begin
+          @delegate.call #yield
+          assert false, "Expected #{a[0]} to be raised"
+        rescue Exception => e
+          assert a[0] === e, "Expected #{a[0]} to be raised, but got #{e.class}"
+          return e
+        end
+      else
+        msg = message(@delegate, sym, *a, &b)
+        assert(@delegate.send(sym, *a, &b ), msg)
+        #assert( @delegate.send(sym, *a, &b ), self.class.message(sym)[@delegate, *a] )
+      end
+    end
+
+    #
+    def message( obj, sym, *a, &b )
+      "#{sym}\n< #{obj.inspect}\n---\n> #{a.collect{|x| x.inspect}.join(',')}"
+    end
+
+  end
+
+  #
+  class False < True
+    message(:==){ |*a| "Expected #{a[0].inspect} not to be equal to #{a[1].inspect}" }
+
+    def assert(assertion, msg="failed assertion (no message given)")
+      raise Assertion, msg if assertion
+    end
+
+    def message( obj, sym, *a, &b )
+      "#{obj.inspect} should not #{sym} #{a.collect{|x| x.inspect}.join(',')}"
+    end
+  end
+
+end
+

data/lib/quarry/breakout.rb

@@ -0,0 +1,45 @@
+require 'facets/core/string/margin' # TODO get rid of.
+
+def breakout( error )
+
+  file, line = *error.exception.backtrace[0].split(':')
+  line = line.to_i
+
+  puts error
+
+  e = "# DEBUG " + error.to_s
+  e.gsub!("`","'")
+
+  e = Regexp.escape(e)
+
+  case ed = ENV['EDITOR']
+  when 'vi', 'vim', 'gvim'
+    cmd = %[
+      |#{ed} -e -s #{file} <<-EOS
+      |:#{line}
+      |a
+      |#{e}
+      |.
+      |:.,+#{e.size}
+      |EOS
+      ].margin
+  else
+    puts "EDITOR environment variable not set"
+  end
+
+  system cmd
+
+end
+
+# command-line mode
+
+if __FILE__ == $0
+
+  begin
+    load $file = ARGV[0]
+  rescue Exception => e
+    error = breakout(e)
+  end
+
+end
+

data/lib/quarry/design/spec.rb

@@ -0,0 +1,197 @@
+#require 'facet/kernel/within?'
+require 'quarry/assertion'
+
+module Quarry
+module Design
+
+  class << self
+    def specifications
+      @specifications ||= []
+    end
+
+    def specification(description, &specification)
+      specifications << Specification.new(nil, description, &specification)
+    end
+    alias_method :spec, :specification
+
+    # TODO: make output compatible with unit_diff ?
+
+    def check
+      specifications.each do |specification|
+        specification.check
+      end
+    end
+
+    def outline
+      specifications.each do |specification|
+        specification.outline
+      end
+    end
+  end
+
+  # Design specification. Sepcification can contains sub-specifications.
+  #
+  class Specification
+    attr :relation
+    attr :description
+    attr :specification
+    attr :context
+    attr :before
+    attr :after
+
+    # New Specification
+
+    def initialize(relation, description, context=nil, &specification)
+      @relation       = relation
+      @description    = description
+      @specification  = specification
+      @context        = context
+      @before         = context.before if context
+      @after          = context.after  if context
+    end
+
+    # Check Specification
+
+    def check(level=0)
+      padding = " " * 2 * level
+
+      clause  = "#{relation} #{description}".strip
+
+      new_context = Context.new
+      new_context.instance_eval(&before) if before
+      begin
+        new_context.instance_eval(&specification)
+        puts ("=" * (level+1)) + " " + clause.gsub(/\b\w/){$&.upcase}
+      rescue Assertion => e
+        #puts padding + " (FAIL) [#{e.backtrace[2]}] " + clause
+        puts "* " + clause.gsub('_',' ') + " [#{e.backtrace[2]}]"
+        puts e if $VERBOSE
+      rescue Exception => e
+        raise e if $DEBUG
+        print padding
+        #puts padding + " (ERROR) [#{e.backtrace[2]}] " + clause
+        puts padding + " (ERROR) #{e}"
+        puts e.backtrace if $VERBOSE
+      ensure
+        new_context.instance_eval(&after) if after
+      end
+
+      new_context.specifications.each do |s|
+        s.check(level+1)
+      end
+    end
+
+    # Outline Specification
+
+    def outline(level=0)
+      padding = (" " * 2 * level) + "- "
+      context = Context.new
+      begin
+        context.instance_eval(&specification)
+      rescue Assertion => e
+      #rescue Exception => e
+      end
+
+      str = ''
+      str << "#{relation} " if relation
+      str << "#{description}"
+      #str = str.strip #.gsub(/\b\w/){$&.upcase}
+
+      puts padding + str.strip
+
+      context.specifications.each do |s|
+        s.outline(level+1)
+      end
+    end
+
+    # A context provides a "clean room" to build a specification.
+
+    class Context
+
+      def specifications
+        @specifications ||= []
+      end
+
+      def before(&before)
+        before ? @before = before : before
+      end
+
+      def after(&after)
+        after ? @after = after : after
+      end
+
+      def method_missing(relation, *description, &specification)
+        if description.size > 1
+          super
+        else
+          specifications << Specification.new(relation, description.first, self, &specification)
+        end
+      end
+
+    end
+
+  end
+
+end
+end
+
+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
+
+    demonstrate "basic assertions" do
+
+      that "4 == 3 fails" do
+        4.assert == 3
+      end
+
+      that "4 != 4 fails" do
+        4.assert! == 4
+      end
+
+      that "raising an ArgumentError does not raise a SyntaxError" do
+        lambda{raise ArgumentError}.assert.raise? SyntaxError
+      end
+
+    end
+
+  end
+
+  $no_autocheck = true
+
+  Quarry::Design.outline
+
+end
+