PageTemplate 2.0.0 → 2.1.0

data/lib/PageTemplate/htglossary.rb

@@ -0,0 +1,70 @@
+# htmltemplate.rb
+#
+# An emulation layer on top of PT to mimic HTML::Template
+#
+
+############################################################
+
+class PageTemplate
+  class HTGlossary < SyntaxGlossary
+    @directive = /<!--(.+?)-->/m
+
+    default { |command,parser|
+      TextCommand.new("<!--#{command}-->",parser)
+    }
+
+    define(/^tmpl_var (?:name=)?"?((?:\w+)(?:\.\w+\??)*)"?(?:\s+processor="?(\w+)"?)?$/i) {
+      |match,parser|
+      # Value, Preprocessor, Parser
+      ValueCommand.new(match[1],match[2],parser)
+    }
+
+    define(/^(tmpl_if|tmpl_unless) (?:name=)?"?((\w+)(\.\w+\??)*)"?$/i) {
+      |match,parser|
+      # Called_As, Value, parser
+      IfCommand.new(match[1],match[2],parser)
+    }
+
+    define(/^(tmpl_loop) (?:name=)"?(\w+(?:\.\w+\??)*)"?(?:\s+iterators?="?((?:\s*\w+)+)"?)?$/i) {
+      |match,parser|
+      # Called_As, Value, Iterators
+      LoopCommand.new(match[1],match[2],match[3])
+    }
+
+    define(/^tmpl_include (?:name=|file=)?"?((\w+)(?:\.\w+\??)*)"?$/i) {
+      |match,parser|
+      # Value, parser
+      IncludeCommand.new(match[1],parser)
+    }
+
+    # Command#else's expect only to be called
+    modifier(:else) { |cmd,command|
+      if command =~ /^tmpl_else$/i
+        cmd.else
+        true
+      else
+        false
+      end
+    }
+    modifier(:end) { |cmd,command|
+      if command =~ /^\/\s*#{cmd.called_as}$/i
+        cmd.end
+        true
+      else
+        false
+      end
+    }
+    modifier(:when) { |cmd,command|
+      case command
+      when /^tmpl_when\s+(?:name=)"?(\w(?:.\w+\??)*)"?$/i
+        cmd.when($1)
+        true
+      when /^tmpl_else$/i
+        cmd.else($1)
+        true
+      else
+        false
+      end
+    }
+  end
+end

data/lib/PageTemplate/parser.rb

@@ -19,22 +19,19 @@ class PageTemplate
   #
   # Cache: A cache ensures that a method on an object will only be
   # called once.
-  class Namespace
+  module NamespaceItem
     attr_accessor :parent, :object
-    def initialize(parent=nil,object=nil)
-      @values = Hash.new
-      @parent = parent
-      @object = object
-    end
 
     # Clears the cache
-    def clear_cache
+    def clear
       @values = Hash.new
     end
+    alias_method :clear_cache, :clear
 
     # Saves a variable +key+ as the string +value+ in the global 
     # namespace.
     def set(key, value)
+      @values ||= {}
       @values[key] = value
     end
     alias_method :[]=, :set
@@ -54,7 +51,11 @@ class PageTemplate
     # If +val+ is a dot-separated list of words, then 'key' is the
     # first part of it.  The remainder of the words are sent to key
     # (and further results) to premit accessing attributes of objects.
-    def get(val)
+    def get(val,clean_rescue=true)
+      args = parser.args
+      clean_rescue = !args['raise_on_error'] if clean_rescue
+      @values ||= {}
+      @object ||= nil
       # Is it ours, or is it cached?
       key, rest = val.split(/\./,2)
       value = case
@@ -62,13 +63,14 @@ class PageTemplate
         @values[key]
       when @object.respond_to?(:has_key?) && @object.has_key?(key)
         @values[key] = @object[key]
-      when @object && @object.respond_to?(key.to_sym)
+      when @object.respond_to?(key.to_sym)
         # This sets the cache and returns the value, too!
         @values[key] = @object.send(key)
       when @object && key == '__ITEM__'
         @object
       when @parent
-        @parent.get(key)
+        # Return what the parent gets
+        return @parent.get(val)
       else
         # We're the global namespace
         nil
