hobo 0.5.3

data/hobo_files/plugin/lib/hobo/static_tags

@@ -0,0 +1,92 @@
+a
+abbr
+acronym
+address
+applet
+area
+b
+base
+basefont
+bdo
+big
+blockquote
+body
+br
+button
+caption
+center
+cite
+code
+col
+colgroup
+dd
+del
+dfn
+dir
+div
+dl
+dt
+em
+embed
+fieldset
+font
+form
+frame
+frameset
+h1
+h2
+h3
+h4
+h5
+h6
+head
+hr
+html
+i
+iframe
+img
+input
+ins
+isindex
+kbd
+label
+legend
+li
+link
+map
+menu
+meta
+noframes
+noscript
+object
+ol
+optgroup
+option
+p
+param
+pre
+q
+s
+samp
+script
+select
+small
+span
+strike
+strong
+style
+sub
+sup
+table
+tbody
+td
+textarea
+tfoot
+th
+thead
+title
+tr
+tt
+u
+ul
+var

data/hobo_files/plugin/lib/hobo/text.rb

@@ -0,0 +1,3 @@
+class Hobo::Text < String
+  
+end

data/hobo_files/plugin/lib/hobo/textile_string.rb

@@ -0,0 +1,13 @@
+class Hobo::TextileString < String
+
+  def to_html
+    if text.blank?
+      ""
+    else
+      textilized = RedCloth.new(self, [ :hard_breaks ])
+      textilized.hard_breaks = true if textilized.respond_to?("hard_breaks=")
+      textilized.to_html
+    end
+  end  
+  
+end

data/hobo_files/plugin/lib/hobo/undefined.rb

@@ -0,0 +1,41 @@
+module Hobo
+
+  class Undefined
+
+    def initialize(klass=Object)
+      @klass = klass
+    end
+
+    def hobo_undefined?
+      true
+    end
+
+    def class
+      @klass
+    end
+
+    def is_a?(klass)
+      return klass == @klass || klass > @klass
+    end
+
+    def to_s
+      "<Hobo::Undefined #{@klass}>"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def new_record?
+      true
+    end
+
+    def method_missing(name, *args)
+      raise UndefinedAccessError.new("call to: #{name}")
+    end
+    
+    undef_method :==
+
+  end
+
+end

data/hobo_files/plugin/lib/hobo/undefined_access_error.rb

@@ -0,0 +1,5 @@
+module Hobo
+
+  class UndefinedAccessError < RuntimeError; end
+
+end

data/hobo_files/plugin/lib/hobo/where_fragment.rb

@@ -0,0 +1,23 @@
+module Hobo
+
+  class WhereFragment
+
+    def initialize(sql, *params)
+      @sql = params.empty? ? sql : ActiveRecord::Base.send(:sanitize_sql, [sql] + params)
+    end
+
+    def &(rhs)
+      WhereFragment.new("(#{to_sql}) and (#{rhs.to_sql})")
+    end
+
+    def |(rhs)
+      WhereFragment.new("(#{to_sql}) or (#{rhs.to_sql})")
+    end
+
+    def to_sql
+      @sql
+    end
+
+  end
+
+end

data/hobo_files/plugin/lib/rexml.rb

