rubysl-rexml 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e77bc3d878fd21ec47c298c95206f0a123b0ecdd
+  data.tar.gz: a737cd6cf7249364bb1d9e0b21f509440dbeefeb
+SHA512:
+  metadata.gz: 8223bf80e756128360ce2d16e933e2a0d26c072e60f79a0eef1806711dbe375483a9680212390c7bb3dff1fe66a3aa4085ce5fc92729b6913937c79c8a89ebea
+  data.tar.gz: 14b5508fa353ddb7ae50ba4d72c482f30f75d2e79595f5eea54ea0f5aecc9663811b323a9599d79e6af23772045e1c2bf24f320d9a8c028b5c73a8f4df3c1e64

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+before_install:
+  - gem update --system
+  - gem --version
+  - gem install rubysl-bundler
+script: bundle exec mspec spec
+rvm:
+  - rbx-nightly-18mode

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rubysl-rexml.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) 2013, Brian Shirai
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+3. Neither the name of the library nor the names of its contributors may be
+   used to endorse or promote products derived from this software without
+   specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,29 @@
+# Rubysl::Rexml
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rubysl-rexml'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rubysl-rexml
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/rexml/attlistdecl.rb

@@ -0,0 +1,62 @@
+#vim:ts=2 sw=2 noexpandtab:
+require 'rexml/child'
+require 'rexml/source'
+
+module REXML
+	# This class needs:
+	# * Documentation
+	# * Work!  Not all types of attlists are intelligently parsed, so we just
+	# spew back out what we get in.  This works, but it would be better if
+	# we formatted the output ourselves.
+	#
+	# AttlistDecls provide *just* enough support to allow namespace
+	# declarations.  If you need some sort of generalized support, or have an
+	# interesting idea about how to map the hideous, terrible design of DTD
+	# AttlistDecls onto an intuitive Ruby interface, let me know.  I'm desperate
+	# for anything to make DTDs more palateable.
+	class AttlistDecl < Child
+		include Enumerable
+
+		# What is this?  Got me.
+		attr_reader :element_name
+
+		# Create an AttlistDecl, pulling the information from a Source.  Notice
+		# that this isn't very convenient; to create an AttlistDecl, you basically
+		# have to format it yourself, and then have the initializer parse it.
+		# Sorry, but for the forseeable future, DTD support in REXML is pretty
+		# weak on convenience.  Have I mentioned how much I hate DTDs?
+		def initialize(source)
+			super()
+			if (source.kind_of? Array)
+				@element_name, @pairs, @contents = *source
+			end
+		end
+	
+		# Access the attlist attribute/value pairs.
+		#  value = attlist_decl[ attribute_name ]
+		def [](key)
+			@pairs[key]
+		end
+
+		# Whether an attlist declaration includes the given attribute definition
+		#  if attlist_decl.include? "xmlns:foobar"
+		def include?(key)
+			@pairs.keys.include? key
+		end
+
+		# Iterate over the key/value pairs:
+		#  attlist_decl.each { |attribute_name, attribute_value| ... }
+		def each(&block)
+			@pairs.each(&block)
+		end
+
+		# Write out exactly what we got in.
+		def write out, indent=-1
+			out << @contents
+		end
+
+		def node_type
+			:attlistdecl
+		end
+	end
+end

data/lib/rexml/attribute.rb

