qed 2.4.0 → 2.5.0

data/lib/qed/{core_ext/instance_exec.rb → core_ext.rb}

@@ -1,3 +1,5 @@
+require 'facets/dir/ascend'
+
 class Object
 
   unless method_defined?(:instance_exec) # 1.9

data/lib/qed/demo.rb

@@ -1,35 +1,31 @@
 module QED
-  require 'yaml'
 
-  require 'facets/dir/ascend'
+  require 'yaml'
 
+  require 'qed/core_ext'
   require 'qed/parser'
   require 'qed/evaluator'
+  require 'qed/applique'
 
-  # = Demo
+  # The Demo class ecapsulates a demonstration document.
   #
   class Demo
 
-    #
-    attr :applique
-
     # Demonstrandum file.
     attr :file
 
-    #
+    # Parser mode.
     attr :mode
 
-    #
+    # Scope to run demonstration within. (Known as a "World" in Cucumber.)
     attr :scope
 
     # New Script
-    def initialize(file, applique, options={})
+    def initialize(file, options={})
       @file     = file
-      @applique = applique.dup # localize copy of applique
       @scope    = options[:scope] || Scope.new(applique, file)
       @mode     = options[:mode]
       @binding  = @scope.__binding__
-      #@loadlist = []
       #apply_environment
     end
 
@@ -38,17 +34,6 @@ module QED
       @binding #||= @scope.__binding__
     end
 
-    # TODO: demo advice vs. applique advice
-    def advice
-      #@scope.__advice__
-      @applique.__advice__
-    end
-
-    #
-    def advise(signal, *args)
-      advice.call(@scope, signal, *args)
-    end
-
     # Expanded dirname of +file+.
     def directory
       @directory ||= File.expand_path(File.dirname(file))
@@ -65,6 +50,48 @@ module QED
       #@scope.module_eval(section.text, @file, section.line)
     end
 
+    # Returns a cached Array of Applique modules.
+    def applique
+      @applique ||= (
+        list = [Applique.new]
+        applique_locations.each do |location|
+          Dir[location + '/**/*.rb'].each do |file|
+            list << Applique.new(file)
+          end
+        end
+        list
+      )
+    end
+
+    # Returns a list of applique directories to be used by this
+    # demonstrastion.
+    def applique_locations
+      @applique_locations ||= (
+        locations = []
+        Dir.ascend(File.dirname(file)) do |path|
+          break if path == Dir.pwd
+          dir = File.join(path, 'applique')
+          if File.directory?(dir)
+            locations << dir
+          end
+        end
+        locations
+      )
+    end
+
+    # Parse demonstration script.
+    #
+    # Returns an abstract syntax tree.
+    def parse
+      Parser.new(file, :mode=>mode).parse
+    end
+
+    #
+    def run(*observers)
+      evaluator = Evaluator.new(self, *observers)
+      evaluator.run
+    end
+
     #
     #def source
     #  @source ||= (
@@ -78,18 +105,6 @@ module QED
     #  )
     #end
 
-    # Parse script.
-    # Retruns an abstract syntax tree.
-    def parse
-      Parser.new(file, :mode=>mode).parse
-    end
-
-    #
-    def run(*observers)
-      evaluator = Evaluator.new(self, *observers)
-      evaluator.run
-    end
-
   end
 
 end

data/lib/qed/evaluator.rb

@@ -98,6 +98,7 @@ module QED
     end
 
     # TODO: Not sure how to handle loading links in --comment runner mode.
+    # TODO: Do not think Scope should be reuseud by imported demo.
     def evaluate_links(step)
       step.text.scan(/\[qed:\/\/(.*?)\]/) do |match|
         file = $1
@@ -110,7 +111,7 @@ module QED
         when '.rb'
           import!(file)
         else
-          Demo.new(file, @script.applique, :scope=>@script.scope).run
+          Demo.new(file, :scope=>@script.scope).run
         end
       end
     end