@@ -0,0 +1,345 @@
+# Hobo needs to process XML as transparently as possibe. In the case of tags
+# that are not defined by hobo (i.e. html tags), they should pass through just
+# as they were in the dryml source. Recontructing the tags from the DOM is not
+# good enough. The extensions to REXML in here allow Hobo to use the original
+# start tag source in the output.
+# There's also some fixes/extras to allow error messages with line numbers.
+
+# The main hack is that Element nodes have two instance variables added:
+#   @start_tag_source and @source_offset
+
+# So cool that Ruby allows us to redfine a method. Such a shame the method
+# happened to be 200 lines long :-(
+
+require 'rexml/document'
+
+module REXML
+  module Parsers
+    class BaseParser
+      def pull
+        if @closed
+          x, @closed = @closed, nil
+          return [ :end_element, x ]
+        end
+        return [ :end_document ] if empty?
+        return @stack.shift if @stack.size > 0
+        @source.read if @source.buffer.size<2
+        if @document_status == nil
+          @source.consume( /^\s*/um )
+          word = @source.match( /(<[^>]*)>/um )
+          word = word[1] unless word.nil?
+          case word
+          when COMMENT_START
+            return [ :comment, @source.match( COMMENT_PATTERN, true )[1] ]
+          when XMLDECL_START
+            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 )
+            identity = md[1]
+            close = md[2]
+            identity =~ IDENTITY
+            name = $1
+            raise REXML::ParseException("DOCTYPE is missing a name") if name.nil?
+            pub_sys = $2.nil? ? nil : $2.strip
+            long_name = $3.nil? ? nil : $3.strip
+            uri = $4.nil? ? nil : $4.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
+          else
+            @document_status = :after_doctype
+            @source.read if @source.buffer.size<2
+            md = @source.match(/\s*/um, true)
+          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
+              end
+            end
+            return [ :attlistdecl, element, pairs, contents ]
+          when NOTATIONDECL_START
+            md = nil
+            if @source.match( PUBLIC )
+              md = @source.match( PUBLIC, true )
+            elsif @source.match( SYSTEM )
+              md = @source.match( SYSTEM, true )
+            else
+              raise REXML::ParseException.new( "error parsing notation: no matching pattern", @source )
+            end
+            return [ :notationdecl, md[1], md[2], md[3] ]
+          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] == ?/
+              last_tag, line_no = @tags.pop
+              #md = @source.match_to_consume( '>', CLOSE_MATCH)
+              md = @source.match( CLOSE_MATCH, true )
+              raise REXML::ParseException.new("Missing end tag for "+
+                                              "'#{last_tag}' (line #{line_no}) (got \"#{md[1]}\")", 
+                @source) unless last_tag == md[1]
+              return [ :end_element, last_tag ]
+            elsif @source.buffer[1] == ?!
+              md = @source.match(/\A(\s*[^>]*>)/um)
+              raise REXML::ParseException.new("Malformed node", @source) unless md
+              if md[0][2] == ?-
+                md = @source.match( COMMENT_PATTERN, true )
+                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(TAG_MATCH, true)
+              raise REXML::ParseException.new("malformed XML: missing tag start", @source) unless md
+              attrs = []
+              if md[2].size > 0
+                attrs = md[2].scan( ATTRIBUTE_PATTERN )
+                raise REXML::ParseException.new("error parsing attributes: [#{attrs.join ', '}], excess = \"#$'\"",
+                                                @source) if $' and $'.strip.size > 0
+              end
+        
+              if md[4]
+                @closed = md[1]
+              else
+                cl = @source.current_line
+                @tags.push([md[1], cl && cl[2]])
+              end
+              attributes = {}
+              attrs.each { |a,b,c| attributes[a] = c }
+              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
+            #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
+
+    class TreeParser
+      def parse
+        tag_stack = []
+        in_doctype = false
+        entities = nil
+        begin
+          while true
+            event = @parser.pull
+            case event[0]
+            when :end_document
+              return
+            when :start_element
+              tag_stack.push(event[1])
+              # find the observers for namespaces
+              @build_context = @build_context.add_element( event[1], event[2] )
+              @build_context.instance_variable_set("@start_tag_source", event[3])
+              @build_context.instance_variable_set("@source_offset", event[4])
+            when :end_element
+              tag_stack.pop
+              @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( 
+                    Text.new( event[1], @build_context.whitespace, nil, true ) 
+                  ) unless (
+                    event[1].strip.size==0 and 
+                    @build_context.ignore_whitespace_nodes
+                  )
+                end
+              end
+            when :comment
+              c = Comment.new( event[1] )
+              @build_context.add( c )
+            when :cdata
+              c = CData.new( event[1] )
+              @build_context.add( c )
+            when :processing_instruction
+              @build_context.add( Instruction.new( event[1], event[2] ) )
+            when :end_doctype
+              in_doctype = false
+              entities.each { |k,v| entities[k] = @build_context.entities[k].value }
+              @build_context = @build_context.parent
+            when :start_doctype
+              doctype = DocType.new( event[1..-1], @build_context )
+              @build_context = doctype
+              entities = {}
+              in_doctype = true
+            when :attlistdecl
+              n = AttlistDecl.new( event[1..-1] )
+              @build_context.add( n )
+            when :externalentity
+              n = ExternalEntity.new( event[1] )
+              @build_context.add( n )
+            when :elementdecl
+              n = ElementDecl.new( event[1] )
+              @build_context.add(n)
+            when :entitydecl
+              entities[ event[1] ] = event[2] unless event[2] =~ /PUBLIC|SYSTEM/
+              @build_context.add(Entity.new(event))
+            when :notationdecl
+              n = NotationDecl.new( *event[1..-1] )
+              @build_context.add( n )
+            when :xmldecl
+              x = XMLDecl.new( event[1], event[2], event[3] )
+              @build_context.add( x )
+            end
+          end
+        rescue REXML::Validation::ValidationException
+          raise
+        rescue
+          raise ParseException.new( $!.message, @parser.source, @parser, $! )
+        end
+      end
+    end
+  end
+end
+
+module Hobo::Dryml
+
+  class RexSource < 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, @orig[0..pos].count("\n") + 1]
+    end
+
+  end
+end