deplate 0.7.3 → 0.8

data/lib/deplate/cache.rb

@@ -3,23 +3,69 @@
 # @Website:     http://deplate.sf.net/
 # @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
 # @Created:     21-Aug-2005.
-# @Last Change: 23-Okt-2005.
-# @Revision:    0.25
+# @Last Change: 08-Apr-2006.
+# @Revision:    0.46
 
 # = Description
 # This class provides a cache for dynamically generated classes.
 class Deplate::Cache
     @@custom_particles = {}
+    @@custom_macros    = {}
+    @@custom_elements  = {}
+    @@custom_regions   = {}
+    @@custom_commands  = {}
 
     attr_reader :cls
  
     class << self
         def particle(deplate, body, args)
             register = args[:register]
-            new(@@custom_particles, Deplate::Particle, deplate, body, args) do |cls|
+            parent   = args[:super] || Deplate::Particle
+            new(@@custom_particles, parent, deplate, body, args) do |cls|
                 if register
                     args[:id] = body
-                    deplate.register_particle(cls, args)
+                    deplate.input.register_particle(cls, args)
+                end
+            end
+        end
+
+        def element(deplate, body, args)
+            register = args[:register]
+            parent   = args[:super] || Deplate::Element
+            new(@@custom_elements, parent, deplate, body, args) do |cls|
+                if register
+                    args[:id] = body
+                    deplate.input.register_element(cls, args)
+                end
+            end
+        end
+
+        def command(deplate, body, args)
+            register = args[:register]
+            parent   = args[:super] || Deplate::Command
+            new(@@custom_commands, parent, deplate, body, args) do |cls|
+                if register
+                    deplate.input.register_command(cls, args)
+                end
+            end
+        end
+
+        def region(deplate, body, args)
+            register = args[:register]
+            parent   = args[:super] || Deplate::Region
+            new(@@custom_regions, parent, deplate, body, args) do |cls|
+                if register
+                    deplate.input.register_region(cls, args)
+                end
+            end
+        end
+
+        def macro(deplate, body, args)
+            register = args[:register]
+            parent   = args[:super] || Deplate::Region
+            new(@@custom_macros, parent, deplate, body, args) do |cls|
+                if register
+                    deplate.input.register_macro(cls, args)
                 end
             end
         end
@@ -32,7 +78,11 @@ class Deplate::Cache
         retrieve_particle(body, specific)
         unless @cls
             @cls = Class.new(super_class)
-            @cls.class_eval(body)
+            if body.kind_of?(Proc)
+                @cls.class_eval(&body)
+            else
+                @cls.class_eval(body)
+            end
             store_particle(body, specific)
         end
         if @cls and block_given?

data/lib/deplate/commands.rb

@@ -3,8 +3,8 @@
 # @Website:     http://deplate.sf.net/
 # @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
 # @Created:     08-Mai-2004.
-# @Last Change: 02-Nov-2005.
-# @Revision:    0.932
+# @Last Change: 02-Mai-2006.
+# @Revision:    0.1164
 
 # Description:
 # 
@@ -40,15 +40,20 @@ class Deplate::Command < Deplate::Element
             @@commands
         end
 
+        def register_as(name, c=self)
+            @@commands[name] = self
+        end
+
         def update_variables(hash, opts, args)
             if args
-                d = args["date"]
-                args["date"] = get_date(d, args) if d
-                if opts["add"]
-                    if opts["add"].kind_of?(String)
-                        sep = opts["add"]
+                opts ||= {}
+                d = args['date']
+                args['date'] = get_date(d, args) if d
+                if opts['add']
+                    if opts['add'].kind_of?(String)
+                        sep = opts['add']
                     else
-                        sep = " "
+                        sep = ' '
                     end
                     args.each_pair do |k,v|
                         if hash[k]
@@ -60,14 +65,13 @@ class Deplate::Command < Deplate::Element
                     hash.update(args)
                 end
             else
-                Deplate::Core.log(["No arguments", opts], :error, src)
+                Deplate::Core.log(['No arguments', opts], :error, src)
             end
         end
     end
     
     def setup(args, cmd)
-        @multiliner = false
-        @collapse   = false
+        # @collapse   = false
         @name       = cmd
         @accum      = [@text]
         @can_be_labelled = false
