deplate 0.7.3

data/lib/deplate.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# deplate.rb -- Convert wiki-like plain text pseudo markup to something else
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     24-Feb-2004.
+# @Last Change: 16-Okt-2005.
+
+require 'profile' if ARGV[0] == '--profile'
+
+require 'deplate/core'
+require 'deplate/input'
+require 'deplate/output'
+require 'deplate/cache'
+require 'deplate/common'
+require 'deplate/etc'
+require 'deplate/elements'
+require 'deplate/regions'
+require 'deplate/commands'
+require 'deplate/macros'
+require 'deplate/particles'
+require 'deplate/define'
+require 'deplate/template'
+require 'deplate/external'
+require 'deplate/metadata'
+
+if __FILE__ == $0
+    require 'deplate/builtin'
+    Deplate::Core.deplate
+end
+

data/lib/deplate/abstract-class.rb

@@ -0,0 +1,30 @@
+# DefAbstract.rb
+# @Created:     18-M�r-2004.
+# @Last Change: 23-Okt-2005.
+# @Revision:    0.10
+# 
+# Description:
+# From: http://groups.google.at/groups?hl=de&lr=&ie=UTF-8&oe=UTF-8&newwindow=1&selm=20030821221909.53f3274a.rpav%40mephle.com&rnum=38
+# Von:Ryan Pavlik (rpav@mephle.com)
+# Betrifft:Re: Class variables - a surprising result
+# Newsgroups:comp.lang.ruby
+# Datum:2003-08-21 22:20:26 PST 
+
+class SubclassResponsibility < Exception; end
+
+class Module
+    def def_abstract(*args)
+        for sym in args
+            module_eval <<-CODE
+            def #{sym}(*args)
+                raise SubclassResponsibility
+            end
+            CODE
+        end
+    end #m:def_abstract
+end #c:Module
+
+# class B
+    # def_abstract :foo, :bar
+# end
+

data/lib/deplate/builtin.rb

@@ -0,0 +1,11 @@
+# builtin.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     05-Jun-2004.
+# @Last Change: 23-Okt-2005.
+# @Revision:    0.4
+# 
+# Description:
+# Dummy file
+

data/lib/deplate/cache.rb

@@ -0,0 +1,59 @@
+# cache.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @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
+
+# = Description
+# This class provides a cache for dynamically generated classes.
+class Deplate::Cache
+    @@custom_particles = {}
+
+    attr_reader :cls
+ 
+    class << self
+        def particle(deplate, body, args)
+            register = args[:register]
+            new(@@custom_particles, Deplate::Particle, deplate, body, args) do |cls|
+                if register
+                    args[:id] = body
+                    deplate.register_particle(cls, args)
+                end
+            end
+        end
+    end
+    
+    def initialize(cache, super_class, deplate, body, args={})
+        @deplate = deplate
+        @cache   = cache
+        specific = args[:specific]
+        retrieve_particle(body, specific)
+        unless @cls
+            @cls = Class.new(super_class)
+            @cls.class_eval(body)
+            store_particle(body, specific)
+        end
+        if @cls and block_given?
+            yield(@cls)
+        end
+    end
+
+    def retrieve_particle(body, specific=false)
+        fmt       = get_formatter_name(specific)
+        particles = @cache[fmt] ||= {}
+        @cls = particles[body]
+    end
+
+    def store_particle(body, specific=false)
+        fmt       = get_formatter_name(specific)
+        particles = @cache[fmt] ||= {}
+        particles[body] = @cls
+    end
+
+    def get_formatter_name(specific)
+        return specific ? @deplate.formatter.formatter_name : :general
+    end
+end
+

data/lib/deplate/commands.rb