@@ -142,7 +143,14 @@ module QED
     # Dispatch event to observers and advice.
     def advise!(signal, *args)
       @observers.each{ |o| o.update(signal, *args) }
-      @script.advise(signal, *args)
+
+      #@script.advise(signal, *args)
+      case signal
+      when :when
+        call_matchers(*args)
+      else
+        call_signals(signal, *args)
+      end
     end
 
     #
@@ -150,6 +158,106 @@ module QED
     #  @advice.call_when(match)
     #end
 
+    # React to an event.
+    #
+    # TODO: Should events short circuit on finding first match?
+    # In other words, should there be only one of each type of signal
+    # ragardless of how many applique layers?
+    def call_signals(type, *args)
+      @script.applique.each do |a|
+        signals = a.__signals__
+        proc = signals[type.to_sym] 
+        #signals.each do |set|
+          #proc = set[type.to_sym]
+          #proc.call(*args) if proc
+          @script.scope.instance_exec(*args, &proc) if proc
+        #end
+      end
+
+      #@script.applique.each do |a|
+      #  signals = a.__signals__
+      #  proc = signals[type.to_sym] 
+      #  if proc
+      #    @script.scope.instance_exec(*args, &proc)
+      #    break
+      #  end
+      #end
+
+      #meth = "qed_#{type}"
+      #if @script.scope.respond_to?(meth)
+      #  meth = @script.scope.method(meth)
+      #  if meth.arity == 0
+      #    meth.call
+      #  else
+      #    meth.call(*args)
+      #  end
+      #end
+
+      #@script.scope.__send__(meth, *args)
+    end
+
+    #
+    def call_matchers(section)
+      match = section.text
+      args  = section.arguments
+      @script.applique.each do |a|
+        matchers =  a.__matchers__
+        matchers.each do |(patterns, proc)|
+          compare = match
+          matched = true
+          params  = []
+          patterns.each do |pattern|
+            case pattern
+            when Regexp
+              regex = pattern
+            else
+              regex = match_string_to_regexp(pattern)
+            end
+            if md = regex.match(compare)
+              params.concat(md[1..-1])
+              compare = md.post_match
+            else
+              matched = false
+              break
+            end
+          end
+          if matched
+            params += args
+            #proc.call(*params)
+            @script.scope.instance_exec(*params, &proc)
+          end
+        end
+      end
+    end
+
+    # Convert matching string into a regular expression. If the string
+    # contains double parenthesis, such as ((.*?)), then the text within
+    # them is treated as in regular expression and kept verbatium.
+    #
+    # TODO: Better way to isolate regexp. Maybe ?:(.*?) or /(.*?)/.
+    #
+    # TODO: Now that we can use multi-patterns, do we still need this?
+    #
+    def match_string_to_regexp(str)
+      str = str.split(/(\(\(.*?\)\))(?!\))/).map{ |x|
+        x =~ /\A\(\((.*)\)\)\Z/ ? $1 : Regexp.escape(x)
+      }.join
+      str = str.gsub(/\\\s+/, '\s+')
+      Regexp.new(str, Regexp::IGNORECASE)
+
+      #rexps = []
+      #str = str.gsub(/\(\((.*?)\)\)/) do |m|
+      #  rexps << '(' + $1 + ')'
+      #  "\0"
+      #end
+      #str = Regexp.escape(str)
+      #rexps.each do |r|
+      #  str = str.sub("\0", r)
+      #end
+      #str = str.gsub(/(\\\ )+/, '\s+')
+      #Regexp.new(str, Regexp::IGNORECASE)
+    end
+
     ##
     #def method_missing(s, *a)
     #  super(s, *a) unless /^tag/ =~ s.to_s
@@ -158,4 +266,3 @@ module QED
   end
 
 end
-

data/lib/qed/helpers/file_fixtures.rb