@@ -91,26 +95,23 @@ class Deplate::Command < Deplate::Element
     end
 
     def format_special
-        format_unknown(self)
+        @deplate.formatter.format_unknown(self)
     end
 end
 
 
 class Deplate::Command::CAP < Deplate::Command
-    @@commands["CAP"] = self
-    @@commands["CAPTION"] = self
+    register_as 'CAP'
+    register_as 'CAPTION'
 
     class << self
         def accumulate(src, array, deplate, text, match, args, cmd)
-            Deplate::Core.log("%s: %s" % [cmd, text], :debug)
-            elt           = deplate.parse_with_source(src, text, false)
-            last          = array.last
-            if last.caption
-                Deplate::Core.log('Element already has a caption', :error, src)
+            Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
+            last = array.last
+            if last
+                last.set_caption(Deplate::CaptionDef.new(text, args, src))
             else
-                last.level_as_string = deplate.get_current_heading
-                last.caption  = Deplate::CaptionDef.new(elt, args)
-                last.register_caption
+                Deplate::Core.log(["Can't attach caption to", nil], :error, src)
             end
         end
     end
@@ -118,23 +119,23 @@ end
 
 
 class Deplate::Command::LANG < Deplate::Command
-    @@commands["LANG"]     = self
-    @@commands["LANGUAGE"] = self
+    register_as 'LANG'
+    register_as 'LANGUAGE'
+    self.volatile = true
     
     def self.accumulate(src, array, deplate, text, match, args, cmd)
-        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
         deplate.set_lang(text)
     end
 end
 
 
 class Deplate::Command::INC < Deplate::Command
-    @@commands["INC"]     = self
-    @@commands["INCLUDE"] = self
+    register_as 'INC'
+    register_as 'INCLUDE'
     
     def self.accumulate(src, array, deplate, text, match, args, cmd)
-        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
-        formatter_name = deplate.formatter.formatter_name
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
         doc = args['doc'] || args['var'] || args['val']
         if args.has_key?('file')
             if text
@@ -164,39 +165,17 @@ class Deplate::Command::INC < Deplate::Command
                 if strings
                     deplate.include_stringarray(strings, array, nil, src.file)
                 else
-                    Deplate::Core.log(["Unknown doc variable", doc], :error, src)
+                    Deplate::Core.log(['Unknown doc variable', doc], :error, src)
                 end
             elsif !text or text == ''
-                Deplate::Core.log(["Malformed command", cmd, text], :error, src)
+                Deplate::Core.log(['Malformed command', cmd, text], :error, src)
             else
-                pwd  = File.dirname(deplate.current_source || "")
-                dirs = [
-                    File.join(pwd, "deplate.rc", formatter_name, text),
-                    File.join(pwd, "deplate.rc", text),
-                    File.join(pwd, text),
-                ]
-                dirs += Deplate::Core.library_directories("lib", formatter_name, text)
-                dirs += Deplate::Core.library_directories("lib", text)
-                dirs += Deplate::Core.library_directories(text)
-                # dirs = [
-                #     File.join(pwd, "deplate.rc", formatter_name, text),
-                #     File.join(pwd, "deplate.rc", text),
-                #     File.join(pwd, text),
-                #     File.join(Deplate::Core::CfgDir, "lib", formatter_name, text),
-                #     File.join(Deplate::Core::CfgDir, "lib", text),
-                #     File.join(Deplate::Core::CfgDir, text), 
-                #     File.join(Deplate::Core::LibDir, "lib", formatter_name, text),
-                #     File.join(Deplate::Core::LibDir, "lib", text),
-                #     File.join(Deplate::Core::DataDir, "lib", formatter_name, text),
-                #     File.join(Deplate::Core::DataDir, "lib", text),
-                # ]
-                for fn in dirs
-                    if !File.directory?(fn) and File.exists?(fn)
-                        deplate.include_file(array, fn)
-                        return
-                    end
+                fn = deplate.find_in_lib(text, :pwd => true)
+                if fn
+                    deplate.include_file(array, fn)
+                else
+                    Deplate::Core.log(['File not found', text], :error, src)
                 end
-                Deplate::Core.log(["File not found", text], :error, src)
             end
         ensure
             deplate.variables['embeddedTextRx']   = embeddedTextRx_orig if embeddedTextRx
