qed 2.1.1 → 2.2.0

data/lib/qed/advice/patterns.rb

@@ -1,11 +1,12 @@
 module QED
 
-  # = Patter Advice (When)
+  # = Pattern Advice (When)
   #
-  # This class tracks When advice defined by demo scripts
-  # and helpers. It is instantiated in Scope, so that
-  # the advice methods will have access to the same
-  # local binding and the demo scripts themselves.
+  # 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
 
@@ -16,33 +17,50 @@ module QED
     end
 
     #
-    def add(pattern, &procedure)
-      @when << [pattern, procedure]
+    def add(patterns, &procedure)
+      @when << [patterns, procedure]
     end
 
     #
-    def call(match, *args)
-      @when.each do |(pattern, proc)|
-        case pattern
-        when Regexp
-          regex = pattern
-        else
-          regex = when_string_to_regexp(pattern)
+    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 md = regex.match(match)
-          proc.call(*md[1..-1])
+        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)
+        x =~ /\A\(\((.*)\)\)\Z/ ? $1 : Regexp.escape(x)
       }.join
-      str = str.gsub(/(\\\ )+/, '\s+')
+      str = str.gsub(/\\\s+/, '\s+')
       Regexp.new(str, Regexp::IGNORECASE)
 
       #rexps = []

data/lib/qed/applique.rb

@@ -0,0 +1,85 @@
+require 'qed/advice'
+
+module QED
+
+  # The Applique is the environment of libraries required by
+  # and the rules to apply to demonstrandum. The applique is
+  # defined by a set of scripts located in the +applique+ 
+  # directory of the upper-most test directory relative to
+  # the tests run and below the root of a project. All
+  # applique scripts are loaded at the start of a test
+  # session. Thus all demos belong to one and only one
+  # applique, and all the scripts in an applique must be
+  # compatible/consistant. For two demos to have separate
+  # applique they must be kept in separate directores.
+
+  class Applique < Module
+
+    #
+    def initialize
+      super()
+      extend self
+      @__advice__ = Advice.new
+    end
+
+    #
+    def initialize_copy(other)
+      @__advice__ = other.__advice__.dup
+    end
+
+    # Redirect missing constants to Object class 
+    # to simulate TOPLEVEL.
+    #
+    # TODO: Clean backtrace when constant is not found.
+    def const_missing(name)
+      Object.const_get(name)
+    end
+
+    #
+    def __advice__
+      @__advice__
+    end
+
+    # Because patterns are mathced against HTML documents
+    # HTML special charaters +<+, +>+ and +&+ should not be
+    # used.
+    def When(*patterns, &procedure)
+      if patterns.size == 1 && Symbol === patterns.first
+        __advice__.events.add(:"#{patterns.first}", &procedure)
+      else
+        __advice__.patterns.add(patterns, &procedure)
+      end
+    end
+
+    # Before advice.
+    def Before(type=:code, &procedure)
+      __advice__.events.add(:"before_#{type}", &procedure)
+    end
+
+    # After advice.
+    def After(type=:code, &procedure)
+      __advice__.events.add(:"after_#{type}", &procedure)
+    end
+
+    # Code match-and-transform procedure.
+    #
+    # This is useful to transform human readable code examples
+    # into proper exectuable code. For example, say you want to
+    # run shell code, but want to make if look like typical
+    # shelle examples:
+    #
+    #    $ cp fixture/a.rb fixture/b.rb
+    #
+    # You can use a transform to convert lines starting with '$'
+    # into executable Ruby using #system.
+    #
+    #    system('cp fixture/a.rb fixture/b.rb')
+    #
+    #def Transform(pattern=nil, &procedure)
+    #
+    #end
+
+  end
+
+end
+

data/lib/qed/command.rb

@@ -3,7 +3,6 @@
 require 'qed'
 require 'optparse'
 require 'shellwords'
-require 'tilt'
 
 module QED
 
@@ -17,7 +16,7 @@ module QED
     # Default location of demonstrations if no
     # specific files or locations given. This
     # is use in Dir.glob.
-    DEFAULT_DEMOS_LOCATION = '{qed}'
+    DEFAULT_DEMO_LOCATION = '{demo,demos}'
 
     # Initialize and execute.
     def self.execute
