qed 2.2.0 → 2.2.1

data/HISTORY

@@ -1,5 +1,17 @@
 = RELEASE HISTORY
 
+== 2.2.1 / 2010-06-21
+
+Remove dependencies to Tilt and Nokogiri. Should have
+done this in last release but alas --there is so
+much to do.
+
+Change:
+
+* Removed HTML parsing dependencies.
+* Reduce Advice to a single class.
+
+
 == 2.2.0 / 2010-06-20
 
 This release returns to a text-based evaluator, rather

data/REQUIRE

@@ -2,8 +2,6 @@ runtime:
   - ae
   - ansi
   - facets
-  - tilt
-  - nokogiri
 
 development:
   - syckle

data/VERSION

@@ -1,5 +1,5 @@
 name : qed
 major: 2
 minor: 2
-patch: 0
+patch: 1
 date : 2010-06-20

data/lib/qed/advice.rb

@@ -1,34 +1,152 @@
 module QED
 
-  require 'qed/advice/events'
-  require 'qed/advice/patterns'
-
   # = Advice
   #
-  # This class tracks advice defined by demo scripts
-  # and helpers. It is instantiated in Scope, so that
+  # This class tracks advice defined by demonstrandum
+  # and applique. It is instantiated in Scope, so that
   # the advice methods will have access to the same
-  # local binding and the scripts themselves.
+  # local binding as the scripts themselves.
+  #
+  # There are two types of advice: *pattern matchers*
+  # and *event signals*.
+  #
+  # == Pattern Matchers (When)
+  #
+  # Matchers are evaluated in Scope context, via #instance_exec,
+  # so that the advice methods will have access to the same
+  # scope as the demonstrandum themselves.
+  #
+  # == Event Signals (Before, After)
+  #
+  # Event advice are triggered on symbolic targets which 
+  # represent an event in the evaluation process, such as
+  # before any demo is run, or after all demo finish running.
   #
   class Advice
 
-    attr :patterns
+    #
+    attr :matchers
 
-    attr :events
+    #
+    attr :signals
 
+    #
     def initialize
-      @patterns = Patterns.new
-      @events   = Events.new
+      @matchers = []
+      @signals  = [{}]
     end
 
+    #
     def call(scope, type, *args)
       case type
       when :when
-        @patterns.call(scope, *args)
+        call_matchers(scope, *args)
+      else
+        #@events.call(scope, type, *args)
+        call_signals(scope, type, *args)
+      end
+    end
+
+    #
+    def add_event(type, &procedure)
+      @signals.last[type.to_sym] = procedure
+    end
+
+    #
+    def add_match(patterns, &procedure)
+      @matchers << [patterns, procedure]
+    end
+
+    # React to an event.
+    def call_signals(scope, type, *args)
+      @signals.each do |set|
+        proc = set[type.to_sym]
+        #proc.call(*args) if proc
+        scope.instance_exec(*args, &proc) if proc
+      end
+    end
+
+    #
+    def call_matchers(scope, section)
+      match = section.text
+      args  = section.args
+
+      @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)
+          scope.instance_exec(*params, &proc)
+        end
+      end
+    end
+
+    # Clear last set of advice.
+    def signals_reset
+      @signals.pop
+    end
+
+    #
+    def signals_setup
+      @signals.push({})
+    end
+
+    # Clear advice.
+    def signals_clear(type=nil)
+      if type
+        @signals.each{ |set| set.delete(type.to_sym) }
       else
-        @events.call(scope, type, *args)
+        @signals = [{}]
       end
     end
+
+  private
+
+    # 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 "?:(.*?)".
+    #
+    # 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
+
   end
 
 end

data/lib/qed/applique.rb

@@ -40,25 +40,23 @@ module QED
       @__advice__
     end
 
-    # Because patterns are mathced against HTML documents
-    # HTML special charaters +<+, +>+ and +&+ should not be
-    # used.
+    # Pattern matchers and "upon" events.
     def When(*patterns, &procedure)
       if patterns.size == 1 && Symbol === patterns.first
-        __advice__.events.add(:"#{patterns.first}", &procedure)
+        __advice__.add_event(patterns.first, &procedure)
       else
-        __advice__.patterns.add(patterns, &procedure)
+        __advice__.add_match(patterns, &procedure)
       end
     end
 
     # Before advice.
     def Before(type=:code, &procedure)
-      __advice__.events.add(:"before_#{type}", &procedure)
+      __advice__.add_event(:"before_#{type}", &procedure)
     end
 
     # After advice.
     def After(type=:code, &procedure)
-      __advice__.events.add(:"after_#{type}", &procedure)
+      __advice__.add_event(:"after_#{type}", &procedure)
     end
 
     # Code match-and-transform procedure.

data/lib/qed/evaluator.rb

@@ -8,11 +8,12 @@ module QED
     #
     def initialize(script, *observers)
       @script  = script
-      @file    = script.file
       @ast     = script.parse
-      @scope   = script.scope
-      @binding = script.binding
-      @advice  = script.advice
+
+      #@file    = script.file
+      #@scope   = script.scope
+      #@binding = script.binding
+      #@advice  = script.advice
 
       @observers = observers
     end