@@ -0,0 +1,35 @@
+module QED
+
+  # This extension provides a simple means for creatind file-system fixtures.
+  # Include this in your applique, to have a
+  module FileFixtures
+
+    #
+    def self.included(base)
+      require 'erb'
+    end
+
+    #
+    def copy_fixture(name, tmpdir=nil)
+      tmpdir ||= 'tmp' # self.tmpdir
+      FileUtils.mkdir(tmpdir) unless File.directory?(tmpdir)
+      srcdir = File.join(demo_directory, 'fixtures', name)
+      paths  = Dir.glob(File.join(srcdir, '**', '*'), File::FNM_DOTMATCH)
+      paths.each do |path|
+        basename = File.basename(path)
+        next if basename == '.'
+        next if basename == '..'
+        dest = File.join(tmpdir, path.sub(srcdir+'/', ''))
+        if File.directory?(path)
+          FileUtils.mkdir(dest)
+        else
+          text = ERB.new(File.read(path)).result
+          File.open(dest, 'w'){ |f| f << text }
+        end
+      end
+    end
+
+  end
+
+end
+

data/lib/qed/meta/data.rb

@@ -1,29 +1,27 @@
-Object.__send__(:remove_const, :VERSION) if Object.const_defined?(:VERSION)      # becuase Ruby 1.8~ gets in the way
-
 module QED
 
-  def self.__DIR__
-    File.dirname(__FILE__)
-  end
+  DIRECTORY = File.dirname(__FILE__)
 
-  def self.gemfile
-    @gemfile ||= (
+  def self.package
+    @package ||= (
       require 'yaml'
-      YAML.load(File.new(__DIR__ + '/gemfile'))
+      YAML.load(File.new(DIRECTORY + '/package'))
     )
   end
 
   def self.profile
     @profile ||= (
       require 'yaml'
-      YAML.load(File.new(__DIR__ + '/profile'))
+      YAML.load(File.new(DIRECTORY + '/profile'))
     )
   end
 
   def self.const_missing(name)
     key = name.to_s.downcase
-    gemfile[key] || profile[key] || super(name)
+    package[key] || profile[key] || super(name)
   end
 
 end
 
+# becuase Ruby 1.8~ gets in the way
+Object.__send__(:remove_const, :VERSION) if Object.const_defined?(:VERSION)

data/lib/qed/meta/{gemfile → package}

@@ -1,10 +1,10 @@
 name: qed
-version: 2.4.0
-date: 2010-09-02
+date: 2010-11-07
+version: 2.5.0
 
 requires:
 - ansi
 - facets
-- ae (test)
+- ae
 - syckle (build)
 

data/lib/qed/reporter/abstract.rb

@@ -237,8 +237,12 @@ module Reporter
     end
 
     def print_tally
+      assert_count = Assertion.count
+      assert_fails = Assertion.fails
+      assert_delta = assert_count - assert_fails
+
       mask = "%s demos, %s steps: %s failures, %s errors (%s/%s assertions)"
-      vars = [demos.size, steps.size, fails.size, errors.size, $assertions-$failures, $assertions] #, @pass.size ]
+      vars = [demos.size, steps.size, fails.size, errors.size, assert_delta, assert_count] #, @pass.size ]
 
       io.puts mask % vars 
     end

data/lib/qed/reporter/verbatim.rb

@@ -46,9 +46,9 @@ module Reporter #:nodoc:
       tab = step.text.index(/\S/)
       io.print "#{txt}\n\n".ansi(:red)
       msg = []
-      #msg << ANSI::Code.bold(ANSI::Code.red("FAIL: ")) + error.to_str
+      #msg << ANSI::Code.bold(ANSI::Code.red("FAIL: ")) + error.message
       #msg << ANSI::Code.bold(clean_backtrace(error.backtrace[0]))
-      msg << "FAIL: ".ansi(:bold, :red) + error.to_str
+      msg << "FAIL: ".ansi(:bold, :red) + error.message #to_str
       msg << clean_backtrace(error.backtrace[0]).ansi(:bold)
       io.puts msg.join("\n").tabto(tab||2)
       io.puts
@@ -62,7 +62,7 @@ module Reporter #:nodoc:
       tab = step.text.index(/\S/)
       io.print "#{txt}\n\n".ansi(:red)
       msg = []
-      msg << "ERROR: #{error.class} ".ansi(:bold,:red) + error.to_str #.sub(/for QED::Context.*?$/,'')
+      msg << "ERROR: #{error.class} ".ansi(:bold,:red) + error.message #.sub(/for QED::Context.*?$/,'')
       msg << clean_backtrace(error.backtrace[0]).ansi(:bold)
       #msg = msg.ansi(:red)
       io.puts msg.join("\n").tabto(tab||2)

data/lib/qed/scope.rb

@@ -6,26 +6,30 @@ module QED
   #
   class Scope < Module
 
-    #
-    def self.new(applique, file)
-      @_applique = applique
-      super(applique, file)
-    end
+    # Location of `qed/scope.rb`.
+    DIRECTORY = File.dirname(__FILE__)
 
     #
-    def self.const_missing(name)
-      @_applique.const_get(name)
-    end
+    #    def self.new(applique, file)
+    #      @_applique = applique
+    #      super(applique, file)
+    #    end
+
+    #    #
+    #    def self.const_missing(name)
+    #      @_applique.const_get(name)
+    #    end
 
     #
     def initialize(applique, file=nil)
       super()
       @_applique = applique
       @_file     = file
+      #@loadlist = []
 
+      include *applique
       extend self
-      extend applique # TODO: extend or include applique or none ?
-      include applique
+      #extend applique # TODO: extend or include applique or none ?
       #extend DSLi
 
       # TODO: custom extends?
@@ -45,20 +49,51 @@ module QED
       }
     end
 
