quarry 0.3.0 → 0.4.0

data/lib/quarry/spec/reporter.rb

@@ -0,0 +1,74 @@
+require 'clio/facets/string'
+require 'clio/ansicode'
+
+module Quarry
+
+  module Spec
+
+    # = Reporter
+    #
+    # Serves as the base class for all other specification 
+    # output formats.
+    # 
+    class Reporter
+      ANSICode = Clio::ANSICode
+
+      attr :steps
+      attr :pass
+      attr :fail
+      attr :error
+
+      def initialize
+        @specs = 0
+        @steps = 0
+        @pass  = []
+        @fail  = []
+        @error = []
+      end
+
+      def report_intro
+      end
+
+      def report_start(spec)
+        @specs += 1
+      end
+
+      def report_header(step)
+      end
+
+      def report_comment(step)
+      end
+
+      def report_mode(step)
+        report_literal(step)
+      end
+
+      def report_step(step)
+        @steps += 1
+      end
+
+      def report_pass(step)
+        @pass << step
+      end
+
+      def report_fail(step, assertion)
+        @fail << [step, assertion]
+      end
+
+      def report_error(step, exception)
+        raise exception if $DEBUG
+        @error << [step, exception]
+      end
+
+      def report_end(spec)
+      end
+
+      def report_summary
+      end
+
+    end
+
+  end
+
+end
+

data/lib/quarry/spec/runner.rb

@@ -0,0 +1,127 @@
+require 'quarry/assert'
+require 'quarry/spec/context'
+
+module Quarry
+
+  module Spec
+
+    # = Specificaton Runner
+    #
+    # The Runner class loops through a set of specifications
+    # and executes each one in turn.
+    #
+    # The current working directory is changed to that of the
+    # specification script's. So any relative file references
+    # within a spec must take that into account.
+    #
+    class Runner
+
+      #  Quarry::Spec::Runner.configure do
+      #    def setup(spec)
+      #      ...
+      #    end
+      #    def teardown(spec)
+      #      ...
+      #    end
+      #  end
+      #def self.configure(plugin=nil, &block)
+      #  if block_given?
+      #    m = Module.new(&block)
+      #    m.extend m
+      #    @config << m
+      #  end
+      #  if plugin
+      #    @config << plugin
+      #  end
+      #end
+
+      attr :specs
+      attr :output
+
+      attr :context
+      #attr :count
+
+      # New Specification
+      def initialize(specs, output=nil)
+        @specs  = [specs].flatten
+        @output = output || Spec::Reporter::DotProgress.new #(self)
+      end
+
+      # Each spec gets it's own context.
+      def check
+        output.report_intro
+        # loop through each specification and run it
+        specs.each do |spec|
+          # create a run context for the spec
+          @context = Context.new
+          # run the specification
+          check_spec(spec)
+        end
+        output.report_summary
+      end
+
+      # Run a specification.
+      #
+      def check_spec(spec)
+        #report(spec.description)
+
+        # pretty sure this is the thing to do
+        Dir.chdir(File.dirname(spec.file)) do
+
+          output.report_start(spec)
+
+          # TODO <-- plugin in here start (how to set?)
+          #context.instance_eval(&spec.given) if spec.given
+
+          spec.steps.each do |step|
+            case step
+            when Header
+              output.report_header(step)
+            when Macro
+              case step.type
+              when :before
+                @before = step.code
+              when :after
+                @after = step.code
+              else
+                context.instance_eval(step.code, spec.file, step.lineno)
+              end
+              output.report_macro(step)
+            when Comment
+              output.report_comment(step)
+            else
+              run_step(spec, step) if step.code
+            end
+          end
+
+          # TODO <-- plugin in here end
+          #context.instance_eval(&spec.complete) if spec.complete
+
+          output.report_end(spec)
+        end
+      end
+
+      # Run a specification step.
+      #
+      def run_step(spec, step)
+        output.report_step(step)
+        # TODO: Would spec.before + spec.code be better?
+        context.instance_eval(@before, spec.file) if @before
+        begin
+          context.instance_eval(step.code, spec.file, step.lineno)
+          output.report_pass(step)
+        rescue Assertion => error
+          output.report_fail(step, error)
+        rescue Exception => error
+          output.report_error(step, error)
+        ensure
+          context.instance_eval(@after, spec.file) if @after
+        end
+      end
+
+    end#class Runner
+
+  end#module Spec
+
+end#module Quarry
+

