deplate 0.8 → 0.8.1

data/lib/deplate/builtin.rb

@@ -1,5 +1,5 @@
 # builtin.rb
-# @Author:      Thomas Link (samul AT web.de)
+# @Author:      Thomas Link (micathom AT gmail com)
 # @Website:     http://deplate.sf.net/
 # @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
 # @Created:     05-Jun-2004.

data/lib/deplate/cache.rb

@@ -1,5 +1,5 @@
 # cache.rb
-# @Author:      Thomas Link (samul AT web.de)
+# @Author:      Thomas Link (micathom AT gmail com)
 # @Website:     http://deplate.sf.net/
 # @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
 # @Created:     21-Aug-2005.

data/lib/deplate/commands.rb

@@ -1,10 +1,10 @@
 # commands.rb
-# @Author:      Thomas Link (samul AT web.de)
+# @Author:      Thomas Link (micathom AT gmail com)
 # @Website:     http://deplate.sf.net/
 # @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
 # @Created:     08-Mai-2004.
-# @Last Change: 02-Mai-2006.
-# @Revision:    0.1164
+# @Last Change: 2007-09-30.
+# @Revision:    0.1298
 
 # Description:
 # 
@@ -16,17 +16,22 @@
 # 
 
 module Deplate::Names
+    module_function
+    def name_match_c(text)
+        if text =~ /^\{(.*)\}$/
+            return {:surname => $1}
+        end
+    end
+
     def name_match_sf(text)
         m = /^\s*(.+?),\s*(.+?)\s*$/.match(text)
         return m ? {:firstname => m[2], :surname => m[1]} : nil
     end
-    module_function :name_match_sf
     
     def name_match_fs(text)
         m = /^\s*(\S+(\s+\S+)*?)\s+(\S+)\s*$/.match(text)
         return m ? {:firstname => m[1], :surname => m[3]} : nil
     end
-    module_function :name_match_fs
 end
 
 class Deplate::Command < Deplate::Element
@@ -84,7 +89,7 @@ class Deplate::Command < Deplate::Element
     end
 
     def finish
-        @elt = [ @accum.join(" ") ]
+        @elt = [ @accum.join(' ') ]
         return self
     end
 
@@ -111,7 +116,7 @@ class Deplate::Command::CAP < Deplate::Command
             if last
                 last.set_caption(Deplate::CaptionDef.new(text, args, src))
             else
-                Deplate::Core.log(["Can't attach caption to", nil], :error, src)
+                Deplate::Core.log(["Cannot attach caption to", nil], :error, src)
             end
         end
     end
@@ -133,55 +138,79 @@ end
 class Deplate::Command::INC < Deplate::Command
     register_as 'INC'
     register_as 'INCLUDE'
-    
-    def self.accumulate(src, array, deplate, text, match, args, cmd)
-        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
-        doc = args['doc'] || args['var'] || args['val']
-        if args.has_key?('file')
-            if text
-                Deplate::Core.log(['Conflicting arguments', 'file > @anonymous'], :error, src)
+   
+    class << self
+        def accumulate(src, array, deplate, text, match, args, cmd)
+            Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
+            var  = args['var'] || args['var'] || args['val']
+            if args.has_key?('file')
+                if text
+                    Deplate::Core.log(['Conflicting arguments', 'file > @anonymous'], :error, src)
+                end
+                text = args['file']
+            end
+            args['INCLUDED'] = src.file
+            vars         = swap_variables(deplate, args)
+            input_format = args['inputFormat']
+            pif          = deplate.push_input_format(input_format)
+
+            begin
+                if var
+                    strings = deplate.variables[var]
+                    if strings
+                        deplate.include_stringarray(strings, array, nil, src.file)
+                    else
+                        Deplate::Core.log(['Unknown doc variable', var], :error, src)
+                    end
+                elsif !text or text == ''
+                    Deplate::Core.log(['Malformed command', cmd, text], :error, src)
+                else
+                    fn = deplate.find_in_lib(text, :pwd => true)
+                    if fn
+                        deplate.include_file(array, fn, args)
+                    else
+                        Deplate::Core.log(['File not found', text], :error, src)
+                    end
+                end
+            ensure
+                restore_variables(deplate, vars)
+                deplate.pop_input_format(input_format) if pif
             end
-            text = args['file']
         end
