quarry 0.5.0 → 0.5.2

data/lib/quarry/grammar/should.rb

@@ -14,7 +14,7 @@ module Quarry
       #   4.should == 3  #=> Expectation Error
       #
       def should
-        return Expectation.new(:delegate=>self, :backtrace=>caller)
+        return Expectation.new(self, :backtrace=>caller)
       end
 
       # Designate a negated expectation via a *functor*.
@@ -25,7 +25,7 @@ module Quarry
       # See also #expect!
       #
       def should!
-        return Expectation.new(:delagte=>self, :negate=>true, :backtrace=>caller)
+        return Expectation.new(self, :negate=>true, :backtrace=>caller)
       end
 
       # See #should! method.

data/lib/quarry/markup.rb

@@ -1,4 +1,10 @@
 require 'quarry/markup/step'
+require 'quarry/markup/header'
+require 'quarry/markup/comment'
+require 'quarry/markup/macro'
+require 'quarry/markup/before'
+require 'quarry/markup/after'
+require 'quarry/markup/table'
 
 module Quarry
 
@@ -41,18 +47,27 @@ module Quarry
         #text << line
         steps << Header.new(self, text, lineno)
       when /^\s+/
-        last = steps.last
-        case last
+        case last = steps.last
         when Step, Macro
           last.code << "\n\n#{text.rstrip}"
         when Comment
-          if last.macro?
-            steps << Macro.new(self, text, lineno, last.type)
+          if last.text =~ /\A([A-Z]{1,9})[:]/
+          #if macro = Macro.types.find{ |m| m.match?(last.text) }
+            type = Markup.const_get($1.capitalize)
+            step = type.new(self, text, lineno, :comment=>last.text, :before=>@before, :after=>@after)
+            case step
+            when Before
+              @before = step
+            when After
+              @after  = step
+            end
+            steps << step
           else
-            steps << Step.new(self, text, lineno)
+            steps << Step.new(self, text, lineno, :before=>@before, :after=>@after)
           end
         else
-          steps << Step.new(self, text, lineno)
+          raise "never here"
+          steps << Step.new(self, text, lineno, :before=>@before, :after=>@after)
         end
       else
         steps << Comment.new(self, text, lineno)
@@ -64,6 +79,17 @@ module Quarry
       File.basename(file)
     end
 
+    #
+    def to_script
+      script = []
+      Dir.chdir(File.dirname(file)) do
+        steps.each do |step|
+          script << step.to_script
+        end
+      end
+      script.join("\n\n")
+    end
+
   end #class Markup
 
 end#module Quarry

data/lib/quarry/markup/after.rb

@@ -0,0 +1,28 @@
+require 'quarry/markup/macro'
+
+module Quarry
+
+  class Markup #:nodoc:
+
+    class After < Macro
+      #def self.match?(comment)
+      #  comment =~ /^AFTER/i
+      #end
+
+      # Run after macro.
+      def run(runner, spec, context, output)
+        #runner.after = code
+        output.report_macro(self)
+      end
+
+      #
+      def to_script
+        code.gsub(/^/, '# ')
+      end
+
+    end
+
+  end #class Markup
+
+end #module Quarry
+

data/lib/quarry/markup/before.rb

@@ -0,0 +1,28 @@
+require 'quarry/markup/macro'
+
+module Quarry
+
+  class Markup #:nodoc:
+
+    class Before < Macro
+      #def self.match?(comment)
+      #  comment =~ /^BEFORE/i
+      #end
+
+      # Run before macro.
+      def run(runner, spec, context, output)
+        #runner.before = code
+        output.report_macro(self)
+      end
+
+      #
+      def to_script
+        code.gsub(/^/, '# ')
+      end
+
+    end
+
+  end #class Markup
+
+end #module Quarry
+

data/lib/quarry/markup/comment.rb