data/lib/quarry/spec/step.rb

@@ -0,0 +1,78 @@
+module Quarry
+
+  module Spec
+
+    # = Step
+    #
+    class Step
+      attr :parent
+      attr :code
+      attr :lineno
+
+      def initialize(parent, code, lineno)
+        @parent = parent
+        @code   = code.rstrip
+        @lineno = lineno
+      end
+
+      alias_method :spec, :parent
+
+      #def description
+      #  alias_method :description, :text
+      #end
+    end
+
+    # = Macro
+    #
+    class Macro < Step
+      attr :type
+      def initialize(parent, code, lineno, type)
+        super(parent, code, lineno)
+        @type = type
+      end
+    end
+
+    # = Header
+    #
+    class Header
+      attr :parent
+      attr :text
+      attr :lineno
+
+      def initialize(parent, text, lineno)
+        @parent = parent
+        @text   = text.strip
+        @lineno = lineno
+      end
+
+      alias_method :spec, :parent
+      alias_method :description, :text
+    end
+
+    # = Comment
+    #
+    class Comment
+      attr :parent
+      attr :text
+      attr :lineno
+
+      def initialize(parent, text, lineno)
+        @parent = parent
+        @text   = text.strip
+        @lineno = lineno
+      end
+
+      alias_method :spec, :parent
+      alias_method :description, :text
+
+      #
+      def type
+        /^(\w{1,9})[:]/i =~ text
+        $1.downcase.to_sym if $1
+      end
+      alias_method :macro?, :type
+    end
+
+  end#module Spec
+
+end#module Quarry

data/lib/quarry/spec/template.rhtml

@@ -0,0 +1,116 @@
+<html>
+<head>
+  <title><%= title %></title>
+
+  <link rel="StyleSheet" href="<%= css %>" type="text/css">
+
+  <script language="javascript" src="../assets/scripts/jquery.js"></script>
+
+  <script type="text/javascript">
+    /*****************************************************************
+     * $.toc()
+     * by rebecca murphey
+     * rmurphey gmail com
+     *
+     * This function is called on its own and takes as an argument
+     * a list of selectors with which it will build a table of
+     * contents. 
+     *
+     * The first selector will make up the top level of the TOC;
+     * the second selector will make up the second level of the TOC;
+     * etc.
+     *
+     * This function returns a div containing nested unordered lists;
+     * each list item is linked to an anchor tag added before the item
+     * on the page.
+     *
+     * usage: $.toc('h1,h2,h3').prependTo('body');
+     ************************************************************************/
+    (function($) { 
+      $.toc = function(tocList) {
+        $(tocList).addClass('jquery-toc');
+        var tocListArray = tocList.split(',');
+        $.each(tocListArray, function(i,v) { tocListArray[i] = $.trim(v); });
+        var $elements = $('.jquery-toc');
+        $('body').append('<div></div>');
+        var $toc = $('body div:last');
+        var lastLevel = 1;
+        $toc.append('<ul class="jquery-toc-1"></ul>');
+        $elements.each(function() {
+          var $e = $(this);
+          var text = $e.text();
+          var anchor = text.replace(/ /g,'-');
+          $e.before('<a name="' + anchor + '"></a>');
+          var level;
+          $.each(tocListArray, function(i,v) { 
+            if (v.match(' ')) {
+              var vArray = v.split(' '); 
+              var e = vArray[vArray.length - 1];
+            } else { e = v; }
+            if ($e.is(e)) { level = i+1; } 
+          });
+          var className = 'jquery-toc-' + level;
+          var li = '<li><a href="#' + anchor + '">' + text + '</a></li>';
+          if (level == lastLevel) {
+            $('ul.' + className + ':last',$toc).append(li);
+          } else if (level > lastLevel) {
+            var parentLevel = level - 1;
+            var parentClassName = 'jquery-toc-' + parentLevel;
+            $('ul.' + parentClassName + ':last',$toc).
+              append('<ul class="' + className + '"></ul>');
+            $('ul.' + className + ':last',$toc).append(li);
+          } else if (level < lastLevel) {
+            $('ul.' + className + ':last',$toc).append(li);
+          }
+          lastLevel = level;
+        });
+        var $toc_ul = $('ul.jquery-toc-1',$toc);
+        $toc.remove();
+        return($toc_ul);
+     }
+    })(jQuery);
+  </script>
+
+  <script>
+    $(document).ready(function(){
+       $.toc('#content h1,h2,h3,h4').appendTo('.toc');
+     });
+
+    function toc_toggle() {
+      $('#toc_side').toggle();
+    };
+  </script>
+</head>
+
+<body>
+
+  <!-- Side Table of Contents -->
+  <div id="sidebar" style="position: fixed; top: 10; right: 10; background: white;">
+    <a href="javascript: toc_toggle();">
+      <img src="img/icon/book.jpg" height="30px;" style="border: none;" alt="TOC" align="right"/>
+    </a>
+
+    <div id="toc_side" class="toc">
+    </div>
+  </div>
+
+  <div id="container">
+    <div id="header">
+      <img src="img/icon/book.jpg" align="left" style="padding-right: 10px;" alt=""/>
+
+      <h1><%= title %></h1>
+      <h1>Table of Contents</h1>
+
+      <div class="toc">
+      </div>
+    </div>
+
+    <div id="content">
+      <%= spec %>
+    </div>
+  </div>
+
+</body>
+
+</html>
+

