PageTemplate 2.0.0 → 2.1.0

data/Changes

@@ -1,3 +1,23 @@
+2.1
+    Commands:
+      Changed: IfCommand now accepts elseif, elsif, else if.
+      Changed: LoopCommand accepts multiple iterators.
+      Changed: Commands don't accept 'commandname arguments' syntax
+      Changed: Commands take arguments they want: called_as, value, iterators
+      Changed: Commands no longer recieve parsers on initialize
+      Changed: Commands can access parser via namespace.parser
+      Removed: modifies? and closes?
+      Added: @modifier = sym, @closer = sym. These are syms for the
+             SyntaxGlossary's lookups for else, when, end, etc.
+    Parser:
+      Added: NamespaceItem module
+      Changed: Namespace is now just an includer of NamespaceItem
+      Changed: Parser and Templare are now both NamespaceItems
+      Changed: Namespace#get returns an error message instead of erroring.
+      Changed: obj.accessor now also has obj.arrayindex and obj.hashkey
+      Changed: SyntaxGlossary is now a singleton, and is more flexible.
+      Added: htglossary.rb, providing an HTML::Template HTGlossary
+      Fixed: Parser#load() accepts full path names now
 2.0
     Major changes:
       Entire code refactored and rewritten.

data/Rakefile

@@ -39,6 +39,11 @@ task :install do
   ruby %{setup.rb}
 end
 