@@ -0,0 +1,56 @@
+module Quarry
+
+  class Markup #:nodoc:
+
+    # = Comment
+    #
+    class Comment
+
+      attr :spec
+      attr :text
+      attr :lineno
+
+      def initialize(spec, text, lineno)
+        @spec   = spec
+        @text   = text.strip
+        @lineno = lineno
+      end
+
+      alias_method :parent, :spec
+      alias_method :description, :text
+
+      # Matches the beginning of text to
+      # determine if this defines a macro section.
+      def type
+        /\A(\w{1,9})[:]\ /i =~ text
+        $1.downcase.to_sym if $1
+      end
+      alias_method :macro?, :type
+
+      # "run" comment.
+      def run(runner, spec, context, output)
+        output.report_comment(self)
+      end
+
+      #
+      def to_s
+        text.to_s
+      end
+
+      # As could appear in stand-alone script.
+      def to_script
+        text.to_s.gsub(/^/m, '# ')
+      end
+
+    end #class Comment
+
+  end #class Markup
+
+end #module Quarry
+
+
+# TABLE: "mytable.yaml" This is what and so on.
+# This is so it will be wahtever fi so.
+#
+#  fdsffsdf
+

data/lib/quarry/markup/header.rb

@@ -0,0 +1,42 @@
+module Quarry
+
+  class Markup #:nodoc:
+
+    # = Header
+    #
+    class Header
+
+      attr :spec
+      attr :text
+      attr :lineno
+
+      def initialize(spec, text, lineno)
+        @parent = spec
+        @text   = text.strip
+        @lineno = lineno
+      end
+
+      alias_method :parent, :spec
+      alias_method :description, :text
+
+      # "run" comment.
+      def run(runner, spec, context, output)
+        output.report_header(self)
+      end
+
+      #
+      def to_s
+        text.to_s
+      end
+
+      # As would appear in stand-alone script.
+      def to_script
+        text.to_s.gsub(/^/m, '# ')
+      end
+
+    end #class Header
+
+  end #class Markup
+
+end #module Quarry
+

data/lib/quarry/markup/macro.rb

@@ -0,0 +1,53 @@
+module Quarry
+
+  class Markup #:nodoc:
+
+    # = Macro
+    #
+    class Macro #< Step
+
+      #def self.inherited(subclass)
+      #  types << subclass
+      #end
+
+      #def self.types
+      #  @types ||= []
+      #end
+
+      attr :spec
+      attr :code
+      attr :lineno
+
+      def initialize(spec, code, lineno, ioc={})
+        @spec   = spec
+        @code   = code.rstrip
+        @lineno = lineno
+      end
+
+      alias_method :parent, :spec
+
+      # Run macro.
+      def run(runner, spec, context, output)
+        context.instance_eval(code, spec.file, lineno)
+        output.report_macro(self)
+      end
+
+      #
+      def tab
+        @tab ||= to_s.index(/\S/)
+      end
+
+      #
+      def to_s ; code ; end
+
+      # As could appear in stand-alone script.
+      def to_script
+        code.to_s
+      end
+
+    end
+
+  end #class Markup
+
+end #module Quarry
+

data/lib/quarry/markup/step.rb

@@ -5,72 +5,68 @@ module Quarry
     # = Step
     #
     class Step
-      attr :parent
+
+      attr :spec
       attr :code
       attr :lineno
 
-      def initialize(parent, code, lineno)
-        @parent = parent
+      attr :before
+      attr :after
+
+      def initialize(spec, code, lineno, ioc={})
+        @spec   = spec
         @code   = code.rstrip
         @lineno = lineno
+
+        @before = ioc[:before]
+        @after  = ioc[:after]
       end
 
-      alias_method :spec, :parent
+      alias_method :parent, :spec
 
       #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
