dryml 1.1.0.pre0

data/lib/dryml/helper.rb

@@ -0,0 +1,69 @@
+# An ActionView Helper
+module Dryml::Helper
+  def context_map(enum = this)
+      # TODO: Calls to respond_to? in here can cause the full collection hiding behind a scoped collection to get loaded
+      res = []
+      empty = true
+      scope.new_scope(:repeat_collection => enum, :even_odd => 'odd', :repeat_item => nil) do
+        if enum.respond_to?(:each_pair)
+          enum.each_pair do |key, value|
+            scope.repeat_item = value
+            empty = false;
+            self.this_key = key;
+            new_object_context(value) { res << yield }
+            scope.even_odd = scope.even_odd == "even" ? "odd" : "even"
+          end
+        else
+          index = 0
+          enum.each do |e|
+            scope.repeat_item = e
+            empty = false;
+            if enum == this
+              new_field_context(index, e) { res << yield }
+            else
+              new_object_context(e) { res << yield }
+            end
+            scope.even_odd = scope.even_odd == "even" ? "odd" : "even"
+            index += 1
+          end
+        end
+        Dryml.last_if = !empty
+      end
+      res
+    end
+    
+    def first_item?
+      if scope.repeat_collection.respond_to? :each_pair
+        this == scope.repeat_collection.first.try.last
+      else
+        this == scope.repeat_collection.first
+      end
+    end
+    
+    
+    def last_item?
+      if scope.repeat_collection.respond_to? :each_pair
+        this == scope.repeat_collection.last.try.last
+      else
+        this == scope.repeat_collection.last
+      end
+    end
+
+        def param_name_for(path)
+      field_path = field_path.to_s.split(".") if field_path.is_one_of?(String, Symbol)
+      attrs = path.rest.map{|part| "[#{part.to_s.sub /\?$/, ''}]"}.join
+      "#{path.first}#{attrs}"
+    end
+
+
+    def param_name_for_this(foreign_key=false)
+      return "" unless form_this
+      name = if foreign_key && (refl = this_field_reflection) && refl.macro == :belongs_to
+               param_name_for(path_for_form_field[0..-2] + [refl.primary_key_name])
+             else
+               param_name_for(path_for_form_field)
+             end
+      register_form_field(name)
+      name
+    end
+end

data/lib/dryml/parser/attribute.rb

@@ -0,0 +1,41 @@
+module Dryml::Parser
+
+  class Attribute < REXML::Attribute
+
+    def initialize(first, second=nil, parent=nil)
+      super
+      if first.is_a?(String) && second == true
+        @value = true
+      end
+    end
+
+    def value
+      if has_rhs?
+        super
+      else
+        element.document.default_attribute_value
+      end
+    end
+
+    def to_string
+      if has_rhs?
+        super
+      else
+        @expanded_name
+      end
+    end
+
+    def has_rhs?
+      @value != true
+    end
+
+
+    # Override to supress Text.check call
+    def element=( element )
+      @element = element
+      self
+    end
+
+  end
+
+end

data/lib/dryml/parser/base_parser.rb