@@ -208,28 +187,62 @@ class Deplate::Command::INC < Deplate::Command
 end
 
 
-class Deplate::Command::DOC < Deplate::Command
-    @@commands["DOC"] = self
-    @@commands["VAR"] = self
-    def self.accumulate(src, array, deplate, text, match, args, cmd)
-        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
-        opts, text = deplate.input.parse_args(text, nil, false)
-        for k, v in opts
-            deplate.register_metadata(src, 
-                                      "type"  => "variable", 
-                                      "name"  => k,
-                                      "value" => v
-                                     )
+class Deplate::Command::VAR < Deplate::Command
+    register_as 'DOC'
+    register_as 'VAR'
+    self.volatile = true
+
+    class << self
+        def set_variable(deplate, var, value, args={}, src=nil)
+            if deplate.input.allow_set_variable(var)
+                deplate.register_metadata(src, 
+                                          'type'  => 'variable', 
+                                          'name'  => var,
+                                          'value' => value
+                                         )
+                update_variables(deplate.variables, args, var => value)
+                return true
+            else
+                Deplate::Core.log(['Disabled', var], :error, src)
+                return false
+            end
+        end
+        
+        def accumulate(src, array, deplate, text, match, args, cmd)
+            Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
+            id = args['id']
+            if id
+                if deplate.input.allow_set_variable(id)
+                    set_variable(deplate, id, text, args, src)
+                end
+            else
+                opts, text = deplate.input.parse_args(text, nil, false)
+                for k, v in opts
+                    unless set_variable(deplate, k, v, args, src)
+                        opts.delete(k)
+                    end
+                end
+            end
         end
-        update_variables(deplate.variables, args, opts)
+    end
+end
+
+
+class Deplate::Command::KEYWORDS < Deplate::Command::VAR
+    register_as 'KEYWORDS'
+    self.volatile = true
+    def self.accumulate(src, array, deplate, text, match, args, cmd)
+        args['id'] = 'keywords'
+        super
     end
 end
 
 
 class Deplate::Command::OPT < Deplate::Command
-    @@commands["OPT"] = self
+    register_as 'OPT'
+    self.volatile = true
     def self.accumulate(src, array, deplate, text, match, args, cmd)
-        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
         elt = array.last
         if elt
             opts, text = deplate.input.parse_args(text, nil, false)
@@ -244,25 +257,25 @@ end
 
 
 class Deplate::Command::PUT < Deplate::Command
-    @@commands["PUT"] = self
-    @@commands["CLIP"] = self
-    @@commands["SET"] = self
+    register_as 'PUT'
+    register_as 'CLIP'
+    register_as 'SET'
     def self.accumulate(src, array, deplate, text, match, args, cmd)
-        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
         id = args["id"]
         if id
             text = deplate.parse_with_source(src, text, false)
             deplate.set_clip(id, Deplate::Element::Clip.new(text, deplate, src))
         else
-            Deplate::Core.log(["No clip-id given", text], :error, src)
+            Deplate::Core.log(["No ID given", text], :error, src)
         end
     end
 end
 
 
 class Deplate::Command::GET < Deplate::Command
-    @@commands["GET"] = self
-    @formatter = :format_GET
+    register_as 'GET'
+    set_formatter :format_GET
     
     def setup_command
         @id = @args["id"] || @accum[0]
@@ -281,13 +294,16 @@ end
 
 
 class Deplate::Command::XARG < Deplate::Command
-    @@commands["XARG"] = self
-    @@commands["XVAL"] = self
+    register_as 'XARG'
+    register_as 'XVAL'
+    self.volatile = true
     
     def setup_command
         id = args["id"] || @accum[0]
-        @elt = @deplate.variables[id]
+        @elt = @deplate.variables[id] || @args["default"]
         if @elt
+            @elt = Deplate::Core.escape_characters(@elt, @args)
+            @elt = post_process_text(@elt)
             @elt = @elt.split(/[\n\r]/).each {|l| l.chomp!}
         else
             log(["Unknown variable", id, @name], :error)
@@ -301,21 +317,25 @@ end
 
 
 class Deplate::Command::ARG < Deplate::Command
