xmlobject 0.1 → 0.2

data/lib/xmlobject/config.rb

@@ -1,6 +1,6 @@
 class XmlObject
 	NAME = 'XmlObject'
-	VERSION = '0.1'
+	VERSION = '0.2'
 	COPYRIGHT = 'Copyright (C) 2007 Florent Solt'
 	DESC = 'Xml object abstraction for both REXML and libxml'
 	AUTHOR = 'Florent Solt'

data/lib/xmlobject/doc.rb

@@ -0,0 +1,77 @@
+
+# XmlObject is a Xml abstraction for both REXML and libxml. If libxml is present use it,
+# if not switch to slower implementation REXML.
+#
+# Before anything else, begin with :
+#   require 'xmlobject'
+#
+# For example, you have this xml in the "buffer" variable :
+#  <root_tag attr_string="foo" attr_int="1" attr_int_false="0">
+#    <children>
+#      <child name='1'/>
+#      <child name='2'/>
+#      <child name='3'/>
+#    </children>
+#    <some_text>
+#      FooBar
+#    </some_text>
+#  </root_tag>
+#
+# Create an XmlObject :
+#   xml = XmlObject.new(buffer)
+#
+# Then get the root attributes :
+#   puts xml.attr_string      -> foo
+#   puts xml['attr_string']   -> foo
+#   puts xml.attr_int         -> 1
+#
+# Ask if some attributes or child are present or true :
+#   puts xml.attr_string?     -> true
+#   puts xml.not_here?        -> false
+#   puts xml.attr_int?        -> true
+#   puts xml.attr_int_false?  -> false
+#   puts xml.children?        -> true
+#
+# Iter through children :
+#   xml.children.child do |child|
+#     puts child.name         -> 1, 2, 3
+#   end
+#
+# Get some text :
+#   puts xml.some_text.text.strip
+class XmlObject < XmlInterface
+
+	# Constructor of XmlObject based on an xml string.
+	# If the string is empty, raise an exception
+	def initialize(xml)
+	end
+
+	# Attribute accessor
+	def [](name)
+	end
+
+	# Text section accessor
+	def text
+	end
+
+	# Return the list of the "methods" of the xml, it's an array containing
+	# all attributes and all children names. This array is cached after the
+	# first call
+	def methods
+	end
+
+	# This is the "magic" part :)
+	#
+	# If the method name end with a "?" then the result will be a boolean.
+	# If the name of the method match :
+	# * a string attibute or a child name : return true, false otherwise
+	# * a integer attribute : return true if the value differ from 0, else false
+	#
+	# If the methode name does not end with a "?", then it return the matched child
+	# or attribute, nil if not found.
+	#
+	# All XmlObject returned are cached after the first call
+	def method_missing(name, *args)
+	end
+
+end

data/lib/xmlobject/interface.rb

@@ -1,4 +1,5 @@
 class XmlInterface
+
 	def id; method_missing(:id); end
 	def inspect; @xml.to_s; end
 	def to_s; @xml.to_s; end

data/lib/xmlobject/object.rb

@@ -4,23 +4,30 @@ class XmlObject < XmlInterface
 if defined? XML # Libxml backend
 ####################################################################################
 
-	def initialize(xml)
+	def initialize(xml) # :nodoc:
+		raise "Empty xml" if xml.to_s.strip.empty?
 		super
 		@parser = XML::Parser.new
 		@parser.string = xml.to_s
 		@xml = @parser.parse.root
 	end
 
-	def [](name); @xml[name.to_s]; end
-	def text; @xml.child? and @xml.child.text? and @xml.child.to_s or nil; end
+	
+	def [](name) # :nodoc:
+		@xml[name.to_s];
+	end
+
+	def text # :nodoc:
+		@xml.child? and @xml.child.text? and @xml.child.to_s or nil
+	end
 
-	def methods
+	def methods # :nodoc:
 		@xml.each_attr { |i| @cache[:attr] << i.name.to_s } if @cache[:attr].empty?
-		@xml.each_child { |i| @cache[:child] << i.name.to_s } if @cache[:child].empty?
+		@xml.each_child { |i| @cache[:child] << i.name.to_s if i.element? } if @cache[:child].empty?
 		super
 	end
 
-	def method_missing(name, *args)
+	def method_missing(name, *args) # :nodoc:
 		methods # Build the cache if necessary
 		name = name.to_s
 		if name !~ /\?$/
@@ -36,21 +43,27 @@ if defined? XML # Libxml backend
 else # fallback to REXML
 ####################################################################################
 
-	def initialize(xml)
+	def initialize(xml) # :nodoc:
+		raise "Empty xml" if xml.to_s.strip.empty?
 		super
 		@xml = REXML::Document.new(xml.to_s).root
 	end
 
-	def [](name); @xml.attributes[name.to_s]; end
-	def text; @xml.text; end
+	def [](name) # :nodoc:
+		@xml.attributes[name.to_s]
+	end
+
+	def text # :nodoc:
+		@xml.text
+	end
 
-	def methods
+	def methods # :nodoc:
 		@xml.attributes.each { |n,v| @cache[:attr] << n.to_s } if @cache[:attr].empty?
 		@xml.elements.each { |e| @cache[:child] << e.name.to_s } if @cache[:child].empty?
 		super
 	end
 
-	def method_missing(name, *args, &block)
+	def method_missing(name, *args, &block) # :nodoc:
 		methods # Build the cache if necessary
 		name = name.to_s
 		if name !~ /\?$/

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: xmlobject
 version: !ruby/object:Gem::Version 
-  version: "0.1"
-date: 2007-04-19 00:00:00 +02:00
+  version: "0.2"
+date: 2007-04-20 00:00:00 +02:00
 summary: Xml object abstraction for both REXML and libxml
 require_paths: 
 - lib
@@ -32,6 +32,7 @@ files:
 - lib/xmlobject/object.rb
 - lib/xmlobject/interface.rb
 - lib/xmlobject/config.rb
+- lib/xmlobject/doc.rb
 - lib/xmlobject.rb
 test_files: []