@@ -0,0 +1,185 @@
+require "rexml/namespace"
+require 'rexml/text'
+
+module REXML
+	# Defines an Element Attribute; IE, a attribute=value pair, as in:
+	# <element attribute="value"/>.  Attributes can be in their own
+	# namespaces.  General users of REXML will not interact with the
+	# Attribute class much.
+	class Attribute
+		include Node
+		include Namespace
+
+		# The element to which this attribute belongs
+		attr_reader :element
+		# The normalized value of this attribute.  That is, the attribute with
+		# entities intact.
+		attr_writer :normalized	
+		PATTERN = /\s*(#{NAME_STR})\s*=\s*(["'])(.*?)\2/um
+
+		# Constructor.
+    # FIXME: The parser doesn't catch illegal characters in attributes
+    #
+    # first:: 
+    #   Either: an Attribute, which this new attribute will become a
+    #   clone of; or a String, which is the name of this attribute
+    # second::
+    #   If +first+ is an Attribute, then this may be an Element, or nil.
+    #   If nil, then the Element parent of this attribute is the parent
+    #   of the +first+ Attribute.  If the first argument is a String, 
+    #   then this must also be a String, and is the content of the attribute.  
+    #   If this is the content, it must be fully normalized (contain no
+    #   illegal characters).
+    # parent::
+    #   Ignored unless +first+ is a String; otherwise, may be the Element 
+    #   parent of this attribute, or nil.
+    #
+		#
+		#  Attribute.new( attribute_to_clone )
+		#  Attribute.new( attribute_to_clone, parent_element )
+		#  Attribute.new( "attr", "attr_value" )
+		#  Attribute.new( "attr", "attr_value", parent_element )
+		def initialize( first, second=nil, parent=nil )
+			@normalized = @unnormalized = @element = nil
+			if first.kind_of? Attribute
+				self.name = first.expanded_name
+				@unnormalized = first.value
+				if second.kind_of? Element
+					@element = second
+				else
+					@element = first.element
+				end
+			elsif first.kind_of? String
+				@element = parent
+				self.name = first
+				@normalized = second.to_s
+			else
+				raise "illegal argument #{first.class.name} to Attribute constructor"
+			end
+		end
+
+		# Returns the namespace of the attribute.
+		# 
+		#  e = Element.new( "elns:myelement" )
+		#  e.add_attribute( "nsa:a", "aval" )
+		#  e.add_attribute( "b", "bval" )
+		#  e.attributes.get_attribute( "a" ).prefix   # -> "nsa"
+		#  e.attributes.get_attribute( "b" ).prefix   # -> "elns"
+		#  a = Attribute.new( "x", "y" )
+		#  a.prefix                                   # -> ""
+		def prefix
+			pf = super
+			if pf == ""
+				pf = @element.prefix if @element
+			end
+			pf
+		end
+
+		# Returns the namespace URL, if defined, or nil otherwise
+		# 
+		#  e = Element.new("el")
+		#  e.add_attributes({"xmlns:ns", "http://url"})
+		#  e.namespace( "ns" )              # -> "http://url"
+		def namespace arg=nil
+			arg = prefix if arg.nil?
+			@element.namespace arg
+		end
+
+		# Returns true if other is an Attribute and has the same name and value,
+		# false otherwise.
+		def ==( other )
+			other.kind_of?(Attribute) and other.name==name and other.value==value
+		end
+
+		# Creates (and returns) a hash from both the name and value
+		def hash
+			name.hash + value.hash
+		end
+
+		# Returns this attribute out as XML source, expanding the name
+		#
+		#  a = Attribute.new( "x", "y" )
+		#  a.to_string     # -> "x='y'"
+		#  b = Attribute.new( "ns:x", "y" )
+		#  b.to_string     # -> "ns:x='y'"
+		def to_string
+			if @element and @element.context and @element.context[:attribute_quote] == :quote
+				%Q^#@expanded_name="#{to_s().gsub(/"/, '&quote;')}"^
+			else
+				"#@expanded_name='#{to_s().gsub(/'/, '&apos;')}'"
+			end
+		end
+
+		# Returns the attribute value, with entities replaced
+		def to_s
+			return @normalized if @normalized
+
+			doctype = nil
+			if @element
+				doc = @element.document
+				doctype = doc.doctype if doc
+			end
+
+			@normalized = Text::normalize( @unnormalized, doctype )
+			@unnormalized = nil
+      @normalized
+		end
+
+		# Returns the UNNORMALIZED value of this attribute.  That is, entities
+		# have been expanded to their values
+		def value
+			return @unnormalized if @unnormalized
+			doctype = nil
+			if @element
+				doc = @element.document
+				doctype = doc.doctype if doc
+			end
+			@unnormalized = Text::unnormalize( @normalized, doctype )
+			@normalized = nil
+      @unnormalized
+		end
+
+		# Returns a copy of this attribute
+		def clone
+			Attribute.new self
+		end
+
+		# Sets the element of which this object is an attribute.  Normally, this
+		# is not directly called.
+		#
+		# Returns this attribute
+		def element=( element )
+			@element = element
+			self
+		end
+
+		# Removes this Attribute from the tree, and returns true if successfull
+		# 
+		# This method is usually not called directly.
+		def remove
+			@element.attributes.delete self.name unless @element.nil?
+		end
+
+		# Writes this attribute (EG, puts 'key="value"' to the output)
+		def write( output, indent=-1 )
+			output << to_string
+		end
+
+    def node_type
+      :attribute
+    end
+
+    def inspect
+      rv = ""
+      write( rv )
+      rv
+    end
+
+    def xpath
+      path = @element.xpath
+      path += "/@#{self.expanded_name}"
+      return path
+    end
+	end
+end
+#vim:ts=2 sw=2 noexpandtab:

data/lib/rexml/cdata.rb

@@ -0,0 +1,67 @@
+require "rexml/text"
+
+module REXML
+	class CData < Text
+		START = '<![CDATA['
+		STOP = ']]>'
+		ILLEGAL = /(\]\]>)/
+
+		#	Constructor.  CData is data between <![CDATA[ ... ]]>
+		#
+		# _Examples_
+		#  CData.new( source )
+		#  CData.new( "Here is some CDATA" )
+		#  CData.new( "Some unprocessed data", respect_whitespace_TF, parent_element )
+		def initialize( first, whitespace=true, parent=nil )
+			super( first, whitespace, parent, true, true, ILLEGAL )
+		end
+
+		# Make a copy of this object
+		# 
+		# _Examples_
+		#  c = CData.new( "Some text" )
+		#  d = c.clone
+		#  d.to_s        # -> "Some text"
+		def clone
+			CData.new self
+		end
+
+		# Returns the content of this CData object
+		#
+		# _Examples_
+		#  c = CData.new( "Some text" )
+		#  c.to_s        # -> "Some text"
+		def to_s
+			@string
+		end
+
+    def value
+      @string
+    end
+
+    # == DEPRECATED
+    # See the rexml/formatters package
+    #
+		# Generates XML output of this object
+		#
+		# output::
+		#   Where to write the string.  Defaults to $stdout
+		# indent::
+    #   The amount to indent this node by
+		# transitive::
+    #   Ignored
+		# ie_hack::
+    #   Ignored
+		#
+		# _Examples_
+		#  c = CData.new( " Some text " )
+		#  c.write( $stdout )     #->  <![CDATA[ Some text ]]>
+		def write( output=$stdout, indent=-1, transitive=false, ie_hack=false )
+      Kernel.warn( "#{self.class.name}.write is deprecated" )
+			indent( output, indent )
+			output << START
+			output << @string
+			output << STOP
+		end
+	end
+end