-        
-        embeddedTextRx      = args['embeddedTextRx']
-        embeddedTextRx_orig = deplate.variables['embeddedTextRx']
-        deplate.variables['embeddedTextRx'] = embeddedTextRx if embeddedTextRx
-            
-        embeddedVerbatim      = args['embeddedVerbatim']
-        embeddedVerbatim_orig = deplate.variables['embeddedVerbatim']
-        deplate.variables['embeddedVerbatim'] = embeddedVerbatim if embeddedVerbatim
-            
-        syntax      = args['codeSyntax'] || args['syntax']
-        syntax_orig = deplate.variables['codeSyntax']
-        deplate.variables['codeSyntax'] = syntax if syntax
-            
-        input_format = args['inputFormat']
-        pif          = deplate.push_input_format(input_format)
-        
-        begin
-            if doc
-                strings = deplate.variables[doc]
-                if strings
-                    deplate.include_stringarray(strings, array, nil, src.file)
+
+        def swap_variables(deplate, args, vars={})
+            # vars[:deplate] ||= deplate.variables.dup
+            args.each do |var, val|
+                case var
+                when 'syntax'
+                    var = 'codeSyntax'
+                when 'codeSyntax', 'embeddedTextRx', 'embeddedVerbatim'
                 else
-                    Deplate::Core.log(['Unknown doc variable', doc], :error, src)
+                    if var[0..0] == '$'
+                        var = var[1..-1]
+                    else
+                        next
+                    end
                 end
-            elsif !text or text == ''
-                Deplate::Core.log(['Malformed command', cmd, text], :error, src)
-            else
-                fn = deplate.find_in_lib(text, :pwd => true)
-                if fn
-                    deplate.include_file(array, fn)
+                has_key = deplate.variables.has_key?(var)
+                vars[var] = {
+                    :has_key => has_key,
+                    :value => has_key ? deplate.variables[var] : nil,
+                }
+                deplate.variables[var] = val
+            end
+            vars
+        end
+
+        def restore_variables(deplate, hash)
+            # deplate.variables = hash[:deplate]
+            hash.each do |var, val|
+                if val[:has_key]
+                    deplate.variables[var] = val[:value]
                 else
-                    Deplate::Core.log(['File not found', text], :error, src)
+                    deplate.variables.delete(var)
                 end
             end
-        ensure
-            deplate.variables['embeddedTextRx']   = embeddedTextRx_orig if embeddedTextRx
-            deplate.variables['embeddedVerbatim'] = embeddedVerbatim_orig if embeddedVerbatim
-            deplate.variables['codeSyntax']       = syntax_orig if syntax
-            deplate.pop_input_format(input_format) if pif
         end
     end
 end
@@ -216,7 +245,9 @@ class Deplate::Command::VAR < Deplate::Command
                     set_variable(deplate, id, text, args, src)
                 end
             else
-                opts, text = deplate.input.parse_args(text, nil, false)
+                cnt = Deplate::PseudoContainer.new(deplate, args)
+                cnt.source = src
+                opts, text = deplate.input.parse_args(text, cnt, false)
                 for k, v in opts
                     unless set_variable(deplate, k, v, args, src)
                         opts.delete(k)
@@ -228,6 +259,16 @@ class Deplate::Command::VAR < Deplate::Command
 end
 
 
+class Deplate::Command::PUSH < Deplate::Command::VAR
+    register_as 'PUSH'
+    self.volatile = true
+    def self.accumulate(src, array, deplate, text, match, args, cmd)
+        args['add'] ||= ','
+        super
+    end
+end
+
+
 class Deplate::Command::KEYWORDS < Deplate::Command::VAR
     register_as 'KEYWORDS'
     self.volatile = true
@@ -240,17 +281,22 @@ end
 
 class Deplate::Command::OPT < Deplate::Command
     register_as 'OPT'
+    # register_as 'ATTR'
+    register_as 'PROP'
+    register_as 'PP'
     self.volatile = true
     def self.accumulate(src, array, deplate, text, match, args, cmd)
         Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
         elt = array.last
         if elt
-            opts, text = deplate.input.parse_args(text, nil, false)
+            cnt = Deplate::PseudoContainer.new(deplate, args)
+            cnt.source = src
+            opts, text = deplate.input.parse_args(text, cnt, false)
             deplate.register_id(opts, elt)
             update_variables(elt.args, args, opts)
             elt.update_args
         else
-            Deplate::Core.log(["No element given", match[0]], :error, src)
+            Deplate::Core.log(['No element given', match[0]], :error, src)
         end
     end
 end
@@ -262,12 +308,12 @@ class Deplate::Command::PUT < Deplate::Command
     register_as 'SET'
     def self.accumulate(src, array, deplate, text, match, args, cmd)
         Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
-        id = args["id"]
+        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 ID given", text], :error, src)
+            Deplate::Core.log(['No ID given', text], :error, src)
         end
     end
 end