data/lib/quarry/spec.rb

@@ -0,0 +1,7 @@
+require 'quarry/spec/markup'
+require 'quarry/spec/reporter'
+require 'quarry/spec/reporter/dotprogress'
+require 'quarry/spec/reporter/verbatim'
+require 'quarry/spec/reporter/summary'
+require 'quarry/spec/runner'
+

data/lib/quarry/stub/mock.rb

@@ -0,0 +1,94 @@
+module Quarry
+
+  # = Mock
+  #
+  class Mock < Module
+    attr :object
+
+    def initialize
+      super()
+      @table = {}
+    end
+
+    #
+    def __table__ ; @table ; end
+
+    # TODO: Ruby has retry, but I need continue!
+    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
+
+    # = Mock::Delegator
+    #
+    class Delegator
+      instance_methods(true).each{ |m| protected m unless m.to_s =~ /^__/ }
+
+      def initialize(object, mock_module)
+        @instance_delegate = object
+        extend(mock_module)
+      end
+
+      def method_missing(s, *a, &b)
+        @instance_delegate.__send__(s, *a, &b)
+      end
+    end#class Delegator
+
+  end#class Mock
+
+  class ::Object
+    # Create mock object.
+    def mock(mock_module=nil)
+      if mock_module
+        Mock::Delegator.new(self, mock_module)
+      else
+        @_mock ||= Mock.new
+        extend(@_mock)
+        @_mock
+      end
+    end
+
+    # We can't remove the module per-say.  So we have to 
+    # just neuter it. This is a very weak solution, but
+    # it will suffice for the moment.
+    #-- 
+    # TODO: Use Carats for #unmix.
+    #++
+    def remove(mock_module=nil)
+      mock_module ||= @_mock
+      obj = self
+      mod = Module.new
+      mock_module.__table__.each do |interface, result|
+        meth = interface[0]
+        mod.module_eval do
+          define_method(meth, &obj.class.instance_method(meth).bind(obj))
+        end
+      end    
+      extend(mod)
+    end
+  end#class ::Object
+
+end#module Quarry
+

data/lib/quarry/stub/spec.txt