+task :uninstall do
+  puts "This is only set up for Brian's machine"
+  sh %{rm -rf /usr/local/lib/ruby/site_ruby/1.8/PageTemplate}
+end
+
 task :doc do
   sh %{rdoc lib/PageTemplate.rb README.txt lib/PageTemplate/*.rb}
 end
@@ -49,7 +54,7 @@ end
 
 spec = Gem::Specification.new do |s|
   s.name = "PageTemplate"
-  s.version = "2.0.0"
+  s.version = "2.1.0"
   s.author = "Brian Wisti"
   s.email  = "brianwisti@rubyforge.org"
   s.homepage = "http://coolnamehere.com/products/pagetemplate"

data/lib/PageTemplate.rb

@@ -20,8 +20,8 @@
 
 ############################################################
 
-require 'PageTemplate/commands'
 require 'PageTemplate/parser'
+require 'PageTemplate/commands'
 
 # PageTemplate is just the namespace for all of its real code, so as
 # not to caues confusion or clashes with the programmer's code.

data/lib/PageTemplate/case.rb

@@ -14,15 +14,16 @@ class PageTemplate
   # [% else %]
   # [% end %]
   class CaseCommand < StackableCommand
-    attr_reader :current_case
+    @modifier = :when
+    @closer   = :end
 
+    attr_reader :current_case
     # +command+ is a variable that is evaluated against the namespace
     # on execution, and then tested against the literals of when. It
     # must return a string literal.
-    def initialize(command)
-      /^case ((\w+)(\.\w+)*)$/i =~ command
+    def initialize(value)
       @called_as = 'case'
-      @value = $1
+      @value = value
       @blocks = {}
       @current_case = nil
       @default = BlockCommand.new
@@ -36,23 +37,18 @@ class PageTemplate
       end
     end
     # 'when' and 'else' modify this command.
-    def modifies?(cmd)
-      case cmd
-      when /^when (.+)$/
-        @current_case = $1
-        @blocks[$1] = BlockCommand.new unless @blocks.has_key?($1)
-        true
-      when /^else$/
-        @current_case = nil
-        true
-      else
-        false
-      end
+    def when(value)
+      @current_case = value
+      @blocks[value] = BlockCommand.new unless @blocks.has_key?(value)
+    end
+    def else
+      @current_case = nil
+      return true
     end
     # If namespace.get(@value) exists in the 'when' clauses, then
     # print out that block.
     def output(namespace=nil)
-      val = namespace.get(@value)
+      val = namespace.get(@value,false)
       if @blocks.has_key?(val)
         @blocks[val].output(namespace)
       else
@@ -68,5 +64,12 @@ class PageTemplate
       str << " ]"
     end
   end
-  DEFAULTGLOSSARY.define(/^case (\w+)(\.\w+)*$/,CaseCommand)
+  DefaultGlossary.define(/^case (\w+(?:\.\w+)*)$/) { |match,parser|
+    CaseCommand.new(match[1])
+  }
+  if PageTemplate.constants.include? 'HTGlossary'
+    HTGlossary.define(/^tmpl_case (?:NAME=)?(\w+(?:\.\w+\?)*)$/) { |m,parser|
+      CaseCommand.new(m[1])
+    }
+  end
 end

data/lib/PageTemplate/commands.rb

@@ -13,6 +13,10 @@ class PageTemplate
   # between each class. Command provides an abstract base class to show
   # interface.
   class Command
+    attr_reader :called_as
+    class << self
+      attr_reader :modifier, :closer
+    end
 
     # Subclasses of Command use the output method to generate their text
     # output.  +namespace+ is a Namespace object, which may be 
@@ -58,27 +62,18 @@ class PageTemplate
     # If the command that UnknownCommand is set to exists, find out if
     # the command exists in the Parser's glossary.
     def output(namespace)
-      cls = @parser.glossary.lookup(@command)
-      case
-      when cls == UnknownCommand
+      cls = namespace.parser.glossary.lookup(@command)
+      case cls
+      when UnknownCommand
         "[ Unknown Command: #{@command} ]"
-      when cls.is_a?(Class)
-        if cls.instance_method(:initialize).arity == 2
-          cls.new(@command,@parser).output(namespace)
-        else
-          cls.new(@command).output(namespace)
-        end
       else
-        p = cls.dup
-        p.set_command @command
-        p.output(namespace)
+        cls.output(namespace)
       end
     end
     # Save the +command+ and the +parser+, so we can look it
     # up and hopefully 
-    def initialize(command,parser)
+    def initialize(command)
       @command = command
-      @parser  = parser
     end
     def to_s
       "[ UnknownCommand: #{@command} ]"
@@ -92,28 +87,21 @@ class PageTemplate
   # StackableCommand. Also recommended is setting @called_as, so 
   # all of StackableCommand's ways of closing blocks work.
   class StackableCommand < Command
+    @modifier = nil
+    @closer   = :end
+
+    def end
+    end
+
     # @called_as is set to the command which this is called as. This
     # allows a number of [% end %], [% end name %], [% endname %] or
     # even [% /name %] to close StackableCommands.
-    def initialize(command=nil)
-      @called_as = 'stackable'
+    def initialize(called_as=nil)
       raise ArgumentError, 'StackableCommand should not be called directly'
     end
     def add(block)
       raise ArgumentError, 'StackableCommand should not be called directly'
     end
-    # Does +command+ modify this StackableCommand? If this is true,
-    # PageTemplate will not lookup +command+, and instead continue on
-    # to what it next finds, it will be ignored and skipped by the
-    # PageTemplate compiler. It is up to the child to make the
-    # modifications caused by +command+.
-    def modifies?(command)
-      false
-    end
-    # Does +command+ close this StackableCommand? If 
-    def closes?(command)
-      /^(end|\/)\s*(#{@called_as})?$/ =~ command
-    end
     def to_s
       "[ #{@called_as} ]"
     end
@@ -164,52 +152,43 @@ class PageTemplate
   # Template should only be called by the Parser, and never
   # by anything else.
   class Template < BlockCommand
+    @modifier = nil
+    @closer   = nil
     # Template must know about the parser so it can access its
     # namespace.
     def initialize(parser)
       @parser = parser
-      @namespace = Namespace.new
       super()
     end
     def to_s
       '[ Template: ' + @commandBlock.map{ |i| "[#{i.to_s}]" }.join(' ') + ']'
     end
+
+    # Template is also a NamespaceItem
+    include NamespaceItem
+
     # Template#output is a special case for a Command. Because
     # Template is what's returned by Parser.load() or Parser.parse(),
     # the programmer may well call Template#output(anything).
     #
     # If +object+ is a Namespace, then treat output as a typical
     # BlockCommand. If +object+ is nil, then namespace is
-    # @parser.namespace. Otherwise, a new namespace is created, a
+    # @parser. Otherwise, a new namespace is created, a
     # child of @namespace, and is assigned +object+ as its namespace
     def output(object=nil)
-      @namespace.parent = @parser.namespace
+      @parent = @parser
       case
-      when object.is_a?(Namespace)
-        @namespace.parent = object
-        super(@namespace)
       when object.nil?
-        super(@namespace)
+        super(self)
+      when object.is_a?(NamespaceItem)
+        @parent = object
+        super(self)
       else
-        namespace = Namespace.new(@namespace)
+        namespace = Namespace.new(self)
         namespace.object = object
         super(namespace)
       end
     end
-    def [](key)
-      @namespace[key]
-    end
-    def []=(key,val)
-      @namespace[key] = val
-    end
-    # This is used as a top-level in the stack, so is always false.
-    def modifies?(cmd)
-      false
-    end
-    # This is used as a top-level in the stack, so is always false.
-    def closes?(cmd)
-      false
-    end
   end
 
   # A very simple Command which outputs a static string of text
@@ -248,23 +227,20 @@ class PageTemplate
     # to be inserted during output. +parser+ is the Parser object,
     # which we save so we can access its Preprocessor and its default
     # preprocessor
-    def initialize(cmd,parser)
-      @parser = parser
-      if /^(?:var )?((?:\w+)(?:\.\w+\??)*)(?:\s+:(\w+))?$/i =~ cmd
-        @value = $1
-        @processor = $2
-      else
-        raise ArgumentError, "ValueCommand.new('#{cmd}') - invalid syntax"
-      end
+    def initialize(value,preprocessor)
+      @value = value
+      @processor = preprocessor
     end
 
     # Requests the value of this object's saved value name from 
     # +namespace+, and returns the string representation of that
     # value to the caller, after passing it through the preprocessor.
     def output(namespace = nil)
-      namespace ||= @parser.namespace
-      preprocessor = @parser.preprocessor
-      processor = @processor || @parser.default_processor
+      parser = namespace.parser if namespace
+      parser = Parser.recent_parser unless parser
+      namespace ||= parser
+      preprocessor = parser.preprocessor
+      processor = @processor || parser.default_processor
       if preprocessor.respond_to?(processor)
         preprocessor.send(processor,namespace.get(@value).to_s)
       else
@@ -290,55 +266,60 @@ class PageTemplate
   # objects are added to @falseCommands, and are printed if +variable+
   # is false, instead.
   class IfCommand < StackableCommand
+    @modifier = :elsif
+    @closer   = :end
+
     # +command+ must match "if <value>" or "unless <value>"
-    def initialize(command)
-      if /^(unless|if) (\w+(\.\w+\??)*)$/i =~ command
-        @called_as = $1
-        @value = $2
-        @trueCommands = BlockCommand.new
-        @falseCommands = BlockCommand.new
-        @in_else = ($1 == 'unless')
-        @switched = false
-      else
-        raise ArgumentError, "IfCommand.new('#{command}') - invalid syntax"
-      end
+    def initialize(called_as, value)
+      @value = value
+      @called_as = called_as
+      @trueCommands = []
+      @trueCommands << [value,BlockCommand.new]
+      @falseCommands = BlockCommand.new
+      @in_else = (called_as == 'unless')
+      @switched = false
     end
     # Add the command to the @trueCommands or @falseCommands block,
     # depending on if the command is an 'if' or 'unless' and if 'else'
     # has been called.
     def add(command)
       unless @in_else
-        @trueCommands.add command
+        @trueCommands.last.last.add command
       else
         @falseCommands.add command
       end
     end
+    # an elseif will create a new condition.
+    def elsif(value)
+      raise Argumentrror, "'elsif' cannot be passed after 'else' or in an 'unless'" if @switched || @in_else
+      @trueCommands << [value,BlockCommand.new]
+    end
     # an 'else' will modify the command, switching it from adding to
     # @trueCommands to adding to @falseCommands, or vice versa.
-    def modifies?(cmd)
-      if cmd =~ /^else$/i
-        raise ArgumentError, "More than one 'else' to IfCommand" if @switched
-        @in_else = ! @in_else
-        @switched = true
-        true
-      else
-        false
-      end
+    def else
+      raise ArgumentError, "More than one 'else' to IfCommand" if @switched
+      @in_else = ! @in_else
+      @switched = true
     end
     # If @value is true within the context of +namespace+, then print
     # the output of @trueCommands. Otherwise, print the output of
     # @falseCommands
     def output(namespace=nil)
-      if namespace.true?(@value)
-        @trueCommands.output(namespace)
-      else
-        @falseCommands.output(namespace)
+      val = ''
+      @trueCommands.each do |val,commands|
+        return commands.output(namespace) if namespace.true?(val)
       end
+      @falseCommands.output(namespace)
     end
     def to_s
-      str = ''
+      str = '['
       if @called_as == 'if'
-        str = "[ If (#{@value}): #{@trueCommands}"
+        str = ' If'
+        label = ' If'
+        str += @trueCommands.map { |val,commands|
+          s = "#{label} (#{val}) #{commands}"
+          label = ' Elsif'
+        }.join('')
         if @falseCommands.length > 0
           str << " else: #{@falseCommands}"
         end
@@ -369,32 +350,26 @@ class PageTemplate
   # [% else %] may be specified, modifying LoopCommand to print out
   # @elseCommands in case +variable+ is false, or empty.
   class LoopCommand < StackableCommand
+    @modifier = :else
+    @closer   = :end
+
     # [% in variable %] or [% loop variable %]
     # Or [% in variable: name %]
-    def initialize(cmd)
-      if /^(in|loop) (\w+(?:\.\w+\??)*)(?:\:\s+(\w+))?$/i =~ cmd
-        @called_as = $1
-        @value = $2
-        @iterator = $3
-        @switched = false
-        @commands = BlockCommand.new
-        @elseCommands = BlockCommand.new
-        @in_else = false
-      else
-        raise ArgumentError, "LoopCommand.new('#{cmd}') - invalid syntax"
-      end
+    def initialize(called_as, value, iterators)
+      @called_as = called_as
+      @value     = value
+      @iterators = iterators.strip.gsub(/\s+/,' ').split if iterators
+      @switched  = false
+      @commands  = BlockCommand.new
+      @elseCommands = BlockCommand.new
+      @in_else = false
     end
     # An 'else' defines a list of commands to call when the loop is
     # empty.
-    def modifies?(cmd)
-      if cmd =~ /^else|no|empty$/i
-        raise ArgumentError, "More than one 'else' to IfCommand" if @switched
-        @in_else = ! @in_else
-        @switched = true
-        true
-      else
-        false
-      end
+    def else
+      raise ArgumentError, "More than one 'else' to IfCommand" if @switched
+      @in_else = ! @in_else
+      @switched = true
     end
     # adds to @commands for the loop, or @elseCommands if 'else' has
     # been passed.
@@ -430,17 +405,46 @@ class PageTemplate
       ns = Namespace.new(namespace)
 
       # Print the output of all the objects joined together.
-      vals.map { |item|
-        ns.clear_cache
-        ns.object = item
-        ns['__FIRST__'] = (i == 1) ? true : false
-        ns['__LAST__'] = (i == len) ? true : false
-        ns['__ODD__'] = odd
-        ns[@iterator] = item if @iterator
-        odd = ! odd
-        i += 1
-        @commands.output(ns)
-      }.join('')
+      case
+      when @iterators.nil? || @iterators.empty?
+        vals.map { |item|
+          ns.clear
+          ns.object = item
+          ns['__FIRST__'] = (i == 1) ? true : false
+          ns['__LAST__'] = (i == len) ? true : false
+          ns['__ODD__'] = odd
+          odd = ! odd
+          i += 1
+          @commands.output(ns)
+        }.join('')
+      when @iterators.size == 1
+        iterator = @iterators[0]
+        vals.map { |item|
+          ns.clear_cache
+          # We have an explicit iterator - don't set an object for it.
+          # ns.object = item
+          ns['__FIRST__'] = (i == 1) ? true : false
+          ns['__LAST__'] = (i == len) ? true : false
+          ns['__ODD__'] = odd
+          odd = ! odd
+          ns[iterator] = item
+          i += 1
+          @commands.output(ns)
+        }.join('')
+      else
+        vals.map { |list|
+          ns.clear_cache
+          ns['__FIRST__'] = (i == 1) ? true : false
+          ns['__LAST__'] = (i == len) ? true : false
+          ns['__ODD__'] = odd
+          @iterators.each_with_index do |iterator,index|
+            ns[iterator] = list[index]
+          end
+          odd = ! odd
+          i += 1
+          @commands.output(ns)
+        }.join('')
+      end
     end
     
     def to_s
@@ -464,13 +468,8 @@ class PageTemplate
   # The body returned by the Source is then passed to Parser for
   # compilation.
   class IncludeCommand < Command
-    def initialize(cmd,parser)
-      if /^include ((\w+)(\.\w+\??)*)$/i =~ cmd
-        @value = $1
-        @parser = parser
-      else
-        raise ArgumentError, "IncludeCommand.new('#{cmd}') - invalid syntax"
-      end
+    def initialize(value)
+      @value = value
     end
     def to_s
       "[ Include: #{@value} ]"
@@ -483,15 +482,16 @@ class PageTemplate
     # The body returned by the Source is then passed to Parser for
     # compilation.
     def output(namespace)
-      # We don't use @parser.compile because we need to know when something
+      # We don't use parser.compile because we need to know when something
       # doesn't exist.
-      body = @parser.source.get(@value)
+      parser = namespace.parser
+      body = parser.source.get(@value)
       unless body
         fn = namespace.get(@value)
-        body = @parser.source.get(fn) if fn
+        body = parser.source.get(fn) if fn
       end
       if body
-        @parser.parse(body).output(namespace)
+        parser.parse(body).output(namespace)
       else
         "[ Template '#{fn || @value}' not found ]"
       end