-    @@commands["ARG"] = self
-    @@commands["VAL"] = self
+    register_as 'ARG'
+    register_as 'VAL'
+    self.volatile = true
 
     class << self
         def accumulate(src, array, deplate, text, match, args, cmd)
-            Deplate::Core.log("%s: %s" % [cmd, text], :debug)
-            id = args["id"] || text
-            val = deplate.variables[id]
+            Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
+            id = args['id'] || text
+            val = deplate.variables[id] || args['default']
             if val
+                val = Deplate::Core.escape_characters(val, args)
+                val = Deplate::CommonGround.post_process_text(val, args)
+                # val.gsub!(/\\/, '\\\\\\\\')
                 acc = val.split(/[\n\r]/)
                 acc.each {|l| l.chomp!}
                 d = deplate.options.master ? deplate.options.master : deplate
                 d.include_stringarray(acc, array, src.begin, src.file)
             else
-                Deplate::Core.log(["Unknown variable", id, cmd], :error, src)
+                Deplate::Core.log(['Unknown variable', id, cmd], :error, src)
             end
         end
     end
@@ -323,10 +343,11 @@ end
 
 
 class Deplate::Command::BIB < Deplate::Command
-    @@commands["BIB"] = self
+    register_as 'BIB'
+    self.volatile = true
     class << self
         def accumulate(src, array, deplate, text, match, args, cmd)
-            Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+            Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
             bibs = text.strip.split(/\s*\|\s*/)
             deplate.options.bib += bibs
             deplate.formatter.read_bib(bibs)
@@ -336,10 +357,11 @@ end
 
 
 class Deplate::Command::TITLE < Deplate::Command
-    @@commands["TITLE"] = self
-    @@commands["TI"] = self
+    register_as 'TITLE'
+    register_as 'TI'
+    self.volatile = true
     def self.accumulate(src, array, deplate, text, match, args, cmd)