@@ -77,21 +79,68 @@ class PageTemplate
       if rest
         rest.split(/\./).each do |i|
           begin
-            value = value.send(i)
+            value = case
+            when value.respond_to?(:has_key?) && value.has_key?(i)
+              value[i]
+            when value.respond_to?(:[]) && i =~ /^\d+$/
+              value[i.to_i]
+            when value.respond_to?(i)
+              value.send(i)
+            else
+              nil
+            end
           rescue NoMethodError => er
             return nil
           end
         end
       end
       value
+    rescue Exception => e
+      if clean_rescue
+        "[ Error: #{e.message} ]"
+      else
+        raise e
+      end
     end
     alias_method :[], :get
 
+    # parser: most namespace objects won't be a parser, but pass this
+    # query up to the parser object.
+    def parser
+      if @parent
+        @parent.parser
+      else
+        Parser.recent_parser
+      end
+    end
+
     # A convenience method to test whether a variable has a true
     # value. Returns nil if +flag+ is not found in the namespace, 
     # or +flag+ has a nil value attached to it.
     def true?(flag)
-      get(flag) ? true : false
+      args = parser.args
+      val = get(flag,false)
+      case
+      when ! val
+        false
+      when args['empty_is_true']
+        true
+      when val.respond_to?(:empty?)
+        ! val.empty?
+      else
+        true
+      end
+    rescue Exception => er
+      false
+    end
+  end
+
+  class Namespace
+    include NamespaceItem
+    def initialize(parent=nil,object=nil)
+      @values = Hash.new
+      @parent = parent
+      @object = object
     end
   end
 
@@ -120,7 +169,7 @@ class PageTemplate
       @args  = args
       @paths = @args['include_paths']
       @paths ||= [@args['include_path']].compact
-      @paths = [Dir.getwd] if @paths.empty?
+      @paths = [Dir.getwd,'/'] if @paths.empty?
     end
 
     # Return the contents of the file +name+, which must be within the
@@ -158,54 +207,147 @@ class PageTemplate
   # regexps should not contain PageTemplate command text. i.e:
   # /var \w+/i should be used instead of /[% var %]/
   class SyntaxGlossary
-    attr_accessor :directive
-
-    def initialize(directive, glossary)
-      @directive = directive
-      @glossary = glossary
-    end
+    class << self
+      attr_accessor :directive
+      attr_writer :default
+      def default(&block)
+        if block_given?
+          @default = block
+        else
+          @default
+        end
+      end
 
-    # Look up +text+ to see if it matches a command within the lookup
-    # table, returning the command for it, or UnknownCommand if none
-    # match.
-    def lookup(text)
-      @glossary.each do |key,val|
-        if m = key.match(text)
-          return val
+      # Look up +command+ to see if it matches a command within the lookup
+      # table, returning the instance of the command for it, or
+      # an UnknownCommand if none match.
+      def lookup(command)
+        @glossary.each do |key,val|
+          if m = key.match(command)
+            return val.call(m)
+          end
         end
+
+        return @default.call(command)
+      end
+      def modifies?(modifier,cmd,command)
+        @modifiers[modifier].call(cmd,command)
+      end
+    
+      # Define a regexp -> Command mapping.
+      # +rx+ is inserted in the lookup table as a key for +command+
+      def define(rx,&block)
+        raise ArgumentError, 'First argument to define must be a Regexp' unless rx.is_a?(Regexp)
+        raise ArgumentError, 'Block expected' unless block
+        @glossary ||= {}
+        @glossary[rx] = block
       end
 
