ruby_on_ruby 0.0.1

data/vendor/javascripts/emscripted-ruby/lib/rexml/encodings/UTF-8.rb

@@ -0,0 +1,18 @@
+module REXML
+  module Encoding
+    def encode_utf8 content
+      content
+    end
+
+    def decode_utf8(str)
+      str
+    end
+
+    register(UTF_8) do |obj|
+      class << obj
+        alias decode decode_utf8
+        alias encode encode_utf8
+      end
+    end
+  end
+end

data/vendor/javascripts/emscripted-ruby/lib/rexml/entity.rb

@@ -0,0 +1,165 @@
+require 'rexml/child'
+require 'rexml/source'
+require 'rexml/xmltokens'
+
+module REXML
+	# God, I hate DTDs.  I really do.  Why this idiot standard still
+	# plagues us is beyond me.
+	class Entity < Child
+		include XMLTokens
+		PUBIDCHAR = "\x20\x0D\x0Aa-zA-Z0-9\\-()+,./:=?;!*@$_%#"
+		SYSTEMLITERAL = %Q{((?:"[^"]*")|(?:'[^']*'))}
+		PUBIDLITERAL = %Q{("[#{PUBIDCHAR}']*"|'[#{PUBIDCHAR}]*')}
+		EXTERNALID = "(?:(?:(SYSTEM)\\s+#{SYSTEMLITERAL})|(?:(PUBLIC)\\s+#{PUBIDLITERAL}\\s+#{SYSTEMLITERAL}))"
+		NDATADECL = "\\s+NDATA\\s+#{NAME}"
+		PEREFERENCE = "%#{NAME};"
+		ENTITYVALUE = %Q{((?:"(?:[^%&"]|#{PEREFERENCE}|#{REFERENCE})*")|(?:'([^%&']|#{PEREFERENCE}|#{REFERENCE})*'))}
+		PEDEF = "(?:#{ENTITYVALUE}|#{EXTERNALID})"
+		ENTITYDEF = "(?:#{ENTITYVALUE}|(?:#{EXTERNALID}(#{NDATADECL})?))"
+		PEDECL = "<!ENTITY\\s+(%)\\s+#{NAME}\\s+#{PEDEF}\\s*>"
+		GEDECL = "<!ENTITY\\s+#{NAME}\\s+#{ENTITYDEF}\\s*>"
+		ENTITYDECL = /\s*(?:#{GEDECL})|(?:#{PEDECL})/um
+
+		attr_reader :name, :external, :ref, :ndata, :pubid
+
+		# Create a new entity.  Simple entities can be constructed by passing a
+		# name, value to the constructor; this creates a generic, plain entity
+		# reference. For anything more complicated, you have to pass a Source to
+		# the constructor with the entity definiton, or use the accessor methods.
+		# +WARNING+: There is no validation of entity state except when the entity
+		# is read from a stream.  If you start poking around with the accessors,
+		# you can easily create a non-conformant Entity.  The best thing to do is
+		# dump the stupid DTDs and use XMLSchema instead.
+		# 
+		#  e = Entity.new( 'amp', '&' )
+		def initialize stream, value=nil, parent=nil, reference=false
+			super(parent)
+			@ndata = @pubid = @value = @external = nil
+			if stream.kind_of? Array
+				@name = stream[1]
+				if stream[-1] == '%'
+					@reference = true 
+					stream.pop
+				else
+					@reference = false
+				end
+				if stream[2] =~ /SYSTEM|PUBLIC/
+					@external = stream[2]
+					if @external == 'SYSTEM'
+						@ref = stream[3]
+						@ndata = stream[4] if stream.size == 5
+					else
+						@pubid = stream[3]
+						@ref = stream[4]
+					end
+				else
+					@value = stream[2]
+				end
+			else
+				@reference = reference
+				@external = nil
+				@name = stream
+				@value = value
+			end
+		end
+
+		# Evaluates whether the given string matchs an entity definition,
+		# returning true if so, and false otherwise.
+		def Entity::matches? string
+			(ENTITYDECL =~ string) == 0
+		end
+
+		# Evaluates to the unnormalized value of this entity; that is, replacing
+		# all entities -- both %ent; and &ent; entities.  This differs from
+		# +value()+ in that +value+ only replaces %ent; entities.
+		def unnormalized
+			v = value()
+			return nil if v.nil?
+			@unnormalized = Text::unnormalize(v, parent)
+			@unnormalized
+		end
+
+		#once :unnormalized
+
+		# Returns the value of this entity unprocessed -- raw.  This is the
+		# normalized value; that is, with all %ent; and &ent; entities intact
+		def normalized
+			@value
+		end
+
+		# Write out a fully formed, correct entity definition (assuming the Entity
+		# object itself is valid.)
+    #
+    # out::
+    #   An object implementing <TT>&lt;&lt;<TT> to which the entity will be
+    #   output
+    # indent::
+    #   *DEPRECATED* and ignored
+		def write out, indent=-1
+			out << '<!ENTITY '
+			out << '% ' if @reference
+			out << @name
+			out << ' '
+			if @external
+				out << @external << ' '
+				if @pubid
+					q = @pubid.include?('"')?"'":'"'
+					out << q << @pubid << q << ' '
+				end
+				q = @ref.include?('"')?"'":'"'
+				out << q << @ref << q
+				out << ' NDATA ' << @ndata if @ndata
+			else
+				q = @value.include?('"')?"'":'"'
+				out << q << @value << q
+			end
+			out << '>'
+		end
+
+		# Returns this entity as a string.  See write().
+		def to_s
+			rv = ''
+			write rv
+			rv
+		end
+
+		PEREFERENCE_RE = /#{PEREFERENCE}/um
+		# Returns the value of this entity.  At the moment, only internal entities
+		# are processed.  If the value contains internal references (IE,
+		# %blah;), those are replaced with their values.  IE, if the doctype
+		# contains:
+		#  <!ENTITY % foo "bar">
+		#  <!ENTITY yada "nanoo %foo; nanoo>
+		# then:
+		#  doctype.entity('yada').value   #-> "nanoo bar nanoo"
+		def value
+			if @value
+				matches = @value.scan(PEREFERENCE_RE)
+				rv = @value.clone
+				if @parent
+					matches.each do |entity_reference|
+						entity_value = @parent.entity( entity_reference[0] )
+						rv.gsub!( /%#{entity_reference};/um, entity_value )
+					end
+				end
+				return rv
+			end
+			nil
+		end
+	end
+
+	# This is a set of entity constants -- the ones defined in the XML
+	# specification.  These are +gt+, +lt+, +amp+, +quot+ and +apos+.
+	module EntityConst
+		# +>+
+		GT = Entity.new( 'gt', '>' )
+		# +<+
+		LT = Entity.new( 'lt', '<' )
+		# +&+
+		AMP = Entity.new( 'amp', '&' )
+		# +"+
+		QUOT = Entity.new( 'quot', '"' )
+		# +'+
+		APOS = Entity.new( 'apos', "'" )
+	end
+end

data/vendor/javascripts/emscripted-ruby/lib/rexml/formatters/default.rb

@@ -0,0 +1,109 @@
+module REXML
+  module Formatters
+    class Default
+      # Prints out the XML document with no formatting -- except if id_hack is
+      # set.
+      #
+      # ie_hack::
+      #   If set to true, then inserts whitespace before the close of an empty
+      #   tag, so that IE's bad XML parser doesn't choke.
+      def initialize( ie_hack=false )
+        @ie_hack = ie_hack
+      end
+
+      # Writes the node to some output.
+      #
+      # node::
+      #   The node to write
+      # output::
+      #   A class implementing <TT>&lt;&lt;</TT>.  Pass in an Output object to
+      #   change the output encoding.
+      def write( node, output )
+        case node
+
+        when Document 
+          if node.xml_decl.encoding != "UTF-8" && !output.kind_of?(Output)
+            output = Output.new( output, node.xml_decl.encoding )
+          end
+          write_document( node, output )
+
+        when Element
+          write_element( node, output )
+
+        when Declaration, ElementDecl, NotationDecl, ExternalEntity, Entity,
+             Attribute, AttlistDecl
+          node.write( output,-1 )
+
+        when Instruction
+          write_instruction( node, output )
+
+        when DocType, XMLDecl
+          node.write( output )
+
+        when Comment
+          write_comment( node, output )
+
+        when CData
+          write_cdata( node, output )
+
+        when Text
+          write_text( node, output )
+
+        else
+          raise Exception.new("XML FORMATTING ERROR")
+
+        end
+      end
+
+      protected
+      def write_document( node, output )
+        node.children.each { |child| write( child, output ) }
+      end
+
+      def write_element( node, output )
+        output << "<#{node.expanded_name}"
+
+        node.attributes.each_attribute do |attr|
+          output << " "
+          attr.write( output )
+        end unless node.attributes.empty?
+
+        if node.children.empty?
+          output << " " if @ie_hack
+          output << "/" 
+        else
+          output << ">"
+          node.children.each { |child|
+            write( child, output )
+          }
+          output << "</#{node.expanded_name}"
+        end
+        output << ">"
+      end
+
+      def write_text( node, output )
+        output << node.to_s()
+      end
+
+      def write_comment( node, output )
+        output << Comment::START
+        output << node.to_s
+        output << Comment::STOP
+      end
+
+      def write_cdata( node, output )
+        output << CData::START
+        output << node.to_s
+        output << CData::STOP
+      end
+
+      def write_instruction( node, output )
+        output << Instruction::START.sub(/\\/u, '')
+        output << node.target
+        output << ' '
+        output << node.content
+        output << Instruction::STOP.sub(/\\/u, '')
+      end
+    end
+  end
+end

data/vendor/javascripts/emscripted-ruby/lib/rexml/formatters/pretty.rb

@@ -0,0 +1,137 @@
+require 'rexml/formatters/default'
+
+module REXML
+  module Formatters
+    # Pretty-prints an XML document.  This destroys whitespace in text nodes
+    # and will insert carriage returns and indentations.
+    #
+    # TODO: Add an option to print attributes on new lines
+    class Pretty < Default
+
+      # If compact is set to true, then the formatter will attempt to use as
+      # little space as possible
+      attr_accessor :compact
+      # The width of a page.  Used for formatting text
+      attr_accessor :width
+
+      # Create a new pretty printer.
+      #
+      # output::
+      #   An object implementing '<<(String)', to which the output will be written.
+      # indentation::
+      #   An integer greater than 0.  The indentation of each level will be
+      #   this number of spaces.  If this is < 1, the behavior of this object
+      #   is undefined.  Defaults to 2.
+      # ie_hack::
+      #   If true, the printer will insert whitespace before closing empty
+      #   tags, thereby allowing Internet Explorer's feeble XML parser to
+      #   function. Defaults to false.
+      def initialize( indentation=2, ie_hack=false )
+        @indentation = indentation
+        @level = 0
+        @ie_hack = ie_hack
+        @width = 80
+      end
+
+      protected
+      def write_element(node, output)
+        output << ' '*@level
+        output << "<#{node.expanded_name}"
+
+        node.attributes.each_attribute do |attr|
+          output << " "
+          attr.write( output )
+        end unless node.attributes.empty?
+
+        if node.children.empty?
+          if @ie_hack
+            output << " "
+          end
+          output << "/" 
+        else
+          output << ">"
+          # If compact and all children are text, and if the formatted output
+          # is less than the specified width, then try to print everything on
+          # one line
+          skip = false
+          if compact
+            if node.children.inject(true) {|s,c| s & c.kind_of?(Text)}
+              string = ""
+              old_level = @level
+              @level = 0
+              node.children.each { |child| write( child, string ) }
+              @level = old_level
+              if string.length < @width
+                output << string
+                skip = true
+              end
+            end
+          end
+          unless skip
+            output << "\n"
+            @level += @indentation
+            node.children.each { |child|
+              next if child.kind_of?(Text) and child.to_s.strip.length == 0
+              write( child, output )
+              output << "\n"
+            }
+            @level -= @indentation
+            output << ' '*@level
+          end
+          output << "</#{node.expanded_name}"
+        end
+        output << ">"
+      end
+
+      def write_text( node, output )
+        s = node.to_s()
+        s.gsub!(/\s/,' ')
+        s.squeeze!(" ")
+        s = wrap(s, 80-@level)
+        s = indent_text(s, @level, " ", true)
+        output << (' '*@level + s)
+      end
+
+      def write_comment( node, output)
+        output << ' ' * @level
+        super
+      end
+
+      def write_cdata( node, output)
+        output << ' ' * @level
+        super
+      end
+
+      def write_document( node, output )
+        # Ok, this is a bit odd.  All XML documents have an XML declaration,
+        # but it may not write itself if the user didn't specifically add it,
+        # either through the API or in the input document.  If it doesn't write
+        # itself, then we don't need a carriage return... which makes this
+        # logic more complex.
+        node.children.each { |child|
+          next if child == node.children[-1] and child.instance_of?(Text)
+          unless child == node.children[0] or child.instance_of?(Text) or
+            (child == node.children[1] and !node.children[0].writethis)
+            output << "\n"
+          end
+          write( child, output )
+        }
+      end
+
+      private
+      def indent_text(string, level=1, style="\t", indentfirstline=true)
+        return string if level < 0
+        string.gsub(/\n/, "\n#{style*level}")
+      end
+
+      def wrap(string, width)
+        # Recursivly wrap string at width.
+        return string if string.length <= width
+        place = string.rindex(' ', width) # Position in string with last ' ' before cutoff
+        return string[0,place] + "\n" + wrap(string[place+1..-1], width)
+      end
+
+    end
+  end
+end
+

data/vendor/javascripts/emscripted-ruby/lib/rexml/formatters/transitive.rb

@@ -0,0 +1,56 @@
+require 'rexml/formatters/pretty'
+
+module REXML
+  module Formatters
+    # The Transitive formatter writes an XML document that parses to an
+    # identical document as the source document.  This means that no extra
+    # whitespace nodes are inserted, and whitespace within text nodes is
+    # preserved.  Within these constraints, the document is pretty-printed,
+    # with whitespace inserted into the metadata to introduce formatting.
+    #
+    # Note that this is only useful if the original XML is not already
+    # formatted.  Since this formatter does not alter whitespace nodes, the
+    # results of formatting already formatted XML will be odd.
+    class Transitive < Default
+      def initialize( indentation=2 )
+        @indentation = indentation
+        @level = 0
+      end
+
+      protected
+      def write_element( node, output )
+        output << "<#{node.expanded_name}"
+
+        node.attributes.each_attribute do |attr|
+          output << " "
+          attr.write( output )
+        end unless node.attributes.empty?
+
+        output << "\n"
+        output << ' '*@level
+        if node.children.empty?
+          output << "/" 
+        else
+          output << ">"
+          # If compact and all children are text, and if the formatted output
+          # is less than the specified width, then try to print everything on
+          # one line
+          skip = false
+          @level += @indentation
+          node.children.each { |child|
+            write( child, output )
+          }
+          @level -= @indentation
+          output << "</#{node.expanded_name}"
+          output << "\n"
+          output << ' '*@level
+        end
+        output << ">"
+      end
+
+      def write_text( node, output )
+        output << node.to_s()
+      end
+    end
+  end
+end