-        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
         c = deplate.parse_with_source(src, text, false)
         deplate.set_clip("title", Deplate::Element::Clip.new(c, deplate, src))
         deplate.register_metadata(src, 
@@ -352,11 +374,12 @@ end
 
 
 class Deplate::Command::AUTHOR < Deplate::Command
-    @@commands["AUTHOR"] = self
-    @@commands["AU"] = self
+    register_as 'AUTHOR'
+    register_as 'AU'
+    self.volatile = true
     class << self
         def accumulate(src, array, deplate, text, match, args, cmd)
-            Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+            Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
             deplate.options.author ||= []
             for this in text.split(/([;\/]|\s+(&|and))\s+/)
                 unless this =~ /^\s*([;\/&]|and)\s*$/
@@ -391,10 +414,11 @@ end
 
 
 class Deplate::Command::AUTHORNOTE < Deplate::Command
-    @@commands["AUTHORNOTE"] = self
-    @@commands["AN"] = self
+    register_as 'AUTHORNOTE'
+    register_as 'AN'
+    self.volatile = true
     def self.accumulate(src, array, deplate, text, match, args, cmd)
-        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
         unless text.empty?
             author = deplate.options.author.last
             if author
@@ -403,7 +427,7 @@ class Deplate::Command::AUTHORNOTE < Deplate::Command
         end
         ans = deplate.options.author.collect {|h| h[:note]}
         sep = deplate.variables["authorSep"] || "; "
-        ans = ans.join(sep)
+        ans = ans.compact.join(sep)
         parsed = deplate.parse_with_source(src, ans, false)
         deplate.set_clip("authornote", Deplate::Element::Clip.new(parsed, deplate, src))
         deplate.register_metadata(src, 
@@ -416,9 +440,10 @@ end
 
 
 class Deplate::Command::DATE < Deplate::Command
-    @@commands["DATE"] = self
+    register_as 'DATE'
+    self.volatile = true
     def self.accumulate(src, array, deplate, text, match, args, cmd)
-        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
         d = get_date(text, args)
         c = deplate.parse_with_source(src, d, false)
         deplate.set_clip(cmd.downcase, Deplate::Element::Clip.new(c, deplate, src))
@@ -432,11 +457,11 @@ end
 
 
 class Deplate::Command::IMG < Deplate::Command
-    @@commands['IMG'] = self
-    @@commands['IMAGE'] = self
-    @@commands['FIG'] = self
-    @@commands['FIGURE'] = self
-    @formatter = :format_IMG
+    register_as 'IMG'
+    register_as 'IMAGE'
+    register_as 'FIG'
+    register_as 'FIGURE'
+    set_formatter :format_IMG
 
     def register_caption
         register_figure
@@ -445,25 +470,97 @@ end
 
 
 class Deplate::Command::MAKETITLE < Deplate::Command
-    @@commands['MAKETITLE'] = self
-    @formatter = :format_title
+    register_as 'MAKETITLE'
+    set_formatter :format_title
 end
 
 
 class Deplate::Command::MAKEBIB < Deplate::Command
-    @@commands['MAKEBIB'] = self
-    @formatter = :format_MAKEBIB
+    register_as 'MAKEBIB'
+    set_formatter :format_MAKEBIB
+    def setup_command
+        unless @text.nil? or @text.empty? or @deplate.variables['bibStyle']
+            log(['Setting variable', 'bibStyle', @text], :anyway)
+            @deplate.variables['bibStyle'] = @text
+        end
+    end
 end
 
 
 class Deplate::Command::LIST < Deplate::Command
-    @@commands['LIST'] = self
-    @formatter = :format_LIST
+    register_as 'LIST'
+    set_formatter :format_LIST
+end
+
+class Deplate::Command::DEFLIST < Deplate::Command
+    register_as 'DEFLIST'
+    self.volatile = true
+    def self.accumulate(src, array, deplate, text, match, args, cmd)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
+        list = args['id'] || args['list'] || text
+        deplate.options.listings.def_listing(list, nil, args)
+        i = deplate.current_heading
+        p = args['parent']
+        deplate.options.counters.def_counter(list, :parent => p)
+    end
+end
+
+class Deplate::Command::REGISTER < Deplate::Command
+    register_as 'REGISTER'
+    self.volatile = true
+    def self.accumulate(src, array, deplate, text, match, args, cmd)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
+        list = args['id'] || args['list']
+        if list
+            elt = array.last
+            if elt
+                name = args['name'] || text
+                if name and !name.empty?
+                    cap = Deplate::CaptionDef.new(name, args, src)
+                    elt.set_caption(cap)
+                end
+                elt.register_in_listing(list, args)
+                return
+            end
+        end
+        Deplate::Core.log(['Nothing to register', list], :error, src)
+    end
+end
+
+
+class Deplate::Command::DEFCOUNTER < Deplate::Command
+    register_as 'DEFCOUNTER'
+    self.volatile = true
+    def self.accumulate(src, array, deplate, text, match, args, cmd)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
+        c = args['id'] || args['counter'] || text
+        # i = deplate.current_heading
+        p = args['parent']
+        deplate.options.counters.def_counter(c, :parent => p)
+    end
+end
+
+class Deplate::Command::COUNTER < Deplate::Command
+    register_as 'COUNTER'
+    self.volatile = true
+    def self.accumulate(src, array, deplate, text, match, args, cmd)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
+        c = args['id'] || args['counter'] || text
+        if args['reset']
+            # <+TBD+>
+        elsif (by = args['increase'])
+            by = by.to_i
+            l  = args['level']
+            # <+TBD+>
+        else
+            Deplate::Core.log(['#COUNTER', 'Missing directive'], :error, src)
+        end
+    end
 end
 
 
 class Deplate::Command::TABLE < Deplate::Command
-    @@commands['TABLE'] = self
+    register_as 'TABLE'
     def setup_command
         if File.exist?(@text)
             File.open(@text) {|io| @accum = io.read.split(/[\r\n]+/)}
@@ -473,14 +570,17 @@ class Deplate::Command::TABLE < Deplate::Command
     end
     
     def finish
-        return Deplate::Regions::Table.make_char_separated(self, @accum, @args['sep'])
+        rv = Deplate::Regions::Table.make_char_separated(self, @accum, @args['sep'])
+        rv.unify_props(self)
+        rv
     end
 end
 
 
 class Deplate::Command::IDX < Deplate::Command
-    @@commands['IDX'] = self
-    @formatter = :format_IDX
+    register_as 'IDX'
+    self.volatile = true
+    set_formatter :format_IDX
     
     class << self
         def accumulate(src, array, deplate, text, match, args, cmd)
@@ -512,7 +612,8 @@ class Deplate::Command::IDX < Deplate::Command
             auto  = args['auto']
             auto  = deplate.variables['autoindex'] if auto.nil?
             for i in text.split(/\s*;\s*/)
-                idx = deplate.add_index(nil, i, deplate.get_current_heading)
+                # <+TBD IDX+>idx = deplate.add_index(nil, i, deplate.get_current_heading)
+                idx = deplate.add_index(container, i)
                 Deplate::Particle.auto_indexing(deplate, idx) if auto
                 accum << idx
                 container.add_metadata(source,
@@ -546,10 +647,11 @@ end
 
 
 class Deplate::Command::AUTOIDX < Deplate::Command
-    @@commands["AUTOIDX"] = self
+    register_as 'AUTOIDX'
+    self.volatile = true
     def self.accumulate(src, array, deplate, text, match, args, cmd)
-        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
-        hd = deplate.get_current_heading
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
+        hd  = deplate.get_current_heading
         for i in text.split(/\s*;\s*/)
             Deplate::Particle.auto_indexing(deplate, deplate.add_index(nil, i, hd))
         end
@@ -558,9 +660,10 @@ end
 
 
 class Deplate::Command::NOIDX < Deplate::Command
-    @@commands["NOIDX"] = self
+    register_as 'NOIDX'
+    self.volatile = true
     def self.accumulate(src, array, deplate, text, match, args, cmd)
-        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
         for i in text.split(/\s*;\s*/)
             deplate.remove_index(self, i)
         end
@@ -569,26 +672,31 @@ end
 
 
 class Deplate::Command::DONTIDX < Deplate::Command
-    @@commands["DONTIDX"] = self
+    register_as 'DONTIDX'
+    self.volatile = true
     def self.accumulate(src, array, deplate, text, match, args, cmd)
-        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
         deplate.options.dont_index += text.split(/\s*;\s*/)
     end
 end
 
 
 class Deplate::Command::WITH < Deplate::Command
-    @@commands["WITH"] = self
+    register_as 'WITH'
     def self.accumulate(src, array, deplate, text, match, args, cmd)
-        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
         file = args["file"]
         body = nil
         if file
             File.open(file) {|io| body = io.readlines}
         else
-            arg = args["arg"]
+            arg = args["arg"] || args["var"]
             if arg
-                body = deplate.variables[arg].split(/[\n\r]/)
+                body = deplate.variables[arg]
+                case body
+                when String
+                    body = body.split(/[\n\r]/)
+                end
             end
         end
         if body
@@ -604,68 +712,97 @@ end
 
 
 class Deplate::Command::ABBREV < Deplate::Command
-    @@commands["ABBREV"] = self
+    register_as 'ABBREV'
+    self.volatile = true
     @@abbrevn = 0
-    
-    def self.accumulate(src, array, deplate, text, match, args, cmd)
-        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
-        rx  = nil
-        tx  = nil
-        cmd = nil
-        catch(:exit) do
-            w = args["word"] || args["w"] || args["wd"]
-            if w
-                rx = Regexp.new(%{\\b%s\\b} % Regexp.escape(w))
-                tx = "%{#{text}}"
-                throw :exit
-            end
-            s = args["symbol"] || args["sym"]
-            if s
-                rx = Regexp.new(%{`%s} % Regexp.escape(s))
-                tx = "%{#{text}}"
-                throw :exit
-            end
-            r = args["regexp"] || args["rx"]
-            if r
-                rx = Regexp.new(r)
-                tx = %{@match[0].gsub(/#{r}/, %{#{text}})}
-                throw :exit
+   
+    class << self
+        def accumulate(src, array, deplate, text, match, args, cmd)
+            Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
+            rx  = nil
+            rs  = nil
+            tx  = nil
+            cmd = nil
+            deplate.options.abbrevs ||= {}
+            catch(:exit) do
+                w = args['word'] || args['w'] || args['wd']
+                if w
+                    rs = %{\\b%s\\b} % Regexp.escape(w)
+                    # tx = "#{Deplate::Core.remove_backslashes(text.inspect)}"
+                    # tx = "#{text.inspect}"
+                    # tx = text.inspect
+                    tx = text
+                    throw :exit
+                end
+                s = args['symbol'] || args['sym']
+                if s
+                    rs = %{`%s} % Regexp.escape(s)
+                    # tx = "#{Deplate::Core.remove_backslashes(text.inspect)}"
+                    # tx = text.inspect
+                    tx = text
+                    throw :exit
+                end
+                r = args['regexp'] || args['rx']
+                if r
+                    rs = r
+                    tx = lambda {|p| p.match[0].gsub(Regexp.new(r), text)}
+                    throw :exit
+                end
             end
-        end
-        if rx
-            if args["plain"]
-                cmd = %{@deplate.formatter.plain_text(#{tx})}
-                specific = false
-            elsif args["native"] or args["ins"]
-                cmd = tx
-                specific = true
+            if rs
+                if args['plain']
+                    # cmd = %{@deplate.formatter.plain_text(#{tx})}
+                    cmd = lambda {|c, t| c.deplate.formatter.plain_text(t)}
+                    specific = false
+                elsif args['native'] or args['ins']
+                    cmd = tx
+                    specific = true
+                else
+                    # cmd = %{@deplate.parse_and_format(@container, #{tx}, false)}
+                    cmd = lambda {|c, t| c.deplate.parse_and_format(c, t, false)}
+                    specific = false
+                end
+                deplate.options.abbrevs[rs] = [tx, cmd]
+                rx = Regexp.new("^#{rs}")
+                # body = <<-EOR
+                #     set_rx(#{rx.inspect})
+                #     def setup
+                #         @elt = #{cmd}
+                #     end
+                # EOR
+                body = <<-EOR
+                    set_rx(#{rx.inspect})
+                    def setup
+                        tx, cmd = @deplate.options.abbrevs[#{rs.inspect}]
+                        case cmd
+                        when Proc
+                            tx   = tx.call(self) if tx.kind_of?(Proc)
+                            @elt = cmd.call(@container, tx)
+                        when String
+                            @elt = cmd
+                        else
+                            log(['Internal error', 'ABBREV', #{rs.inspect}, cmd.class], :error)
+                        end
+                    end
+                EOR
+                cls = Deplate::Cache.particle(deplate, body, 
+                                              :register => true,
+                                              :specific => specific
+                                             )
             else
-                cmd = %{@deplate.parse_and_format(@container, #{tx}, false)}
-                specific = false
+                Deplate::Core.log(["No pattern specified", args], :error, src)
             end
-            body = <<-EOR
-                @rx = /^#{rx}/
-                def setup
-                    @elt = #{cmd}
-                end
-            EOR
-            cls = Deplate::Cache.particle(deplate, body, 
-                                           :register => true,
-                                           :specific => specific
-                                          )
-        else
-            Deplate::Core.log(["No pattern specified", args], :error, src)
         end
     end
 end
 
 
 class Deplate::Command::MODULE < Deplate::Command
-    @@commands["MODULE"] = self
-    @@commands["MOD"] = self
+    register_as 'MODULE'
+    register_as 'MOD'
     class << self
         def accumulate(src, array, deplate, text, match, args, cmd)
-            Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+            Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
             deplate.require_module(text)
             deplate.call_methods_matching(deplate, /^hook_late_require_/)
             # deplate.initialize_particles(false, :always => true)
@@ -675,11 +812,11 @@ end
 
 
 class Deplate::Command::LTX < Deplate::Command
-    @@commands["LTX"] = self
-    @@commands["INLATEX"] = self
+    register_as 'LTX'
+    register_as 'INLATEX'
     class << self
         def accumulate(src, array, deplate, text, match, args, cmd)
-            Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+            Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
             m = []
             m[Deplate::Element::Region.rxi_name]   = 'Ltx'
             m[Deplate::Element::Region.rxi_args]   = match[2] 
@@ -691,3 +828,29 @@ class Deplate::Command::LTX < Deplate::Command
     end
 end
 
+class Deplate::Element::PAGE < Deplate::Command
+    register_as 'PAGE'
+    class << self
+        def accumulate(src, array, deplate, text, match, args, cmd)
+            Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
+            m = []
+            Deplate::Element::Break.accumulate(src, array, deplate, text, m)
+        end
+    end
+end
+
+class Deplate::Command::NOP < Deplate::Command
+    register_as 'NOP'
+
+    def setup_command
+        @embedable = false
+    end
+
+    def finish
+        return self
+    end
+    
+    def process
+    end
+end
+