@@ -0,0 +1,693 @@
+# commands.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @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
+
+# Description:
+# 
+# Usage:
+# 
+# TODO:
+# 
+# CHANGES:
+# 
+
+module Deplate::Names
+    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
+    include Deplate::Names
+
+    @@commands = {}
+    
+    class << self
+        # attr_reader :commands
+        def commands
+            @@commands
+        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"]
+                    else
+                        sep = " "
+                    end
+                    args.each_pair do |k,v|
+                        if hash[k]
+                            v = hash[k] + sep + v
+                        end
+                        hash[k] = v
+                    end
+                else
+                    hash.update(args)
+                end
+            else
+                Deplate::Core.log(["No arguments", opts], :error, src)
+            end
+        end
+    end
+    
+    def setup(args, cmd)
+        @multiliner = false
+        @collapse   = false
+        @name       = cmd
+        @accum      = [@text]
+        @can_be_labelled = false
+        @args.update(args)
+        setup_command
+        update_args
+    end
+    
+    def setup_command
+    end
+
+    def finish
+        @elt = [ @accum.join(" ") ]
+        return self
+    end
+
+    def process
+        process_etc
+        @elt = @elt.join("\n")
+        return self
+    end
+
+    def format_special
+        format_unknown(self)
+    end
+end
+
+
+class Deplate::Command::CAP < Deplate::Command
+    @@commands["CAP"] = self
+    @@commands["CAPTION"] = self
+
+    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)
+            else
+                last.level_as_string = deplate.get_current_heading
+                last.caption  = Deplate::CaptionDef.new(elt, args)
+                last.register_caption
+            end
+        end
+    end
+end
+
+
+class Deplate::Command::LANG < Deplate::Command
+    @@commands["LANG"]     = self
+    @@commands["LANGUAGE"] = self
+    
+    def self.accumulate(src, array, deplate, text, match, args, cmd)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        deplate.set_lang(text)
+    end
+end
+
+
+class Deplate::Command::INC < Deplate::Command
+    @@commands["INC"]     = self
+    @@commands["INCLUDE"] = self
+    
+    def self.accumulate(src, array, deplate, text, match, args, cmd)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        formatter_name = deplate.formatter.formatter_name
+        doc = args['doc'] || 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
+        
+        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)
+                else
+                    Deplate::Core.log(["Unknown doc variable", doc], :error, src)
+                end
+            elsif !text or text == ''
+                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
+                end
+                Deplate::Core.log(["File not found", text], :error, src)
+            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
+
+
+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
+                                     )
+        end
+        update_variables(deplate.variables, args, opts)
+    end
+end
+
+
+class Deplate::Command::OPT < Deplate::Command
+    @@commands["OPT"] = self
+    def self.accumulate(src, array, deplate, text, match, args, cmd)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        elt = array.last
+        if elt
+            opts, text = deplate.input.parse_args(text, nil, 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)
+        end
+    end
+end
+
+
+class Deplate::Command::PUT < Deplate::Command
+    @@commands["PUT"] = self
+    @@commands["CLIP"] = self
+    @@commands["SET"] = self
+    def self.accumulate(src, array, deplate, text, match, args, cmd)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        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)
+        end
+    end
+end
+
+
+class Deplate::Command::GET < Deplate::Command
+    @@commands["GET"] = self
+    @formatter = :format_GET
+    
+    def setup_command
+        @id = @args["id"] || @accum[0]
+    end
+    
+    def process
+        @elt = @deplate.get_clip(@id)
+        if @elt
+            return self
+        else
+            log(["GET: Clip not found", @id], :error)
+            return nil
+        end
+    end
+end
+
+
+class Deplate::Command::XARG < Deplate::Command
+    @@commands["XARG"] = self
+    @@commands["XVAL"] = self
+    
+    def setup_command
+        id = args["id"] || @accum[0]
+        @elt = @deplate.variables[id]
+        if @elt
+            @elt = @elt.split(/[\n\r]/).each {|l| l.chomp!}
+        else
+            log(["Unknown variable", id, @name], :error)
+        end
+    end
+    
+    def format_special
+        @elt
+    end
+end
+
+
+class Deplate::Command::ARG < Deplate::Command
+    @@commands["ARG"] = self
+    @@commands["VAL"] = self
+
+    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]
+            if val
+                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)
+            end
+        end
+    end
+end
+
+
+class Deplate::Command::BIB < Deplate::Command
+    @@commands["BIB"] = self
+    class << self
+        def accumulate(src, array, deplate, text, match, args, cmd)
+            Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+            bibs = text.strip.split(/\s*\|\s*/)
+            deplate.options.bib += bibs
+            deplate.formatter.read_bib(bibs)
+        end
+    end
+end
+
+
+class Deplate::Command::TITLE < Deplate::Command
+    @@commands["TITLE"] = self
+    @@commands["TI"] = self
+    def self.accumulate(src, array, deplate, text, match, args, cmd)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        c = deplate.parse_with_source(src, text, false)
+        deplate.set_clip("title", Deplate::Element::Clip.new(c, deplate, src))
+        deplate.register_metadata(src, 
+                                  "type" => "metadata", 
+                                  "name" => "title",
+                                  "value" => text
+                                 )
+    end
+end
+
+
+class Deplate::Command::AUTHOR < Deplate::Command
+    @@commands["AUTHOR"] = self
+    @@commands["AU"] = self
+    class << self
+        def accumulate(src, array, deplate, text, match, args, cmd)
+            Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+            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"]
+                    author[:surname] = sn if sn
+                    fn = args["firstname"]
+                    author[:firstname] = fn if fn
+                    if this.empty?
+                        author[:name] = args["name"] || "%s %s" % [args["firstname"], args["surname"]]
+                    else
+                        author[:name] = this
+                    end
+                    author[:note] = args["note"]
+                    deplate.options.author << author
+                end
+            end
+            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.register_metadata(src, 
+                                      "type" => "metadata", 
+                                      "name" => "author",
+                                      "value" => authors
+                                     )
+        end
+    end
+end
+
+
+class Deplate::Command::AUTHORNOTE < Deplate::Command
+    @@commands["AUTHORNOTE"] = self
+    @@commands["AN"] = self
+    def self.accumulate(src, array, deplate, text, match, args, cmd)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        unless text.empty?
+            author = deplate.options.author.last
+            if author
+                author[:note] = text
+            end
+        end
+        ans = deplate.options.author.collect {|h| h[:note]}
+        sep = deplate.variables["authorSep"] || "; "
+        ans = ans.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, 
+                                  "type" => "metadata", 
+                                  "name" => "authornote",
+                                  "value" => ans
+                                 )
+    end
+end
+
+
+class Deplate::Command::DATE < Deplate::Command
+    @@commands["DATE"] = self
+    def self.accumulate(src, array, deplate, text, match, args, cmd)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        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))
+        deplate.register_metadata(src, 
+                                  'type' => 'metadata', 
+                                  'name' => 'date',
+                                  'value' => d
+                                 )
+    end
+end
+
+
+class Deplate::Command::IMG < Deplate::Command
+    @@commands['IMG'] = self
+    @@commands['IMAGE'] = self
+    @@commands['FIG'] = self
+    @@commands['FIGURE'] = self
+    @formatter = :format_IMG
+
+    def register_caption
+        register_figure
+    end
+end
+
+
+class Deplate::Command::MAKETITLE < Deplate::Command
+    @@commands['MAKETITLE'] = self
+    @formatter = :format_title
+end
+
+
+class Deplate::Command::MAKEBIB < Deplate::Command
+    @@commands['MAKEBIB'] = self
+    @formatter = :format_MAKEBIB
+end
+
+
+class Deplate::Command::LIST < Deplate::Command
+    @@commands['LIST'] = self
+    @formatter = :format_LIST
+end
+
+
+class Deplate::Command::TABLE < Deplate::Command
+    @@commands['TABLE'] = self
+    def setup_command
+        if File.exist?(@text)
+            File.open(@text) {|io| @accum = io.read.split(/[\r\n]+/)}
+        else
+            log(['File not found', @text], :error)
+        end
+    end
+    
+    def finish
+        return Deplate::Regions::Table.make_char_separated(self, @accum, @args['sep'])
+    end
+end
+
+
+class Deplate::Command::IDX < Deplate::Command
+    @@commands['IDX'] = self
+    @formatter = :format_IDX
+    
+    class << self
+        def accumulate(src, array, deplate, text, match, args, cmd)
+            i = -1
+            while array[i] and array[i].kind_of?(Deplate::Element::Whitespace)
+                i -= 1
+            end
+            e = array[i]
+            if e
+                out = get_indices(e, deplate, args, text, src)
+                pseudocontainer = Deplate::PseudoContainer.new(deplate, :args => args)
+                e.postponed_preformat << Proc.new do |container|
+                    out.collect! do |idx|
+                        deplate.formatter.format_particle(:format_index, pseudocontainer, idx)
+                    end
+                end
+                e.postponed_format << Proc.new do |container|
+                    out.delete('')
+                    out.compact!
+                    container.output(out.join) unless out.empty?
+                end
+            else
+                array << self.new(deplate, src, text, match, args, cmd)
+            end
+        end
+
+        def get_indices(container, deplate, args, text, source)
+            accum = []
+            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)
+                Deplate::Particle.auto_indexing(deplate, idx) if auto
+                accum << idx
+                container.add_metadata(source,
+                                       'type'  => 'index', 
+                                       'name'  => idx.name,
+                                       'label' => idx.label
+                                      )
+            end
+            return accum
+        end
+    end
+    
+    def setup_command
+        @accum = Deplate::Command::IDX.get_indices(self, @deplate, @args, @text, @source)
+    end
+
+    def finish
+        return self
+    end
+    
+    def process
+        @accum.collect! do |idx|
+            deplate.formatter.format_particle(:format_index, self, idx)
+        end
+        @accum.delete("")
+        @accum.compact!
+        @elt = [ @accum.join ]
+        super
+    end
+end
+
+
+class Deplate::Command::AUTOIDX < Deplate::Command
+    @@commands["AUTOIDX"] = self
+    def self.accumulate(src, array, deplate, text, match, args, cmd)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        hd = deplate.get_current_heading
+        for i in text.split(/\s*;\s*/)
+            Deplate::Particle.auto_indexing(deplate, deplate.add_index(nil, i, hd))
+        end
+    end
+end
+
+
+class Deplate::Command::NOIDX < Deplate::Command
+    @@commands["NOIDX"] = self
+    def self.accumulate(src, array, deplate, text, match, args, cmd)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        for i in text.split(/\s*;\s*/)
+            deplate.remove_index(self, i)
+        end
+    end
+end
+
+
+class Deplate::Command::DONTIDX < Deplate::Command
+    @@commands["DONTIDX"] = self
+    def self.accumulate(src, array, deplate, text, match, args, cmd)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        deplate.options.dont_index += text.split(/\s*;\s*/)
+    end
+end
+
+
+class Deplate::Command::WITH < Deplate::Command
+    @@commands["WITH"] = self
+    def self.accumulate(src, array, deplate, text, match, args, cmd)
+        Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+        file = args["file"]
+        body = nil
+        if file
+            File.open(file) {|io| body = io.readlines}
+        else
+            arg = args["arg"]
+            if arg
+                body = deplate.variables[arg].split(/[\n\r]/)
+            end
+        end
+        if body
+            body.each {|l| l.chomp!}
+            sep = "-=deplate=-%.10f-=end=-" % Time.new.to_f
+            acc = ["#%s <<%s" % [text, sep], *body] << sep
+            deplate.include_stringarray(acc, array, src.begin, src.file)
+        else
+            Deplate::Core.log(["No input! Skip", text], :error, src)
+        end
+    end
+end
+
+
+class Deplate::Command::ABBREV < Deplate::Command
+    @@commands["ABBREV"] = self
+    @@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
+            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
+            else
+                cmd = %{@deplate.parse_and_format(@container, #{tx}, false)}
+                specific = false
+            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
+    class << self
+        def accumulate(src, array, deplate, text, match, args, cmd)
+            Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+            deplate.require_module(text)
+            deplate.call_methods_matching(deplate, /^hook_late_require_/)
+            # deplate.initialize_particles(false, :always => true)
+        end
+    end
+end
+
+
+class Deplate::Command::LTX < Deplate::Command
+    @@commands["LTX"] = self
+    @@commands["INLATEX"] = self
+    class << self
+        def accumulate(src, array, deplate, text, match, args, cmd)
+            Deplate::Core.log("%s: %s" % [cmd, text], :debug)
+            m = []
+            m[Deplate::Element::Region.rxi_name]   = 'Ltx'
+            m[Deplate::Element::Region.rxi_args]   = match[2] 
+            m[Deplate::Element::Region.rxi_endrx]  = Regexp.escape('_$%{}%$_')
+            m[Deplate::Element::Region.rxi_indent] = ''
+            text += "\n_$%{}%$_"
+            Deplate::Element::Region.accumulate(src, array, deplate, text, m)
+        end
+    end
+end
+