@@ -0,0 +1,254 @@
+module Dryml::Parser
+
+  class BaseParser < REXML::Parsers::BaseParser
+
+    NEW_REX = defined?(REXML::VERSION) && REXML::VERSION =~ /3\.1\.(\d)(?:\.(\d))?/ && $1.to_i*1000 + $2.to_i >= 7002
+
+    DRYML_NAME_STR          = "#{NCNAME_STR}(?::(?:#{NCNAME_STR})?)?"
+    DRYML_ATTRIBUTE_PATTERN = if NEW_REX
+                                /\s*(#{NAME_STR})(?:\s*=\s*(["'])(.*?)\4)?/um
+                              else
+                                /\s*(#{NAME_STR})(?:\s*=\s*(["'])(.*?)\2)?/um
+                              end
+    DRYML_TAG_MATCH         = if NEW_REX
+                                /^<((?>#{DRYML_NAME_STR}))\s*((?>\s+#{NAME_STR}(?:\s*=\s*(["']).*?\5)?)*)\s*(\/)?>/um
+                              else
+                                /^<((?>#{DRYML_NAME_STR}))\s*((?>\s+#{NAME_STR}(?:\s*=\s*(["']).*?\3)?)*)\s*(\/)?>/um
+                              end
+    DRYML_CLOSE_MATCH       = /^\s*<\/(#{DRYML_NAME_STR})\s*>/um
+
+    # For compatibility with REXML 3.1.7.3
+    IDENTITY = /^([!\*\w\-]+)(\s+#{NCNAME_STR})?(\s+["'](.*?)['"])?(\s+['"](.*?)["'])?/u
+
+    def pull
+      if @closed
+        x, @closed = @closed, nil
+        return [ :end_element, x, false ]
+      end
+      return [ :end_document ] if empty?
+      return @stack.shift if @stack.size > 0
+      #STDERR.puts @source.encoding
+      @source.read if @source.buffer.size<2
+      #STDERR.puts "BUFFER = #{@source.buffer.inspect}"
+      if @document_status == nil
+        #@source.consume( /^\s*/um )
+        word = @source.match( /^((?:\s+)|(?:<[^>]*>))/um ) #word = @source.match(/(<[^>]*)>/um)
+        word = word[1] unless word.nil?
+        #STDERR.puts "WORD = #{word.inspect}"
+        case word
+        when COMMENT_START
+          return [ :comment, @source.match( COMMENT_PATTERN, true )[1] ]
+        when XMLDECL_START
+          #STDERR.puts "XMLDECL"
+          results = @source.match( XMLDECL_PATTERN, true )[1]
+          version = VERSION.match( results )
+          version = version[1] unless version.nil?
+          encoding = ENCODING.match(results)
+          encoding = encoding[1] unless encoding.nil?
+          @source.encoding = encoding
+          standalone = STANDALONE.match(results)
+          standalone = standalone[1] unless standalone.nil?
+          return [ :xmldecl, version, encoding, standalone ]
+        when INSTRUCTION_START
+          return [ :processing_instruction, *@source.match(INSTRUCTION_PATTERN, true)[1,2] ]
+        when DOCTYPE_START
+          md = @source.match( DOCTYPE_PATTERN, true )
+          #@nsstack.unshift(curr_ns=Set.new)
+          identity = md[1]
+          close = md[2]
+          identity =~ IDENTITY
+          name = $1
+          raise REXML::ParseException.new("DOCTYPE is missing a name") if name.nil?
+          pub_sys = $2.nil? ? nil : $2.strip
+          long_name = $4.nil? ? nil : $4.strip
+          uri = $6.nil? ? nil : $6.strip
+          args = [ :start_doctype, name, pub_sys, long_name, uri ]
+          if close == ">"
+            @document_status = :after_doctype
+            @source.read if @source.buffer.size<2
+            md = @source.match(/^\s*/um, true)
+            @stack << [ :end_doctype ]
+          else
+            @document_status = :in_doctype
+          end
+          return args
+        when /^\s+/
+        else
+          @document_status = :after_doctype
+          @source.read if @source.buffer.size<2
+          md = @source.match(/\s*/um, true)
+          if @source.encoding == "UTF-8"
+            if @source.buffer.respond_to? :force_encoding
+              @source.buffer.force_encoding(Encoding::UTF_8)
+            end
+          end
+        end
+      end
+      if @document_status == :in_doctype
+        md = @source.match(/\s*(.*?>)/um)
+        case md[1]
+        when SYSTEMENTITY
+          match = @source.match( SYSTEMENTITY, true )[1]
+          return [ :externalentity, match ]
+
+        when ELEMENTDECL_START
+          return [ :elementdecl, @source.match( ELEMENTDECL_PATTERN, true )[1] ]
+
+        when ENTITY_START
+          match = @source.match( ENTITYDECL, true ).to_a.compact
+          match[0] = :entitydecl
+          ref = false
+          if match[1] == '%'
+            ref = true
+            match.delete_at 1
+          end
+          # Now we have to sort out what kind of entity reference this is
+          if match[2] == 'SYSTEM'
+            # External reference
+            match[3] = match[3][1..-2] # PUBID
+            match.delete_at(4) if match.size > 4 # Chop out NDATA decl
+            # match is [ :entity, name, SYSTEM, pubid(, ndata)? ]
+          elsif match[2] == 'PUBLIC'
+            # External reference
+            match[3] = match[3][1..-2] # PUBID
+            match[4] = match[4][1..-2] # HREF
+            # match is [ :entity, name, PUBLIC, pubid, href ]
+          else
+            match[2] = match[2][1..-2]
+            match.pop if match.size == 4
+            # match is [ :entity, name, value ]
+          end
+          match << '%' if ref
+          return match
+        when ATTLISTDECL_START
+          md = @source.match( ATTLISTDECL_PATTERN, true )
+          raise REXML::ParseException.new( "Bad ATTLIST declaration!", @source ) if md.nil?
+          element = md[1]
+          contents = md[0]
+
+          pairs = {}
+          values = md[0].scan( ATTDEF_RE )
+          values.each do |attdef|
+            unless attdef[3] == "#IMPLIED"
+              attdef.compact!
+              val = attdef[3]
+              val = attdef[4] if val == "#FIXED "
+              pairs[attdef[0]] = val
+              if attdef[0] =~ /^xmlns:(.*)/
+                #@nsstack[0] << $1
+              end
+            end
+          end
+          return [ :attlistdecl, element, pairs, contents ]
+        when NOTATIONDECL_START
+          md = nil
+          if @source.match( PUBLIC )
+            md = @source.match( PUBLIC, true )
+            vals = [md[1],md[2],md[4],md[6]]
+          elsif @source.match( SYSTEM )
+            md = @source.match( SYSTEM, true )
+            vals = [md[1],md[2],nil,md[4]]
+          else
+            raise REXML::ParseException.new( "error parsing notation: no matching pattern", @source )
+          end
+          return [ :notationdecl, *vals ]
+        when CDATA_END
+          @document_status = :after_doctype
+          @source.match( CDATA_END, true )
+          return [ :end_doctype ]
+        end
+      end
+      begin
+        if @source.buffer[0] == ?<
+          if @source.buffer[1] == ?/
+            #@nsstack.shift
+            last_tag, line_no = @tags.pop
+            #md = @source.match_to_consume( '>', CLOSE_MATCH)
+            md = @source.match(DRYML_CLOSE_MATCH, true)
+
+            valid_end_tag = last_tag =~ /^#{Regexp.escape(md[1])}(:.*)?$/
+            raise REXML::ParseException.new( "Missing end tag for "+
+                                             "'#{last_tag}' (line #{line_no}) (got \"#{md[1]}\")",
+                                             @source) unless valid_end_tag
+            return [ :end_element, last_tag, true ]
+          elsif @source.buffer[1] == ?!
+            md = @source.match(/\A(\s*[^>]*>)/um)
+            #STDERR.puts "SOURCE BUFFER = #{source.buffer}, #{source.buffer.size}"
+            raise REXML::ParseException.new("Malformed node", @source) unless md
+            if md[0][2] == ?-
+              md = @source.match( COMMENT_PATTERN, true )
+
+              case md[1]
+              when /--/, /-$/
+                raise REXML::ParseException.new("Malformed comment", @source)
+              end
+
+              return [ :comment, md[1] ] if md
+            else
+              md = @source.match( CDATA_PATTERN, true )
+              return [ :cdata, md[1] ] if md
+            end
+            raise REXML::ParseException.new( "Declarations can only occur "+
+                                             "in the doctype declaration.", @source)
+          elsif @source.buffer[1] == ??
+            md = @source.match( INSTRUCTION_PATTERN, true )
+            return [ :processing_instruction, md[1], md[2] ] if md
+            raise REXML::ParseException.new( "Bad instruction declaration",
+                                             @source)
+          else
+            # Get the next tag
+            md = @source.match(DRYML_TAG_MATCH, true)
+            unless md
+              # Check for missing attribute quotes
+              raise REXML::ParseException.new("missing attribute quote", @source) if
+                defined?(MISSING_ATTRIBUTE_QUOTES) && @source.match(MISSING_ATTRIBUTE_QUOTES)
+              raise REXML::ParseException.new("malformed XML: missing tag start", @source)
+
+            end
+            attributes = {}
+            #@nsstack.unshift(curr_ns=Set.new)
+            if md[2].size > 0
+              attrs = md[2].scan(DRYML_ATTRIBUTE_PATTERN)
+              raise REXML::ParseException.new( "error parsing attributes: [#{attrs.join ', '}], excess = \"#$'\"", @source) if $' and $'.strip.size > 0
+              attrs.each { |a,b,c,d,e|
+                val = NEW_REX ? e : c
+                if attributes.has_key? a
+                  msg = "Duplicate attribute #{a.inspect}"
+                  raise REXML::ParseException.new( msg, @source, self)
+                end
+                attributes[a] = val || true
+              }
+            end
+
+            if md[NEW_REX ? 6 : 4]
+              @closed = md[1]
+              #@nsstack.shift
+            else
+              cl = @source.current_line
+              @tags.push( [md[1], cl && cl[2]] )
+            end
+            return [ :start_element, md[1], attributes, md[0],
+                     @source.respond_to?(:last_match_offset) && @source.last_match_offset ]
+          end
+        else
+          md = @source.match( TEXT_PATTERN, true )
+          if md[0].length == 0
+            @source.match( /(\s+)/, true )
+          end
+          #STDERR.puts "GOT #{md[1].inspect}" unless md[0].length == 0
+          #return [ :text, "" ] if md[0].length == 0
+          # unnormalized = Text::unnormalize( md[1], self )
+          # return PullEvent.new( :text, md[1], unnormalized )
+          return [ :text, md[1] ]
+        end
+      rescue REXML::ParseException
+        raise
+      rescue Exception, NameError => error
+        raise REXML::ParseException.new( "Exception parsing",
+                                         @source, self, (error ? error : $!) )
+      end
+      return [ :dummy ]
+    end
+  end
+
+end

data/lib/dryml/parser/document.rb

@@ -0,0 +1,57 @@
+module Dryml
+
+  module Parser
+
+    class Document < REXML::Document
+
+      def initialize(source, path)
+        super(nil)
+
+        # Replace <%...%> scriptlets with xml-safe references into a hash of scriptlets
+        @scriptlets = {}
+        source = source.gsub(/<%(.*?)%>/m) do
+          _, scriptlet = *Regexp.last_match
+          id = @scriptlets.size + 1
+          @scriptlets[id] = scriptlet
+          newlines = "\n" * scriptlet.count("\n")
+          "[![DRYML-ERB#{id}#{newlines}]!]"
+        end
+
+
+        @reference_src = "<dryml_page>" + source + "</dryml_page>"
+        rex_src = Dryml::Parser::Source.new(@reference_src)
+
+        @elements = Dryml::Parser::Elements.new(self)
+        build(rex_src)
+
+      rescue REXML::ParseException => e
+        raise Dryml::DrymlSyntaxError, "File: #{path}\n#{e}"
+      end
+
+
+      def element_line_num(el)
+        offset = el.source_offset
+        @reference_src[0..offset].count("\n") + 1
+      end
+
+
+      def default_attribute_value
+        "&true"
+      end
+
+
+      def restore_erb_scriptlets(src)
+        src.gsub(/\[!\[DRYML-ERB(\d+)\s*\]!\]/m) {|s| "<%#{@scriptlets[$1.to_i]}%>" }
+      end
+
+
+      private
+      def build( source )
+        Dryml::Parser::TreeParser.new( source, self ).parse
+      end
+
+    end
+
+  end
+
+end

data/lib/dryml/parser/element.rb

@@ -0,0 +1,27 @@
+module Dryml::Parser
+
+  class Element < REXML::Element
+
+    def initialize(*args)
+      super
+      @elements = Dryml::Parser::Elements.new(self)
+    end
+
+    def dryml_name
+      expanded_name.sub(/:.*/, "")
+    end
+
+    attr_accessor :start_tag_source, :source_offset
+
+    attr_writer :has_end_tag
+    def has_end_tag?
+      @has_end_tag
+    end
+
+    def parameter_tag?
+      expanded_name =~ /:$/
+    end
+
+  end
+
+end

data/lib/dryml/parser/elements.rb

@@ -0,0 +1,21 @@
+module Dryml::Parser
+
+  class Elements < REXML::Elements
+
+    # Override to ensure DRYML elements are created
+    def add(element=nil)
+      rv = nil
+      if element.nil?
+        Dryml::Parser::Element.new("", self, @element.context)
+      elsif not element.kind_of?(Element)
+        Dryml::Parser::Element.new(element, self, @element.context)
+      else
+        @element << element
+        element.context = @element.context
+        element
+      end
+    end
+
+  end
+
+end

data/lib/dryml/parser/source.rb

@@ -0,0 +1,58 @@
+module Dryml::Parser
+
+  # A REXML source that keeps track of where in the buffer it is
+  class Source < REXML::Source
+
+    def initialize(src)
+      super(src)
+      @buffer_offset = 0
+    end
+
+    attr_reader :last_match_offset
+
+    def remember_match(m)
+      if m
+        @last_match = m
+        @last_match_offset = @buffer_offset + m.begin(0)
+        @orig[@last_match_offset..@last_match_offset+m[0].length] == @buffer[m.begin(0)..m.end(0)]
+      end
+      m
+    end
+
+    def advance_buffer(md)
+      @buffer = md.post_match
+      @buffer_offset += md.end(0)
+    end
+
+    def scan(pattern, cons=false)
+      raise '!'
+      return nil if @buffer.nil?
+      rv = @buffer.scan(pattern)
+      if cons and rv.size > 0
+        advance_buffer(Regexp.last_match)
+      end
+      rv
+    end
+
+    def consume(pattern)
+      md = remember_match(pattern.match(@buffer))
+      if md
+        advance_buffer(md)
+        @buffer
+      end
+    end
+
+    def match(pattern, cons=false)
+      md = remember_match(pattern.match(@buffer))
+      advance_buffer(md) if cons and md
+      return md
+    end
+
+    def current_line
+      pos = last_match_offset || 0
+      [0, 0, @orig[0..pos].count("\n") + 1]
+    end
+
+  end
+
+end

data/lib/dryml/parser/text.rb

@@ -0,0 +1,13 @@
+module Dryml::Parser
+
+  class Text < REXML::Text
+
+    def parent=(parent)
+      # Bypass immediate super
+      REXML::Child.instance_method(:parent=).bind(self).call(parent)
+      Text.check(@string, /</, nil) if @raw and @parent && Text.respond_to?(:check)
+    end
+
+  end
+
+end

data/lib/dryml/parser/tree_parser.rb

@@ -0,0 +1,67 @@
+module Dryml::Parser
+
+  class TreeParser < REXML::Parsers::TreeParser
+    def initialize( source, build_context = Document.new )
+      @build_context = build_context
+      @parser = Dryml::Parser::BaseParser.new(source)
+    end
+
+
+    def parse
+      tag_stack = []
+      in_doctype = false
+      entities = nil
+      begin
+        while true
+          event = @parser.pull
+          #STDERR.puts "TREEPARSER GOT #{event.inspect}"
+          case event[0]
+          when :end_document
+            unless tag_stack.empty?
+              #raise ParseException.new("No close tag for #{tag_stack.inspect}")
+              raise ParseException.new("No close tag for #{@build_context.xpath}")
+            end
+            return
+          when :start_element
+            tag_stack.push(event[1])
+            el = @build_context = @build_context.add_element( event[1] )
+            event[2].each do |key, value|
+              el.attributes[key]=Dryml::Parser::Attribute.new(key,value,self)
+            end
+            @build_context.start_tag_source = event[3]
+            @build_context.source_offset = event[4]
+          when :end_element
+            tag_stack.pop
+            @build_context.has_end_tag = event[2]
+            @build_context = @build_context.parent
+          when :text
+            if not in_doctype
+              if @build_context[-1].instance_of? Text
+                @build_context[-1] << event[1]
+              else
+                @build_context.add(
+                                   Dryml::Parser::Text.new(event[1], @build_context.whitespace, nil, true)
+                                   ) unless (
+                                             @build_context.ignore_whitespace_nodes and
+                                             event[1].strip.size==0
+                                             )
+              end
+            end
+          when :comment
+            c = REXML::Comment.new( event[1] )
+            @build_context.add( c )
+          when :cdata
+            c = REXML::CData.new( event[1] )
+            @build_context.add( c )
+          when :processing_instruction
+            @build_context.add( Instruction.new( event[1], event[2] ) )
+          end
+        end
+      rescue REXML::Validation::ValidationException
+        raise
+      rescue
+        raise REXML::ParseException.new( $!.message, @parser.source, @parser, $! )
+      end
+    end
+  end
+end

data/lib/dryml/parser.rb

@@ -0,0 +1,3 @@
+module Dryml::Parser
+
+end