data/lib/rexml/child.rb

@@ -0,0 +1,96 @@
+require "rexml/node"
+
+module REXML
+	##
+	# A Child object is something contained by a parent, and this class
+	# contains methods to support that.  Most user code will not use this
+	# class directly.
+	class Child
+		include Node
+		attr_reader :parent		# The Parent of this object
+
+		# Constructor.  Any inheritors of this class should call super to make
+		# sure this method is called.
+		# parent::
+		#   if supplied, the parent of this child will be set to the
+		#   supplied value, and self will be added to the parent
+		def initialize( parent = nil )
+			@parent = nil  
+			# Declare @parent, but don't define it.  The next line sets the 
+			# parent.
+			parent.add( self ) if parent
+		end
+
+		# Replaces this object with another object.  Basically, calls
+		# Parent.replace_child
+		#
+		# Returns:: self
+		def replace_with( child )
+			@parent.replace_child( self, child )
+			self
+		end
+
+		# Removes this child from the parent.
+		#
+		# Returns:: self
+		def remove
+			unless @parent.nil?
+				@parent.delete self
+			end
+			self
+		end
+
+		# Sets the parent of this child to the supplied argument.
+		#
+		# other::
+		#   Must be a Parent object.  If this object is the same object as the
+		#   existing parent of this child, no action is taken. Otherwise, this
+		#   child is removed from the current parent (if one exists), and is added
+		#   to the new parent.
+		# Returns:: The parent added
+		def parent=( other )
+			return @parent if @parent == other
+			@parent.delete self if defined? @parent and @parent
+			@parent = other
+		end
+
+		alias :next_sibling :next_sibling_node
+		alias :previous_sibling :previous_sibling_node
+
+		# Sets the next sibling of this child.  This can be used to insert a child
+		# after some other child.
+		#  a = Element.new("a")
+		#  b = a.add_element("b")
+		#  c = Element.new("c")
+		#  b.next_sibling = c
+		#  # => <a><b/><c/></a>
+		def next_sibling=( other )
+		  parent.insert_after self, other
+		end
+
+		# Sets the previous sibling of this child.  This can be used to insert a 
+		# child before some other child.
+		#  a = Element.new("a")
+		#  b = a.add_element("b")
+		#  c = Element.new("c")
+		#  b.previous_sibling = c
+		#  # => <a><b/><c/></a>
+		def previous_sibling=(other)
+		  parent.insert_before self, other
+		end
+
+		# Returns:: the document this child belongs to, or nil if this child
+		# belongs to no document
+		def document
+			return parent.document unless parent.nil?
+			nil
+		end
+
+		# This doesn't yet handle encodings
+		def bytes
+			encoding = document.encoding
+
+			to_s
+		end
+	end
+end