@@ -156,12 +155,11 @@ module QED
     end
 
     #
-
     def demos
       files = self.files
-      types = Tilt.mappings.keys
+      types = %w{qed rdoc md markdown} #Tilt.mappings.keys
       if files.empty?
-        files << DEFAULT_DEMOS_LOCATION
+        files << DEFAULT_DEMO_LOCATION
       end
       files = files.map do |pattern|
         Dir[pattern]

data/lib/qed/evaluator.rb

@@ -1,27 +1,15 @@
 module QED
 
-  require 'tilt'
-  require 'nokogiri'
   require 'qed/scope'
 
-  # = Demo Script Evaluator
-  #
-  #--
-  # TODO: Currently the Evaluator class uses #traverse to work
-  # thru the HTML document and trigger events accordingly. This
-  # works well enough for simple HTML documents --the kind produced
-  # by typical wiki-markup formats. However, for complex HTML it
-  # it will not produce ideal output (although the code segements
-  # should still run just fine). To counter this weakness, we will
-  # have to swtich to a more complex SAX parser in the future.
-  #--
+  # = Demonstrandum Evaluator
   class Evaluator
 
     #
     def initialize(script, *observers)
       @script  = script
       @file    = script.file
-      @root    = script.root
+      @ast     = script.parse
       @scope   = script.scope
       @binding = script.binding
       @advice  = script.advice
@@ -31,75 +19,78 @@ module QED
 
     #
     def run
-      Dir.chdir(File.dirname(@file)) do
-        advise!(:before_document, @script)
-        @root.traverse do |element|
-          call_tag(element)
-        end
-        advise!(:after_document, @script)
-      end
-    end
-
-    #
-    def call_tag(element)
-      advise!(:tag, element)
-      __send__("tag_#{element.name}", element)
+      advise!(:before_document, @script)
+      process
+      advise!(:after_document, @script)
     end
 
-    # T A G S
-
     #
-    def tag_a(element)
-      case element['href']
-      when /qed:\/\/(.*?)$/
-        file = $1
-        case File.extname(file)
-        when '.rb'
-          import!(file)
-        else
-          Script.new(file, scope).run
+    def process
+      @ast.each do |section|
+        case section.type
+        when :code
+          evaluate_code(section)
+        when :text
+          evaluate_text(section)
         end
       end
     end
 
     #
-    def tag_pre(element)
-      advise!(:before_code, element, @file)
+    def evaluate_code(section)
+      advise!(:before_code, section, @file)
       begin
-        eval(element.text, @binding, @file, element.line)
-        pass!(element)
+        advise!(:code, section)
+        eval(section.text, @binding, @file, section.line)
+        #@scope.module_eval(section.text, @file, section.line)
+        pass!(section)
       rescue Assertion => exception
-        fail!(element, exception)
+        fail!(section, exception)
       rescue Exception => exception
-        error!(element, exception)
+        error!(section, exception)
       end
-      advise!(:after_code, element, @file)
+      advise!(:after_code, section, @file)
     end
 
     #
-    def tag_p(element)
-      advise!(:when, element.text)
+    def evaluate_text(section)
+      advise!(:text, section)
+      evaluate_links(section)
+      advise!(:when, section)
     end
 
     #
-    def method_missing(s, *a)
-      super(s, *a) unless /^tag/ =~ s.to_s
+    def evaluate_links(section)
+      section.text.scan(/\[qed:\/\/(.*?)\]/) do |match|
+        file = $1
+        # relative to demo script
+        if File.exist?(File.join(@script.directory,file))
+          file = File.join(@script.directory,file)
+        end
+        # ruby or another demo
+        case File.extname(file)
+        when '.rb'
+          import!(file)
+        else
+          Script.new(@script.applique, file, @script.scope).run
+        end
+      end
     end
 
     #
-    def pass!(element)
-      advise!(:pass, element)
+    def pass!(section)
+      advise!(:pass, section)
     end
 
     #
-    def fail!(element, exception)
-      advise!(:fail, element, exception)
+    def fail!(section, exception)
+      advise!(:fail, section, exception)
       #raise exception
     end
 
     #
-    def error!(element, exception)
-      advise!(:error, element, exception)
+    def error!(section, exception)
+      advise!(:error, section, exception)
       #raise exception
     end
 