+    #
+    def include(*modules)
+      super(*modules)
+      extend self
+    end
+
     # Expanded dirname of +file+.
     def demo_directory
       @_demo_directory ||= File.expand_path(File.dirname(@_file))
     end
 
     # Evaluate code in the context of the scope's special binding.
-    def eval(code, binding=nil)
+    def eval(code, binding=nil, file=nil)
       super(code, binding || __binding__, @_file)
     end
 
+
+
+    # Utilize is like #require, but will evaluate the script in the context
+    # of the current scope.
+    #--
+    # TODO: Alternative to Plugin gem?
+    #
+    # TODO: Should work like require so same file isn't loaded twice.
+    #++
+    def utilize(file)
+      file = Dir[DIRECTORY + "/helpers/#{file}"].first
+      if !file
+        require 'plugin'
+        file = Plugin.find("#{file}{,.rb}", :directory=>nil)
+      end
+      if file
+        code = File.read(file)
+        eval(code, nil, file)
+      else
+        raise LoadError, "no such file -- #{file}"
+      end
+    end
+
+
+
     # Define "when" advice.
     def When(*patterns, &procedure)
       patterns = patterns.map{ |pat| pat == :text ? :desc : pat }
-      @_applique.When(*patterns, &procedure)
+      @_applique.first.When(*patterns, &procedure)
     end
 
     # Define "before" advice. Default type is :each, which
@@ -66,7 +101,7 @@ module QED
     def Before(type=:each, &procedure)
       type = :step if type == :each
       type = :demo if type == :all
-      @_applique.Before(type, &procedure)
+      @_applique.first.Before(type, &procedure)
     end
 
     # Define "after" advice. Default type is :each, which
@@ -74,9 +109,11 @@ module QED
     def After(type=:each, &procedure)
       type = :step if type == :each
       type = :demo if type == :all
-      @_applique.After(type, &procedure)
+      @_applique.first.After(type, &procedure)
     end
 
+
+
     # TODO: Should Table and Data be extensions that can be loaded if desired?
 
     # Use sample table to run steps. The table file will be
@@ -128,6 +165,11 @@ module QED
       #end
     end
 
+    #
+    def const_missing(const)
+      Object.const_get(const)
+    end
+
   end#class Scope
 
 end#module QED