-      return UnknownCommand
-    end
-  
-    # Define a regexp -> Command mapping.
-    # +rx+ is inserted in the lookup table as a key for +command+
-    def define(rx,command)
-      raise ArgumentError, 'First argument to define must be a Regexp' unless rx.is_a?(Regexp)
-      @glossary[rx] = command
-    end
-    # This is shorthand for define(+key+,Valuecommand), and also
-    # allows +key+ to be a string, converting it to a regexp before
-    # adding it to the dictionary.
-    def define_global_var(key)
-      rx = key
-      rx = /^#{key.to_s}(?:\.\w+\??)*(?:\s:(\w+))?$/ unless key.is_a?(Regexp)
-      @glossary[rx] = ValueCommand
+      def modifier(sym,&block)
+        raise ArgumentError, 'First argument to define must be a Symbol' unless sym.is_a?(Symbol)
+        raise ArgumentError, 'Block expected' unless block
+        @modifiers ||= Hash.new(lambda { false })
+        @modifiers[sym] = block
+      end
+
+      # This is shorthand for define(+key+,Valuecommand), and also
+      # allows +key+ to be a string, converting it to a regexp before
+      # adding it to the dictionary.
+      def define_global_var(rx)
+        @glossary ||= {}
+        rx = /^(#{key.to_s}(?:\.\w+\??)*)(?:\s:(\w+))?$/ unless rx.is_a?(Regexp)
+        @glossary[rx] = lambda { |match|
+          ValueCommand.new(match[1],match[2])
+        }
+      end
     end
   end
 
   # This is the regexp we tried using for grabbing an entire line
   # Good for everything but ValueCommand :-/.
   # /(?:^\s*\[%([^\]]+?)%\]\s*$\r?\n?|\[%(.+?)%\])/m,
-  DEFAULTGLOSSARY = SyntaxGlossary.new(
-          /\[%(.+?)%\]/m,
+  class DefaultGlossary < SyntaxGlossary
+    @directive = /\[%(.+?)%\]/m
+
+    default { |command|
+      UnknownCommand.new(command)
+    }
+
+    define(/^var ((?:\w+)(?:\.\w+\??)*)(?:\s+:(\w+))?$/i) { |match|
+      # Value, Preprocessor
+      ValueCommand.new(match[1],match[2])
+    }
+
+    define(/^--(.+)$/i) { |match|
+    # The Comment
+      CommentCommand.new(match[1])
+    }
+
+    define(/^(if|unless) ((\w+)(\.\w+\??)*)$/i) { |match|
+      # Called_As, Value
+      IfCommand.new(match[1],match[2])
+    }
+
+    define(/^(in|loop) (\w+(?:\.\w+\??)*)(?:\:((?:\s+\w+)+))?$/i) { |match|
+      # Called_As, Value, Iterators
+      LoopCommand.new(match[1],match[2],match[3])
+    }
+
+    define(/^include ((\w+)(?:\.\w+\??)*)$/i) { |match|
+      # Value
+      IncludeCommand.new(match[1])
+    }
+
+    # Command#else's expect only to be called
+    modifier(:else) { |cmd,command|
+      case command
+      when /^else|no|empty$/i
+        cmd.else
+        true
+      else
+        false
+      end
+    }
+
+    # elsif: accepts else and elsif
+    modifier(:elsif) { |cmd,command|
+      case command
+      when /^(?:elsif|elseif|else if) (.+)$/i
+        cmd.elsif($1)
+        true
+      when /^else|no|empty$/i
+        cmd.else
+        true
+      else
+        false
+      end
+    }
 
-          /^var ((\w+)(\.\w+\??)*)(\s+:\w+)?$/i       => ValueCommand,
-          /^--/i                                   => CommentCommand,
-          /^(if|unless) ((\w+)(\.\w+\??)*)$/i         => IfCommand,
-          /^(in|loop) ((\w+)(\.\w+\??)*)(:\s+\w+)?$/i => LoopCommand,
-          /^(include) ((\w+)(\.\w+\??)*)$/i           => IncludeCommand
-      )
+    # Command#end
+    # accepts 'end', 'end(name)' and 'end (name)'
+    modifier(:end) { |cmd,command|
+      case command
+      when /^end\s*(#{cmd.called_as})?$/i
+        cmd.end
+        true
+      else
+        false
+      end
+    }
+    # For case statements.
+    modifier(:when) { |cmd,command|
+      case command
+      when /^when\s+(\w(?:.\w+\??)*)$/i
+        cmd.when($1)
+        true
+      when /^else$/i
+        cmd.else($1)
+        true
+      else
+        false
+      end
+    }
+  end
 
   # Preprocessor is a parent class for preprocessors.
   # A preprocessor is used to process or otherwise prepare output for
@@ -249,7 +391,7 @@ class PageTemplate
   # keys: (with defaults)
   #
   #  'namespace' => A namespace object. (A new namespace)
-  #  'glossary'  => A SyntaxGlossary object. (a dup of DEFAULTGLOSSARY)
+  #  'glossary'  => A SyntaxGlossary class singleton. (DefaultGlossary)
   #  'preprocessor' => The preprocessor. (DefaultPreprocessor)
   #  'default_processor' => The processor. (:process)
   #  'source' => The Source for templates. (FileSource)
@@ -268,6 +410,12 @@ class PageTemplate
     attr_reader :preprocessor, :default_processor
     attr_reader :glossary, :namespace, :source
     attr_reader :args, :commands
+
+    # This is corny, but recent_parser returns the most recently created
+    # Parser.
+    def Parser.recent_parser
+      @@recent_parser
+    end
     # Parser.new() accepts a hash as an argument, and looks for these
     # keys: (with defaults)
     #
@@ -277,9 +425,11 @@ class PageTemplate
     #  'default_processor' => The processor. (:process)
     #  'source' => The Source for templates. (FileSource)
     def initialize(args = {})
+      @namespace    = self
+      @@recent_parser = self
       @args         = args # For sub-commands
-      @namespace    = args['namespace'] || Namespace.new
-      @glossary     = args['glossary'] || DEFAULTGLOSSARY.dup
+      @parent       = args['namespace'] || nil
+      @glossary     = args['glossary'] || DefaultGlossary
       @preprocessor = args['preprocessor'] || DefaultPreprocessor
       @default_processor = args['default_processor'] || :process
       @source       = (args['source'] || FileSource).new(@args)
@@ -304,6 +454,10 @@ class PageTemplate
     def parse(body)
       rx = @glossary.directive
       stack = [Template.new(self)]
+      stack[0].parent = self
+      last = stack.last
+      modifier = nil
+      closer = nil
       while (m = rx.match(body))
         pre = m.pre_match
         command = m[1].strip.gsub(/\s+/,' ')
@@ -316,31 +470,28 @@ class PageTemplate
 
         # If the command at the top of the stack is a 'Stacker',
         # Does this command modify it? If so, just skip back.
-        next if stack.last.modifies?(command)
+        next if modifier && @glossary.modifies?(modifier,last,command)
 
         # If it closes, we're done changing this. Pop it off the
         # Stack and add it to the one above it.
-        if stack.last.closes?(command)
+        if closer and @glossary.modifies?(closer,last,command)
           cmd = stack.pop
-          stack.last.add(cmd)
+          last = stack.last
+          last.add(cmd)
           next
         end
 
-        # Find what command it is.
+        # Create the command
         cmd = @glossary.lookup(command)
         
-        # If the command takes it, pass the parser.
-        block = if (cmd.instance_method(:initialize).arity == 2)
-          cmd.new(command,self)
-        else
-          cmd.new(command)
-        end
-
         # If it's a stacking command, push it on the stack
-        if block.is_a?(StackableCommand)
-          stack.push block
+        if cmd.is_a?(StackableCommand)
+          modifier = cmd.class.modifier
+          closer   = cmd.class.closer
+          stack.push cmd
+          last = cmd
         else
-          stack.last.add block
+          last.add cmd
         end
       end
       stack.last.add TextCommand.new(body) if body && body.length > 0
@@ -349,25 +500,22 @@ class PageTemplate
       end
       stack[0]
     end
+
+    # Since a Parser is also a namespace object, include NamespaceItem
+    include NamespaceItem
+    # But redefine parser
+    def parser
+      self
+    end
+
     # Not really of any point, but clears the saved commands.
     def clearCommands
       @commands = nil
     end
-    # Sets this parser's namespace values.
-    def []=(key,val)
-      @namespace[key] = val
-    end
-    # Gets this parser's namespace values.
-    def [](key)
-      @namespace[key]
-    end
     # If any commands are loaded and saved, return a string of it.
-    def output(namespace=nil)
+    def output(*args)
       return '' unless @commands
-      @namespace.parent = namespace if namespace
-      str = @commands.output(@namespace)
-      @namespace.parent = nil
-      str
+      @commands.output(*args)
     end
   end
 end