@@ -278,7 +324,7 @@ class Deplate::Command::GET < Deplate::Command
     set_formatter :format_GET
     
     def setup_command
-        @id = @args["id"] || @accum[0]
+        @id = @args['id'] || @accum[0]
     end
     
     def process
@@ -286,7 +332,7 @@ class Deplate::Command::GET < Deplate::Command
         if @elt
             return self
         else
-            log(["GET: Clip not found", @id], :error)
+            log(['GET: Clip not found', @id], :error)
             return nil
         end
     end
@@ -296,20 +342,18 @@ end
 class Deplate::Command::XARG < Deplate::Command
     register_as 'XARG'
     register_as 'XVAL'
-    self.volatile = true
+    # self.volatile = true
     
     def setup_command
-        id = args["id"] || @accum[0]
-        @elt = @deplate.variables[id] || @args["default"]
+        id = args['id'] || @accum[0]
+        @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!}
+            @elt = Deplate::Command::ARG.preformat_element(@elt, @args)
         else
-            log(["Unknown variable", id, @name], :error)
+            log(['Unknown variable', id, @name], :error)
         end
     end
-    
+
     def format_special
         @elt
     end
@@ -319,7 +363,7 @@ end
 class Deplate::Command::ARG < Deplate::Command
     register_as 'ARG'
     register_as 'VAL'
-    self.volatile = true
+    # self.volatile = true
 
     class << self
         def accumulate(src, array, deplate, text, match, args, cmd)
@@ -327,17 +371,30 @@ class Deplate::Command::ARG < Deplate::Command
             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!}
+                acc = preformat_element(val, args)
                 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)
             end
         end
+
+        def preformat_element(elt, args)
+            case elt
+            when Array
+                elt = elt.collect {|text| preformat_text(text, args)}
+            else
+                elt = preformat_text(elt, args)
+            end
+            elt.flatten!
+            return elt
+        end
+
+        def preformat_text(text, args)
+            text = Deplate::Core.escape_characters(text, args)
+            text = Deplate::CommonGround.post_process_text(text, args)
+            return text.split(/[\n\r]/).each {|l| l.chomp!}
+        end
     end
 end
 
@@ -361,13 +418,13 @@ class Deplate::Command::TITLE < Deplate::Command
     register_as 'TI'
     self.volatile = true
     def self.accumulate(src, array, deplate, text, match, args, cmd)
-        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
+        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.set_clip('title', Deplate::Element::Clip.new(c, deplate, src))
         deplate.register_metadata(src, 
-                                  "type" => "metadata", 
-                                  "name" => "title",
-                                  "value" => text
+                                  'type' => 'metadata', 
+                                  'name' => 'title',
+                                  'value' => text
                                  )
     end
 end
@@ -379,34 +436,34 @@ class Deplate::Command::AUTHOR < Deplate::Command
     self.volatile = true
     class << self
         def accumulate(src, array, deplate, text, match, args, cmd)
-            Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
+            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*$/
                     author = Deplate::Names.name_match_sf(this) || 
                         Deplate::Names.name_match_fs(this) || {}
-                    sn = args["surname"]
+                    sn = args['surname']
                     author[:surname] = sn if sn
-                    fn = args["firstname"]
+                    fn = args['firstname']
                     author[:firstname] = fn if fn
                     if this.empty?
-                        author[:name] = args["name"] || "%s %s" % [args["firstname"], args["surname"]]
+                        author[:name] = args['name'] || '%s %s' % [args['firstname'], args['surname']]
                     else
                         author[:name] = this
                     end
-                    author[:note] = args["note"]
+                    author[:note] = args['note']
                     deplate.options.author << author
                 end
             end
-            sep     = deplate.variables["authorSep"] || "; "
+            sep     = deplate.variables['authorSep'] || '; '
             authors = deplate.options.author.collect {|h| h[:name]}
             authors = authors.join(sep)
             parsed  = deplate.parse_with_source(src, authors, false)
-            deplate.set_clip("author", Deplate::Element::Clip.new(parsed, deplate, src))
+            deplate.set_clip('author', Deplate::Element::Clip.new(parsed, deplate, src))
             deplate.register_metadata(src, 
-                                      "type" => "metadata", 
-                                      "name" => "author",
-                                      "value" => authors
+                                      'type' => 'metadata', 
+                                      'name' => 'author',
+                                      'value' => authors
                                      )
         end
     end
@@ -418,7 +475,7 @@ class Deplate::Command::AUTHORNOTE < Deplate::Command
     register_as 'AN'
     self.volatile = true
     def self.accumulate(src, array, deplate, text, match, args, cmd)
-        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
+        Deplate::Core.log('%s: %s' % [cmd, text], :debug, src)
         unless text.empty?
             author = deplate.options.author.last
             if author