+      # Run specification step.
+      #
+      # TODO: Would spec.before + spec.code be better?
+      #
+      def run(runner, spec, context, output)
+        output.report_step(self)
+        #context.instance_eval(runner.before, spec.file) if runner.before
+        context.instance_eval(before.code, spec.file) if before
+        begin
+          context.instance_eval(code, spec.file, lineno)
+          output.report_pass(self)
+        rescue Assertion => error
+          output.report_fail(self, error)
+        rescue Exception => error
+          output.report_error(self, error)
+        ensure
+          context.instance_eval(after.code, spec.file) if after
+          #context.instance_eval(runner.after, spec.file) if runner.after
+        end
       end
-    end
-
-    # = Header
-    #
-    class Header
-      attr :parent
-      attr :text
-      attr :lineno
 
-      def initialize(parent, text, lineno)
-        @parent = parent
-        @text   = text.strip
-        @lineno = lineno
+      #
+      def tab
+        @tab ||= to_s.index(/\S/)
       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
+      #
+      def to_s
+        code
       end
 
-      alias_method :spec, :parent
-      alias_method :description, :text
-
-      #
-      def type
-        /^(\w{1,9})[:]/i =~ text
-        $1.downcase.to_sym if $1
+      # As could appear in stand-alone script.
+      def to_script
+        script = []
+        script << before.code if before
+        script << code
+        script << before.code if after
+        script .join("\n")
       end
-      alias_method :macro?, :type
     end
 
   end #class Markup

data/lib/quarry/markup/table.rb

@@ -0,0 +1,89 @@
+require 'yaml'
+require 'quarry/markup/step'
+
+module Quarry
+
+  class Markup #:nodoc:
+
+    # = Table
+    #
+    class Table < Step
+      attr :file
+      attr :data
+      attr :vars
+
+      def initialize(spec, code, lineno, ioc={})
+        super(spec, code, lineno, ioc)
+
+        comment = ioc[:comment]
+
+        if md = /\(\*?\)/.match(comment)
+          @fname = md[1]
+        else
+          @fname = 'default.yaml'  # TODO: more intelligent default?
+        end
+
+        @file = File.join('tables', @fname)
+      end
+
+      def load_table
+        table = YAML.load(File.new(file))  # yaml or csv ?
+        vars, *data = *table
+        return vars, data
+      end
+
+      # Run a specification tabular step.
+      #
+      # TODO: Table reporting needs to be improved.
+      # TODO: Currently on simple object types can be used b/c of set's use of #inspect.
+      #
+      def run(runner, spec, context, output)
+        vars, rows = *load_table
+
+        #context.instance_eval(runner.before, spec.file) if runner.before
+        context.instance_eval(before.code, spec.file) if before
+
+        begin
+          output.report_macro(self); puts #(little bit of a hack here)
+          rows.each do |row|
+            set  = vars.zip(row).map{ |a| "#{a[0]}=#{a[1].inspect}" }.join('; ')
+            set  = (' ' * tab) + set
+            code = "#{set}\n#{code()}"
+            step = Step.new(spec, set, lineno) # fuax step
+            begin
+              context.instance_eval(code, spec.file, lineno)
+              #output.report_literal(set)
+              output.report_pass(step) #(self)
+            rescue Assertion => error
+              output.report_fail(step, error) #(self, error)
+            rescue Exception => error
+              output.report_error(step, error) #(self, error)
+            end
+          end
+        ensure
+          #context.instance_eval(runner.after, spec.file) if runner.after
+          context.instance_eval(after.code, spec.file) if after
+        end
+      end
+
+      #
+      def to_script
+        script = []
+        vars, rows = *load_table
+        script << before.code if before
+        rows.each do |row|
+          set  = vars.zip(row).map{ |a| "#{a[0]}=#{a[1].inspect}" }.join('; ')
+          set  = (' ' * tab) + set
+          code = "#{set}\n#{code()}"
+          script << code
+        end
+        script << after.code if after
+        script.join("\n")
+      end
+
+    end #class Table
+
+  end #class Markup
+
+end #module Quarry
+