@@ -114,7 +105,7 @@ module QED
     def advise!(signal, *args)
       @observers.each{ |o| o.update(signal, *args) }
       #@scope.__advice__.call(signal, *args)
-      @advice.call(signal, *args)
+      @advice.call(@scope, signal, *args)
     end
 
     #
@@ -122,6 +113,11 @@ module QED
     #  @advice.call_when(match)
     #end
 
+    ##
+    #def method_missing(s, *a)
+    #  super(s, *a) unless /^tag/ =~ s.to_s
+    #end
+
   end
 
 end

data/lib/qed/package.yml

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

data/lib/qed/parser.rb

@@ -0,0 +1,149 @@
+module QED
+
+  # The parser breaks down a demonstandum into
+  # structured object to passed thru the script
+  # evaluator.
+  # 
+  # Technically is defines it's own markup language
+  # but for interoperability sake it ...
+  class Parser
+
+    #
+    def initialize(file)
+      @lines = File.readlines(file).to_a
+      @ast = []
+    end
+
+    #
+    attr :ast
+
+    #
+    def parse
+      state = :text
+      linein = 0
+
+      text  = ''
+
+      @lines.each_with_index do |line, lineno|
+        if /^\S/ =~ line
+          if state == :code
+            add_section(:code, text, linein)
+            linein = lineno
+            text = ''
+          end
+          state = :text
+          text << line          
+        else
+          if state == :text
+            next if text.strip.empty?
+            add_section(:text, text, linein)
+            linein = lineno
+            text = ''
+          end
+          state = :code
+          text << line          
+        end
+      end
+      add_section(state, text, linein)
+      @ast.reject!{ |sect| sect.type == :code && sect.text.strip.empty? }
+      return @ast
+    end
+
+    #
+    def add_section(state, text, lineno)
+      case state
+      when :code
+        if ast.last.raw?
+          @ast.last << text #clean_quote(text)
+        else
+          @ast << CodeSection.new(text, lineno)
+        end
+      else
+        @ast << TextSection.new(text, lineno)
+        #cont = (/\.\.\.\s*^/ =~ text ? true : false)
+      end
+    end
+
+    # TODO: We need to preserve the indentation for the verbatim reporter.
+    #def clean_quote(text)
+    #  text = text.tabto(0).chomp.sub(/\A\n/,'')
+    #  if md = /\A["]{3,}(.*?)["]{3,}\Z/.match(text)
+    #    text = md[1]
+    #  end
+    #  text.rstrip
+    #end
+
+    #
+    class Section
+      attr :text
+      attr :line
+      def initialize(text, line)
+        @text = text
+        @line = line
+      end
+    end
+
+    #
+    class TextSection < Section
+      attr :args
+      attr :cont
+      def initialize(text, line, *args)
+        @text = text
+        @line = line
+        @args = args
+        @cont = []
+      end
+      def <<(text)
+        @cont << clean_continuation(text)
+        @args << block_continuation(text)
+      end
+      def type
+        :text
+      end
+      # TODO: Use ':' or '...' ?
+      def raw?
+        #/\:\s*\Z/m =~ text
+        /\.\.\.\s*\Z/m =~ text
+      end
+
+      # Clean up the text, removing unccesseary white lines and triple
+      # quote brackets, but keep indention intact.
+      def clean_continuation(text)
+        text = text.chomp.sub(/\A\n/,'')
+        if md = /\A["]{3,}(.*?)["]{3,}\Z/.match(text)
+          text = md[1]
+        end
+        text.rstrip
+      end
+
+      # Block the text, removing white lines, triple quote brackets
+      # and indention.
+      def block_continuation(text)
+        text = text.tabto(0).chomp.sub(/\A\n/,'')
+        if md = /\A["]{3,}(.*?)["]{3,}\Z/.match(text)
+          text = md[1]
+        end
+        text.rstrip
+      end
+    end
+
+    #
+    class CodeSection < Section
+      #attr :args
+      def intialize(text, line) #, *args)
+        @text = text
+        @line = line
+        #@args = args
+      end
+      #def <<(arg)
+      #  @args << arg
+      #end
+      def type
+        :code
+      end
+    end
+
+  end
+
+end
+