deplate 0.7.3

data/lib/deplate/input.rb

@@ -0,0 +1,492 @@
+# input.rb
+# @Author:      Thomas Link (samul AT web.de)
+# @Website:     http://deplate.sf.net/
+# @License:     GPL (see http://www.gnu.org/licenses/gpl.txt)
+# @Created:     10-M�r-2005.
+# @Last Change: 01-Nov-2005.
+# @Revision:    0.294
+#
+# = Description
+# = Usage
+# = TODO
+# = CHANGES
+
+# Input: 
+class Deplate::Input
+    class << self
+        attr_reader :myname
+
+        def myname=(value)
+            @myname = value
+            klass   = self
+            Deplate::Core.class_eval do
+                declare_input_format(klass)
+            end
+        end
+    end
+    
+    self.myname = 'deplate'
+
+    attr_reader :elements, :commands, :regions, :macros
+    attr_reader :paragraph_class, :comment_class, :command_class
+    attr_reader :particles, :rx_particles, :particles_ext, :rx_particles_ext
+
+    @@custom_particles = {}
+    
+    def initialize(deplate, args)
+        @deplate  = deplate
+        @options  = deplate.options
+        @args     = args
+        @elements = (args[:elements] || Deplate::Element.elements)
+        @commands = (args[:commands] || Deplate::Command.commands)
+        @regions  = (args[:regions ] || Deplate::Region.regions)
+        @macros   = (args[:macros]   || Deplate::Macro.macros)
+        @paragraph_class = args[:paragraph_class] || Deplate::Element::Paragraph
+        @comment_class   = args[:comment_class]   || Deplate::Element::Comment
+        @command_class   = args[:command_class]   || Deplate::Element::Command
+        @allow_onthefly_particles = args[:onthefly_particles] || true
+        initialize_particles
+    end
+    
+    def initialize_particles(alt=false, args=@args)
+        always = args[:always]
+        if always or @allow_onthefly_particles or !@rx_particles
+            @particles_custom ||= args[:particles]
+            if @particles_custom
+                @particles = args[:particles].dup
+            else
+                @particles = Deplate::Particle.particles.dup
+            end
+            for p in @options.disabled_particles
+                disable_particle_class(p)
+            end
+            initialize_rx(:standard)
+        end
+        
+        if always or !defined?(@particles_ext) or (@allow_onthefly_particles and alt)
+            @particles_ext_custom ||= args[:particles_ext]
+            if @particles_ext_custom
+                @particles_ext = args[:particles_ext].dup
+            else
+                @particles_ext = Deplate::Particle.particles_ext.dup
+            end
+            initialize_rx(:extended)
+        else
+            @particles_all    = @particles
+            @rx_particles_all = @rx_particles
+        end
+    end
+
+    def initialize_rx(what=:both)
+        case what
+        when :extended, :both
+            if @particles_ext
+                @particles_all = @particles + @particles_ext
+            else
+                @particles_all = @particles
+            end
+            @rx_particles_all = get_rx_particles(@particles_all)
+        else
+            @rx_particles = get_rx_particles(@particles)
+        end
+    end
+    
+    def register_particle(particle, args={})
+        arr = args[:extended] ? @particles_ext : @particles
+        id  = args[:id] || particle.name
+        catch(:cont) do
+            old = @@custom_particles[id]
+            if old
+                idx = arr.index(old)
+                if idx
+                    arr[idx] = particle
+                    throw :cont
+                end
+            end
+            arr << particle
+        end
+        @@custom_particles[id] = particle
+        initialize_rx(:both)
+    end
+    
+    def get_rx_particles(particles)
+        return Regexp.new(particles.collect {|e| e.rx.source[1..-1]}.join("|"))
+    end
+
+    def get_particles(what, alt=true)
+        if alt
+            p = @particles_all
+            r = @rx_particles_all
+        else
+            p = @particles
+            r = @rx_particles
+        end
+        case what
+        when :rx
+            return r
+        when :particles
+            return p
+        else
+            return r, p
+        end
+    end
+    
+    def disable_particle_class(particle)
+        @particles.delete(particle)
+    end
+       
+    # This is the general function for including text from whatever source 
+    # that follows the enumeration interface. In general, the more 
+    # specialized methods from Deplate::Core should be used to call this.
+    def include_enum(enum, acc_array, linenumber)
+        accum = []
+        for line in enum
+            linenumber += 1
+            line.chomp!
+            unless accum.empty?
+                line.gsub!(/^\s+/, "")
+            end
+            use_line_continuation = acc_array.last ? acc_array.last.line_cont : true
+            if comment_class.match(line)
+                next
+            elsif use_line_continuation and line =~ /(^|[^\\])\\$/
+                accum << line[0..-2]
+            else
+                accum << line
+                handle_line(acc_array, accum.join, linenumber)
+                accum = []
+            end
+        end
+        handle_line(acc_array, nil, linenumber)
+    end
+    
+    def handle_line(array, line, lineNumber=-1)
+        last = array.last
+        if line
+            src = Deplate::Source.new(@deplate.current_source, @deplate.current_source_stats,
+                                      lineNumber, nil)
+            if (tic = @deplate.variables['embeddedTextRx'])
+                # If +embeddedTextRx+ is set, the actual text is hidden in 
+                # comments or similar. Other text is printed as 
+                # verbatim.
+                ec = @deplate.variables['embeddedVerbatim'] || 'Verbatim'
+                rx = /^#{tic}/
+                if line =~ rx
+                    if $1
+                        line = $1
+                    else
+                        line.sub!(rx, '')
+                    end
+                    if last.kind_of?(Deplate::Element::Region) and last.name == ec and !last.finished?
+                        last = finish_last(array, last, lineNumber)
+                    end
+                else
+                    if !@deplate.switches.last
+                        if last.kind_of?(Deplate::Element::Region) and last.name == ec
+                            last << line
+                        elsif line =~ /\S/
+                            unless last.finished?
+                                last = finish_last(array, last, lineNumber)
+                            end
+                            m = Deplate::Element::Region.pseudo_match(:args => '')
+                            Deplate::Element::Region.do_accumulate(src, array, @deplate, '', m, ec)
+                            array.last << line
+                        end
+                    end
+                    return
+                end
+            end
+            if last and !last.finished? and last.endRx
+                # last is a region
+                if line =~ last.endRx
+                    last = finish_last(array, last, lineNumber)
+                else
+                    last << line
+                end
+            else
+                # last is something else
+                e, m = match_elements(line)
+                if last
+                    # so, there is a element in the queue
+                    if e == comment_class
+                        c = nil
+                    elsif last.finished?
+                        # last is finished, so we start a new element
+                        c = e || paragraph_class
+                    elsif e
+                        unless e.is_volatile?(m)
+                            last = finish_last(array, last, lineNumber - 1)
+                        end
+                        c = e
+                    elsif last.to_be_continued?(line)
+                        # this line is something else, so we ask last if it wants 
+                        # to be continued
+                        if @options.keep_whitespace or last.keep_whitespace
+                            last << line
+                        else
+                            last << line.strip
+                        end
+                        c = nil
+                    else
+                        # last doesn't want this line, so we start a new element
+                        last = finish_last(array, last, lineNumber - 1)
+                        c = paragraph_class
+                    end
+                else
+                    # as there is no last element, we start a new one in any 
+                    # case
+                    c = e || paragraph_class
+                end
+                if c and (c == command_class or !@deplate.switches.last)
+                    c.do_accumulate(src, array, @deplate, line, m)
+                end
+            end
+        elsif last and !last.finished?
+            last = finish_last(array, last, lineNumber)
+        end
+    end
+    private :handle_line
+
+    def finish_last(array, last, lineNumber=-1)
+        last.source.end  = lineNumber if lineNumber > 0
+        finished_element = last.finish
+        array.pop
+        if finished_element.kind_of?(Array)
+            for e in finished_element
+                handle_finished_element(array, e)
+            end
+        else
+            handle_finished_element(array, finished_element)
+        end
+        array.last
+    end
+    private :finish_last
+
+    def handle_finished_element(array, element)
+        unless element.nil? or element.drop?
+            pred = array.last
+            unless pred and pred.unify(element)
+                if !@deplate.labels_floating.empty? and element.can_be_labelled
+                    element.put_label(@deplate.labels_floating)
+                    @deplate.labels_floating = []
+                end
+                array << element
+            end
+        end
+    end
+    private :handle_finished_element
+
+
+    ### Elements
+
+    # Test for all elements except Paragraph. It's a real Paragraph if there 
+    # is undefined text and the previous element wasn't a "multiliner"
+    def match_elements(line)
+        @elements.each do |e|
+            m = e.match(line)
+            if m
+                return [e, m]
+            end
+        end
+        return [nil, @paragraph_class.match(line)]
+    end
+    private :match_elements
+
+
+    ### Particles
+    
+    # This is the method that does the actual parsing of elements into 
+    # particles. It takes a regular expression made up of all known particles 
+    # and matches the text against it. It splits the text into a prelude, a 
+    # match, and the rest. The the prelude is turned into an instance of 
+    # Deplate::Particle::Text, the match into a matching particle. The rest is 
+    # matched against the grand regular expression again.
+    #
+    # This approach provides for easy runtime modifications of the 
+    # lexer/parser, which wouldn't be possible, I assume, if I had used rexml 
+    # or similar ... I assume.
+    #
+    # Anyway, you should call this method directly unless you have to, but use 
+    # the more specialized ones.
+    def parse_using(container, text, rx, particles, alt=true)
+        rest = text
+        rt   = []
+        last = ""
+        src  = container ? container.source : nil
+        while !rest.empty?
+            begin
+                mx = rx.match(rest)
+            rescue RegexpError => e
+                if rest.size > 60
+                    sample = "%s ..." % rest[0..60]
+                else
+                    sample = rest
+                end
+                log_error(container, ["Regexp error when parsing", sample], :error, src)
+            rescue Exception => e
+                puts e.backtrace[0..10].join("\n")
+                raise e
+            end
+            if mx
+                rest = mx.post_match
+                catch(:ok) do
+                    particles.each do |e|
+                        m = e.match(mx[0])
+                        if m
+                            pre = mx.pre_match
+                            unless pre.empty?
+                                rt << Deplate::Particle::Text.new(@deplate, container, rt, mx.pre_match, alt, last)
+                            end
+                            txt = last + mx.pre_match
+                            # begin
+                                rt << e.new(@deplate, container, rt, m, alt, txt, rest)
+                                # rescue Exception => exc
+                                # puts "Internal error when initializing %s: %s" % [e.name, txt]
+                                # raise exc
+                            # end
+                            throw :ok
+                        end
+                    end
+                    txt = mx.pre_match + mx[0]
+                    rt << Deplate::Particle::Text.new(@deplate, container, rt, txt, alt, last, rest)
+                end
+                last = mx[0]
+            else
+                rt << Deplate::Particle::Text.new(@deplate, container, rt, rest, alt, last, "")
+                break
+            end
+        end
+        return rt
+    end
+
+    def parse_with_particles(container, text, particles, alt=true)
+        parse_using(container, text, get_particles(:rx, alt), particles, alt)
+    end
+
+    def parse_with_source(source, text, alt=true)
+        container = Deplate::PseudoContainer.new(@deplate, :source => source)
+        parse(container, text, alt)
+    end
+
+    def parse(container, text, alt=true, excluded=[])
+        rx, particles = get_particles(:both, alt)
+        for p in excluded
+            particles.delete(p)
+        end
+        parse_using(container, text, rx, particles, alt)
+    end
+
+    ### Arguments
+    # @@rxsrc_args = %{(\\w+?)(!|=("(\\\\"|[^"])*"|(\\\\=|.)+?))(\\s*$|(?= \w+(!|=)))}
+    # @@rxsrc_args = %{(\\w+?)(!|=((\\\\=|.)+?))(\\s*$|(?= \w+(!|=)))}
+    # @@rxsrc_argval       = %{("(\\\\"|[^"])*?"|(\\\\=|\\\\:|\\\\!|[^=!]+)+?)}
+    # @@rxsrc_argval       = %{(\\\\=|\\\\:|[^=:]*)+?}
+    # @@rxsrc_argval = %{("(\\\\"|[^"])*?"|(\\\\ |\\\\=|\\\\:|\\\\!|[%s]+)+?)}
+    @@rxsrc_argval = %{("(\\\\"|[^"])*"|\\([^)]+\\)|\\\\.|[%s"]+)+?}
+    # @@rxsrc_argval = %{("(\\\\"|[^"])*"|\\\\.|[%s"]+)+?}
+    @@rxsrc_key    = %{[@\\w]+(\\[\\S*?\\])?}
+    @@rxsrc_args1  = %{(#{@@rxsrc_key})(!|=(#{@@rxsrc_argval}))\\s*} % "^=!:"
+    @@rxsrc_args2  = %{(#{@@rxsrc_key})(!|=(#{@@rxsrc_argval}))\\s*} % "^=!"
+    @@rx_args      = /^\s*(#{@@rxsrc_args2})(\s*$|(?=\s+#{@@rxsrc_key}(!|=)))/
+    @@rx_argstext  = /^\s*((#{@@rxsrc_args1})*?)(:\s*(.+))?$/
+
+    def parse_args(argText, container=nil, firstPass=true, parseText=false)
+        if argText
+            if firstPass
+                m  = @@rx_argstext.match(argText)
+            else
+                m = [nil, argText]
+            end
+            accum = {}
+            if m
+                args = m[1]
+                text = m[10]
+                while !args.empty?
+                    m = @@rx_args.match(args)
+                    if m
+                        key = m[2]
+                        if key =~ /^no[A-Z]/
+                            key_alt = key[2..2].downcase + key[3..-1]
+                            accum[key_alt] = false
+                            val = true
+                        end
+                        if m[4] == "!"
+                            val = true
+                        elsif m[5] == 'true'
+                            val = true
+                        elsif m[5] == 'false'
+                            val = false
+                        else
+                            valm = /^"(.*?)"$/.match(m[5])
+                            if valm
+                                val = valm[1]
+                            else
+                                val = m[5].strip
+                            end
+                            val = Deplate::Core.remove_backslashes(val)
+                        end
+                        accum[key] = val
+                        args = m.post_match
+                        if args.empty?
+                            break
+                        end
+                    else
+                        log_error(@container, ["Argument parse error", args, argText])
+                        break
+                    end
+                end
+                if parseText
+                    if text
+                        parsed = parse(container, text)
+                    else
+                        parsed = []
+                    end
+                end
+            else
+                text   = nil
+                parsed = nil
+            end
+            id = accum['id']
+            if id
+                accum['@id'] = id
+                accum['id']  = @deplate.formatter.encode_id(id)
+            end
+            fmt   = accum["fmt"]
+            accum.delete("fmt") if fmt
+            ifOpt = accum["if"]
+            if ifOpt
+                accum.delete("if")
+                ifOpt = Deplate::Element::Command.check_switch(@deplate, ifOpt)
+            else
+                ifOpt = true
+            end
+            nofmt = accum["nofmt"]
+            accum.delete("nofmt") if nofmt
+            nofmt ||= accum["noFmt"]
+            accum.delete("noFmt") if nofmt
+            if (!firstPass or (ifOpt and
+                              (!fmt || @deplate.formatter.matches?(fmt)) and 
+                              (!nofmt || !(@deplate.formatter.matches?(nofmt)))))
+                if parseText
+                    return [accum, text, parsed]
+                else
+                    return [accum, text || ""]
+                end
+            else
+                raise Deplate::DontFormatException
+            end
+        else
+            return nil
+        end
+    end
+
+    private
+    def log_error(container, text)
+        (container || @deplate).log(text, :error)
+    end
+end
+
+# class Deplate::Core
+#     declare_input_format(Deplate::Input)
+# end
+