hobo 1.0.3 → 1.1.0.pre0

data/lib/hobo/dryml/parser/document.rb

@@ -1,57 +0,0 @@
-module Hobo::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 = Hobo::Dryml::Parser::Source.new(@reference_src)
-
-        @elements = Hobo::Dryml::Parser::Elements.new(self)
-        build(rex_src)
-
-      rescue REXML::ParseException => e
-        raise Hobo::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 )
-        Hobo::Dryml::Parser::TreeParser.new( source, self ).parse
-      end
-
-    end
-
-  end
-
-end

data/lib/hobo/dryml/parser/element.rb

@@ -1,27 +0,0 @@
-module Hobo::Dryml::Parser
-
-  class Element < REXML::Element
-
-    def initialize(*args)
-      super
-      @elements = Hobo::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/hobo/dryml/parser/elements.rb

@@ -1,45 +0,0 @@
-module Hobo::Dryml::Parser
-
-  class Element < REXML::Element
-
-    def initialize(*args)
-      super
-      @elements = Hobo::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
-
-  class Elements < REXML::Elements
-
-    # Override to ensure DRYML elements are created
-    def add(element=nil)
-      rv = nil
-      if element.nil?
-        Hobo::Dryml::Parser::Element.new("", self, @element.context)
-      elsif not element.kind_of?(Element)
-        Hobo::Dryml::Parser::Element.new(element, self, @element.context)
-      else
-        @element << element
-        element.context = @element.context
-        element
-      end
-    end
-
-  end
-
-end

data/lib/hobo/dryml/parser/source.rb

@@ -1,58 +0,0 @@
-module Hobo::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/hobo/dryml/parser/text.rb

@@ -1,13 +0,0 @@
-module Hobo::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/hobo/dryml/parser/tree_parser.rb

@@ -1,67 +0,0 @@
-module Hobo::Dryml::Parser
-
-  class TreeParser < REXML::Parsers::TreeParser
-    def initialize( source, build_context = Document.new )
-      @build_context = build_context
-      @parser = Hobo::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]=Hobo::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(
-                                   Hobo::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/hobo/dryml/part_context.rb

@@ -1,137 +0,0 @@
-module Hobo
-
-  module Dryml
-
-    # Raised when the part context fails its integrity check.
-    class PartContext
-
-      class TamperedWithPartContext < StandardError; end
-
-      class TypedId < String; end
-
-      class << self
-        attr_accessor :secret, :digest
-      end
-      self.digest = 'SHA1'
-
-
-      def self.client_side_storage(contexts, session)
-        return "" if contexts.empty?
-
-        contexts.map do |dom_id, context|
-          code = context.marshal(session).split("\n").map{|line| "'#{line}\\n'"}.join(" +\n    ")
-          "hoboParts['#{dom_id}'] = (#{code});\n"
-        end.join
-      end
-      
-      
-      def self.pre_marshal(x)
-        if x.is_a?(ActiveRecord::Base) && x.respond_to?(:typed_id)
-          TypedId.new(x.typed_id)
-        else
-          x
-        end
-      end
-
-
-      def self.for_call(part_name, environment, locals)
-        new do |c|
-          c.part_name       = part_name
-          c.locals          = locals.map { |l| pre_marshal(l) }
-          c.this_id         = environment.typed_id
-          c.form_field_path = environment.form_field_path
-        end
-      end
-      
-      
-      def self.for_refresh(encoded_context, page_this, session)
-        new do |c|
-          c.unmarshal(encoded_context, page_this, session)
-        end
-      end
-      
-      
-      def initialize
-        yield self
-      end
-      
-      attr_accessor :part_name, :locals, :this, :this_field, :this_id, :form_field_path
-
-
-      def marshal(session)
-        context = [@part_name, @this_id, @locals]
-        context << form_field_path if form_field_path
-        data = Base64.encode64(Marshal.dump(context)).strip
-        digest = generate_digest(data, session)
-        "#{data}--#{digest}"
-      end
-
-
-      # Unmarshal part context to a hash and verify its integrity.
-      def unmarshal(client_store, page_this, session)
-        data, digest = CGI.unescape(client_store).strip.split('--')
-
-        raise TamperedWithPartContext unless digest == generate_digest(data, session)
-
-        context = Marshal.load(Base64.decode64(data))
-        
-        part_name, this_id, locals, form_field_path = context
-
-        if RAILS_DEFAULT_LOGGER
-          RAILS_DEFAULT_LOGGER.info "Call part: #{part_name}. this-id = #{this_id}, locals = #{locals.inspect}"
-          RAILS_DEFAULT_LOGGER.info "         : form_field_path = #{form_field_path.inspect}" if form_field_path
-        end
-        
-        self.part_name             = part_name
-        self.this_id               = this_id
-        self.locals                = restore_locals(locals)
-        self.form_field_path       = form_field_path
-        
-        parse_this_id(page_this)        
-      end
-
-
-      # Generate the HMAC keyed message digest. Uses SHA1 by default.
-      def generate_digest(data, session)
-        secret = self.class.secret || ActionController::Base.session_options[:secret] || ActionController::Base.cached_session_options.first[:secret]
-        key = secret.respond_to?(:call) ? secret.call(session) : secret
-        OpenSSL::HMAC.hexdigest(OpenSSL::Digest::Digest.new(self.class.digest), key, data)
-      end
-
-
-
-      def parse_this_id(page_this)
-        if this_id == "this"
-          self.this = page_this
-        elsif this_id =~ /^this:(.*)/
-          self.this = page_this
-          self.this_field = $1
-        elsif this_id == "nil"
-          nil
-        else
-          parts = this_id.split(':')
-          if parts.length == 3
-            self.this       = Hobo::Model.find_by_typed_id("#{parts[0]}:#{parts[1]}")
-            self.this_field = parts[2]
-          else
-            self.this = Hobo::Model.find_by_typed_id(this_id)
-          end
-        end
-      end
-
-
-      def restore_locals(locals)
-        locals.map do |l|
-          if l.is_a?(TypedId)
-            Hobo::Model.find_by_typed_id(l)
-          else
-            l
-          end
-        end
-      end
-
-    end
-
-  end
-
-end

data/lib/hobo/dryml/scoped_variables.rb

@@ -1,42 +0,0 @@
-module Hobo::Dryml
-
-  class ScopedVariables
-
-    def initialize(variables=nil)
-      @scopes = variables ? [variables] : []
-    end
-
-    def [](key)
-     s = scope_with_key(key) and s[key]
-    end
-
-    def []=(key, val)
-      s = scope_with_key(key) or raise ArgumentError, "no such scoped variable: #{key}"
-      s[key] = val
-    end
-
-    def new_scope(variables)
-      @scopes << variables.dup
-      res = yield
-      @scopes.pop
-      res
-    end
-
-    def scope_with_key(key)
-      @scopes.reverse_each do |s|
-        return s if s.has_key?(key)
-      end
-      nil
-    end
-
-    def method_missing(name, *args)
-      if name.to_s =~ /=$/
-        self[name.to_s[0..-2].to_sym] = args.first
-      else
-        self[name]
-      end
-    end
-
-  end
-
-end