@@ -38,18 +39,17 @@ module QED
 
     #
     def evaluate_code(section)
-      advise!(:before_code, section, @file)
+      advise!(:before_code, section, @script.file)
       begin
         advise!(:code, section)
-        eval(section.text, @binding, @file, section.line)
-        #@scope.module_eval(section.text, @file, section.line)
+        @script.evaluate(section.text, section.line)
         pass!(section)
       rescue Assertion => exception
         fail!(section, exception)
       rescue Exception => exception
         error!(section, exception)
       end
-      advise!(:after_code, section, @file)
+      advise!(:after_code, section, @script.file)
     end
 
     #
@@ -97,15 +97,14 @@ module QED
     #
     def import!(file)
       advise!(:unload)
-      eval(File.read(file), @binding, file)
+      eval(File.read(file), @script.binding, file)
       advise!(:load, file)
     end
 
-    #
+    # Dispatch event to observers and advice.
     def advise!(signal, *args)
       @observers.each{ |o| o.update(signal, *args) }
-      #@scope.__advice__.call(signal, *args)
-      @advice.call(@scope, signal, *args)
+      @script.advise(signal, *args)
     end
 
     #

data/lib/qed/package.yml

@@ -1,5 +1,5 @@
 name : qed
 major: 2
 minor: 2
-patch: 0
+patch: 1
 date : 2010-06-20

data/lib/qed/script.rb

@@ -40,6 +40,11 @@ module QED
       @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))
@@ -50,6 +55,12 @@ module QED
       @name ||= File.basename(file).chomp(File.extname(file))
     end
 
+    #
+    def evaluate(code, line)
+      eval(code, @binding, @file, line)
+      #@scope.module_eval(section.text, @file, section.line)
+    end
+
     #
     #def source
     #  @source ||= (
@@ -63,6 +74,8 @@ module QED
     #  )
     #end
 
+    # Parse script.
+    # Retruns an abstract syntax tree.
     def parse
       Parser.new(file).parse
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: qed
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 5
   prerelease: false
   segments: 
   - 2
   - 2
-  - 0
-  version: 2.2.0
+  - 1
+  version: 2.2.1
 platform: ruby
 authors: 
 - Thomas Sawyer <transfire@gmail.com>
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-19 00:00:00 -04:00
+date: 2010-06-20 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -60,38 +60,10 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: tilt
-  prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: nokogiri
-  prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id005
 - !ruby/object:Gem::Dependency 
   name: syckle
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -101,7 +73,7 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id006
+  version_requirements: *id004
 description: QED (Quality Ensured Demonstrations) is a TDD/BDD framework utilizing Literate Programming techniques.
 email: 
 executables: 
@@ -137,8 +109,6 @@ files:
 - eg/hello_world.rdoc
 - eg/view_error.rdoc
 - eg/website.rdoc
-- lib/qed/advice/events.rb
-- lib/qed/advice/patterns.rb
 - lib/qed/advice.rb
 - lib/qed/applique.rb
 - lib/qed/command.rb

data/lib/qed/advice/events.rb

@@ -1,57 +0,0 @@
-module QED
-
-  class Advice
-
-    # This class encapsulates advice on symbolic targets,
-    # such as Before, After and Upon.
-    #
-    class Events
-
-      #
-      attr :signals
-
-      #
-      def initialize
-        @signals = [{}]
-      end
-
-      #
-      def add(type, &procedure)
-        @signals.last[type.to_sym] = procedure
-      end
-
-      #
-      def call(scope, type, *args)
-        
-        @signals.each do |set|
-          proc = set[type.to_sym]
-          #proc.call(*args) if proc
-          scope.instance_exec(*args, &proc) if proc
-        end
-      end
-
-      # Clear last set of advice.
-      def reset
-        @signals.pop
-      end
-
-      #
-      def setup
-        @signals.push {}
-      end
-
-      # Clear advice.
-      def clear(type=nil)
-        if type
-          @signals.each{ |set| set.delete(type.to_sym) }
-        else
-          @signals = [{}]
-        end
-      end
-
-    end
-
-  end
-
-end
-

data/lib/qed/advice/patterns.rb

@@ -1,82 +0,0 @@
-module QED
-
-  # = Pattern Advice (When)
-  #
-  # This class encapsulates "When" advice on plain text.
-  #
-  # Matches are evaluated in Scope context, via #instance_exec,
-  # so that the advice methods will have access to the same
-  # scope as the demonstrandum themselves.
-  #
-  class Patterns
-
-    attr :when
-
-    def initialize
-      @when = []
-    end
-
-    #
-    def add(patterns, &procedure)
-      @when << [patterns, procedure]
-    end
-
-    #
-    def call(scope, section)
-      match = section.text
-      args  = section.args
-
-      @when.each do |(patterns, proc)|
-        compare = match
-        matched = true
-        params  = []
-        patterns.each do |pattern|
-          case pattern
-          when Regexp
-            regex = pattern
-          else
-            regex = when_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)
-          scope.instance_exec(*params, &proc)
-        end
-      end
-    end
-
-  private
-
-    # TODO: Now that we can use multi-patterns, we might not need this any more.
-    def when_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
-
-  end
-
-end
-