quarry 0.4.0 → 0.5.0

data/lib/quarry/reporter/verbatim.rb

@@ -0,0 +1,82 @@
+require 'quarry/reporter'
+
+module Quarry
+
+  class Reporter #:nodoc:
+
+    # = Verbatim Reporter
+    #
+    class Verbatim < Reporter
+
+      #def report_step(step)
+      #  super
+      #  if step.code
+      #    #str = "(%s) %s" % [count.join('.'), str.tab(6).strip]
+      #    #puts "* #{step.text.tab(2).strip}"
+      #    #puts
+      #    #puts step.text
+      #    #puts
+      #  else
+      #    #puts "#{step.text}\n"  # TODO: This never happens.
+      #  end
+      #end
+
+      def report_header(step)
+        puts ANSICode.bold(step.text)
+        puts
+      end
+
+      def report_comment(step)
+        puts step.text
+        puts
+      end
+
+      def report_macro(step)
+        #puts
+        #puts step.text
+        puts ANSICode.magenta("#{step.code}")
+        puts
+      end
+
+      def report_pass(step)
+        puts ANSICode.green("#{step.code}")
+        puts
+      end
+
+      def report_fail(step, error)
+        tab = step.code.index(/\S/)
+        puts ANSICode.red("#{step.code}")
+        puts
+        msg = []
+        msg << ANSICode.bold(ANSICode.red("FAIL: ")) + error.to_str
+        msg << ANSICode.bold(error.backtrace[0].chomp(":in \`run_step'"))          
+        puts msg.join("\n").tabto(tab||2)
+        puts
+      end
+
+      def report_error(step, error)
+        raise error if $DEBUG
+        tab = step.code.index(/\S/)
+        puts ANSICode.red("#{step.code}")
+        puts
+        msg = []
+        msg << ANSICode.bold(ANSICode.red("ERROR: ")) + error.to_str.sub(/for Quarry::Context.*?$/,'')
+        msg << ANSICode.bold(error.backtrace[0].chomp(":in \`run_step'"))
+        #msg = ANSICode.red(msg)
+        puts msg.join("\n").tabto(tab||2)
+        puts
+      end
+
+      #def report(str)
+      #  count[-1] += 1 unless count.empty?
+      #  str = str.chomp('.') + '.'
+      #  str = count.join('.') + ' ' + str
+      #  puts str.strip
+      #end
+
+    end
+
+  end
+
+end #module Quarry
+

data/lib/quarry/reporter.rb

@@ -0,0 +1,70 @@
+require 'clio/facets/string'
+require 'clio/ansicode'
+
+module Quarry
+
+  # = 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
+

data/lib/quarry/{spec → runner}/context.rb

@@ -1,16 +1,21 @@
 module Quarry
 
-  module Spec
+  class Runner
 
     # = Spec Context
     #
     # Specifications are run within an instance of Context.
     class Context < Module
 
-      def initialize
+      def initialize(spec)
+        @spec = spec
         extend self
       end
 
+      def inspect
+        @spec.file
+      end
+
     end #class Context
 
   end #module Spec

data/lib/quarry/runner.rb

@@ -0,0 +1,123 @@
+#require 'quarry/behave'
+require 'quarry/runner/context'
+
+module Quarry
+
+  # = 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 || 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(spec)
+        # 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 Markup::Header
+            output.report_header(step)
+          when Markup::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 Markup::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 Quarry
+

data/lib/quarry/{stub/stub.rb → stub.rb}

@@ -74,7 +74,7 @@ module Quarry
     #-- 
     # TODO: Use Carats for #unmix.
     #++
-    def remove(stub_module=nil)
+    def remove_stub(stub_module=nil)
       stub_module ||= @_stub
       obj = self
       mod = Module.new

data/lib/quarry.rb

@@ -0,0 +1,10 @@
+require 'quarry/grammar'
+require 'quarry/markup'
+require 'quarry/runner'
+require 'quarry/reporter'
+require 'quarry/reporter/dotprogress'
+require 'quarry/reporter/verbatim'
+require 'quarry/reporter/summary'
+require 'quarry/stub'
+require 'quarry/mock'
+#require 'quarry/spy'

data/spec/basic.rd

@@ -16,5 +16,3 @@ And some that will raise an error:
 
   nobody_knows_method
 
-QED.
-

data/spec/complex.rd

@@ -46,5 +46,3 @@ And some that will raise an error:
 
   nobody_knows_method
 
-QED.
-

data/spec/mock.rd

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

data/spec/stub.rd

@@ -2,32 +2,30 @@
 
 Require stub.rb library.
 
-  require 'quarry/stub/stub'
-
+  require 'quarry/stub'
 
 == Delegation Approach
 
 We will stub-out a simple string.
 
-   obj = "hello"
+   @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.
+Apply the stub module to the object we want to stub.
 
-   alt = obj.stub(@stb)
+   @alt = @obj.stub(@stb)
 
 And get teh newly stubbed output.
 
-   alt.upcase.assert == "HeLLo"
+   @alt.upcase.assert == "HeLLo"
 
 Teh original is still intact.
 
-   obj.upcase.assert == "HELLO"
-
+   @obj.upcase.assert == "HELLO"
 
 == Singleton Approach
 
@@ -39,7 +37,7 @@ Teh original is still intact.
 
    obj.upcase.assert == "hI"
 
-   obj.remove(@stb)
+   obj.remove_stub(@stb)
 
    obj.upcase.assert == "HI"
 
@@ -53,9 +51,7 @@ Teh original is still intact.
 
    obj.upcase.assert == "HeY"
 
-   obj.remove  # imples obj.remove(obj.stub)
+   obj.remove_stub  # imples obj.remove_stub(obj.stub)
 
    obj.upcase.assert == "HEY"
 
-QED.
-