@@ -426,14 +483,14 @@ class Deplate::Command::AUTHORNOTE < Deplate::Command
             end
         end
         ans = deplate.options.author.collect {|h| h[:note]}
-        sep = deplate.variables["authorSep"] || "; "
+        sep = deplate.variables['authorSep'] || '; '
         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.set_clip('authornote', Deplate::Element::Clip.new(parsed, deplate, src))
         deplate.register_metadata(src, 
-                                  "type" => "metadata", 
-                                  "name" => "authornote",
-                                  "value" => ans
+                                  'type' => 'metadata', 
+                                  'name' => 'authornote',
+                                  'value' => ans
                                  )
     end
 end
@@ -443,7 +500,7 @@ class Deplate::Command::DATE < Deplate::Command
     register_as 'DATE'
     self.volatile = true
     def self.accumulate(src, array, deplate, text, match, args, cmd)
-        Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
+        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))
@@ -611,7 +668,7 @@ class Deplate::Command::IDX < Deplate::Command
             accum = []
             auto  = args['auto']
             auto  = deplate.variables['autoindex'] if auto.nil?
-            for i in text.split(/\s*;\s*/)
+            for i in Deplate::Core.split_list(text, ';', nil, source)
                 # <+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
@@ -652,7 +709,7 @@ class Deplate::Command::AUTOIDX < Deplate::Command
     def self.accumulate(src, array, deplate, text, match, args, cmd)
         Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
         hd  = deplate.get_current_heading
-        for i in text.split(/\s*;\s*/)
+        for i in Deplate::Core.split_list(text, ';', nil, src)
             Deplate::Particle.auto_indexing(deplate, deplate.add_index(nil, i, hd))
         end
     end
@@ -664,7 +721,7 @@ class Deplate::Command::NOIDX < Deplate::Command
     self.volatile = true
     def self.accumulate(src, array, deplate, text, match, args, cmd)
         Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
-        for i in text.split(/\s*;\s*/)
+        for i in Deplate::Core.split_list(text, ';', nil, src)
             deplate.remove_index(self, i)
         end
     end
@@ -676,7 +733,7 @@ class Deplate::Command::DONTIDX < Deplate::Command
     self.volatile = true
     def self.accumulate(src, array, deplate, text, match, args, cmd)
         Deplate::Core.log("%s: %s" % [cmd, text], :debug, src)
-        deplate.options.dont_index += text.split(/\s*;\s*/)
+        deplate.options.dont_index += Deplate::Core.split_list(text, ';', nil, src)
     end
 end
 
@@ -723,11 +780,12 @@ class Deplate::Command::ABBREV < Deplate::Command
             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)
+                    # rs = %{\\b%s\\b} % Regexp.escape(w)
+                    # rs = %{\\b%s(?=[^#{Deplate::HyperLink.chars}])} % Regexp.escape(w)
+                    rs = %{\\b%s(?=([[:punct:][:cntrl:][:space:]]|$))} % Regexp.escape(w)
                     # tx = "#{Deplate::Core.remove_backslashes(text.inspect)}"
                     # tx = "#{text.inspect}"
                     # tx = text.inspect
@@ -755,14 +813,14 @@ class Deplate::Command::ABBREV < Deplate::Command
                     cmd = lambda {|c, t| c.deplate.formatter.plain_text(t)}
                     specific = false
                 elsif args['native'] or args['ins']
-                    cmd = tx
+                    cmd = lambda {|c, t| t}
                     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]
+                deplate.options.abbrevs[[rs, deplate.formatter.formatter_name]] = [tx, cmd]
                 rx = Regexp.new("^#{rs}")
                 # body = <<-EOR
                 #     set_rx(#{rx.inspect})
@@ -773,7 +831,7 @@ class Deplate::Command::ABBREV < Deplate::Command
                 body = <<-EOR
                     set_rx(#{rx.inspect})
                     def setup
-                        tx, cmd = @deplate.options.abbrevs[#{rs.inspect}]
+                        tx, cmd = @deplate.options.abbrevs[[#{rs.inspect}, @deplate.formatter.formatter_name]]
                         case cmd
                         when Proc
                             tx   = tx.call(self) if tx.kind_of?(Proc)
@@ -787,7 +845,8 @@ class Deplate::Command::ABBREV < Deplate::Command
                 EOR
                 cls = Deplate::Cache.particle(deplate, body, 
                                               :register => true,
-                                              :specific => specific
+                                              :specific => specific,
+                                              :unshift => args['priority']
                                              )
             else
                 Deplate::Core.log(["No pattern specified", args], :error, src)