@@ -0,0 +1,113 @@
+
+Testing the Number 4
+====================
+
+  4.modulo(1) => 0
+  4.modulo(2) => 0
+  4.modulo(3) => 1
+  4.modulo(4) => 0
+  4.modulo(5) => 4
+
+
+Using Mocha
+-----------
+
+  4.stubs(:modulo).with(1).returns(0)
+  4.stubs(:modulo).with(2).returns(0)
+  4.stubs(:modulo).with(3).returns(1)
+  4.stubs(:modulo).with(4).returns(0)
+  4.stubs(:modulo).with(5).returns(4)
+
+Using RR
+--------
+
+  stub(4).modulo(1){ 0 }
+  stub(4).modulo(2){ 0 }
+  stub(4).modulo(3){ 1 }
+  stub(4).modulo(4){ 0 }
+  stub(4).modulo(5){ 4 }
+
+Using Quarry "Old-Style"
+------------------------
+
+  4.stub.modulo(1) == 0
+  4.stub.modulo(2) == 0
+  4.stub.modulo(3) == 1
+  4.stub.modulo(4) == 0
+  4.stub.modulo(5) == 4
+
+The #== operator is a shorthand for #returns. We could also use #returns_map:
+
+  4.stub.modulo.equate(1 => 0, 2 => 0, 3 => 1, 4 => 0, 5 => 4)
+
+Generalizing...
+
+  Integer.stub.modulo(1) == ?
+
+  Integer.stub.modulo == lamba{ |x| divmod(x)[0] }
+
+This testing with double entry bookkeeping. In other words, we are testing one implementation
+by comparing it to another implementation we consider equivalent, at lease within the
+limited range of inputs we are considering at the moment.
+
+Now what are we really doing in all of these cases? Singleton methods:
+
+  def 4.modulo(x)
+    case x
+    when 1 then 0
+    ...
+  end
+
+Oops. We can't do that to for "immutable" classes. But that's the idea anyway.
+
+So what are we doing with stubs? Well, after the fact we inpsect the results.
+
+  r = 4.modulo(1)
+
+  r.assert == 0
+
+
+What is a Mock?
+---------------
+
+Stub with attitude.
+
+A better term for Mock might be "inspector".
+
+  In*SPEC*tor
+
+though the modus operandi of an inspector is really as an:
+
+  Ex*SPEC*tor
+
+Stubs stand in for things. Mocks stand in for things too. But Mocks
+insist on being treated in certain ways.
+
+  # oops
+  4.modulo(1) #=> 1
+
+  4.mock.modulo(1) == 0
+
+  4.modulo(1) #=> raises Assertion error
+
+Why no expections for "receives"? This couples tests too tightly to implementations.
+We don't care how it behaves on the inside, only how it behaves on the outside.
+Consideration of "inside" behavior is the domain of benchmarkers.
+
+
+Yes, 'stub' and 'mock' are STUPID words.
+
+Why? Because they "Pokemon" (or "D&D" for you old-schoolers). They were coined
+in the forge of geekdom. Now let's grow up and call things for what they DO.
+
+"Stubbing"
+
+  4.define.modulo(1) == 0
+
+"Mocking"
+
+  4.expect.modulo(1) == 0
+
+
+
+

data/lib/quarry/stub/stub.rb

@@ -0,0 +1,93 @@
+module Quarry
+
+  #
+  class Stub < Module
+    attr :object
+
+    def initialize
+      super()
+      @table = {}
+    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|
+        table[interface]
+      end
+
+      Setter.new(table, interface)
+    end
+
+    #
+    class Setter
+      def initialize(table, interface)
+        @table     = table
+        @interface = interface
+      end
+
+      def ==(result)
+        @table[@interface] = result
+      end
+    end#class Setter
+
+    # = Stub::Delegator
+    #
+    class Delegator
+      instance_methods(true).each{ |m| protected m unless m.to_s =~ /^__/ }
+
+      def initialize(object, stub_module)
+        @instance_delegate = object
+        extend(stub_module)
+      end
+
+      def method_missing(s, *a, &b)
+        @instance_delegate.__send__(s, *a, &b)
+      end
+    end
+
+  end#class Stub
+
+  class ::Object
+
+    # Create a new stub.
+    def stub(stub_module=nil)
+      if stub_module
+        Stub::Delegator.new(self, stub_module)
+      else
+        @_stub ||= Stub.new
+        extend(@_stub)
+        @_stub
+      end
+    end
+
+    # We can't remove the module per-say.  So we have to 
+    # just neuter it. This is a very weak solution, but
+    # it will suffice for the moment.
+    #-- 
+    # TODO: Use Carats for #unmix.
+    #++
+    def remove(stub_module=nil)
+      stub_module ||= @_stub
+      obj = self
+      mod = Module.new
+      stub_module.__table__.each do |interface, result|
+        meth = interface[0]
+        mod.module_eval do
+          define_method(meth, &obj.class.instance_method(meth).bind(obj))
+        end
+      end    
+      extend(mod)
+    end
+
+  end#class ::Object
+
+end#module Quarry
+

data/meta/abstract

@@ -0,0 +1,5 @@
+Quarry is a small collection of libraries to facilitate
+Ruby project development, testing and debugging. In
+particular it includes a flexible but light-weight
+Behavior-Driven Development (BDD) library.
+

data/meta/authors

@@ -0,0 +1 @@
+Thomas Sawyer <transfire@gmail.com>