ox 1.3.5 → 1.4.0

data/README.md

@@ -26,9 +26,10 @@ A fast XML parser and Object marshaller as a Ruby gem.
 
 ## <a name="release">Release Notes</a>
 
-### Release 1.3.4
+### Release 1.4.0
 
- - Made Ox SAX compatible with Ruby 1.8.7 when readpartial is not implemented on IO.
+ - Fixed bug in parsing the xml instruction.
+ - Added locate() method that provides simple and limited xpath like functionality.
 
 ## <a name="description">Description</a>
 

data/ext/ox/parse.c

@@ -189,6 +189,8 @@ read_instruction(PInfo pi) {
         if ('?' == *pi->s) {
             pi->s++;
         }
+    } else {
+        pi->s++;
     }
     if ('>' != *pi->s++) {
         raise_error("invalid format, processing instruction not terminated", pi->str, pi->s);

data/lib/ox.rb

@@ -88,6 +88,7 @@ module Ox
 end
 
 require 'ox/version'
+require 'ox/invalidpath'
 require 'ox/node'
 require 'ox/comment'
 require 'ox/cdata'

data/lib/ox/element.rb

@@ -1,5 +1,6 @@
 
 module Ox
+
   # An Element represents a element of an XML document. It has a name,
   # attributes, and sub-nodes.
   class Element < Node
@@ -64,6 +65,108 @@ module Ox
       true
     end
     alias == eql?
+    
+    # Returns an array of Nodes or Strings that correspond to the locations
+    # specified by the path parameter. The path parameter describes the path
+    # to the return values which can be either nodes in the XML or
+    # attributes. The path is a relative description. There are similarities
+    # between the locate() method and XPath but locate does not follow the
+    # same rules as XPath. The syntax is meant to be simpler and more Ruby
+    # like.
+    #
+    # Like XPath the path delimiters are the slash (/) character. The path is
+    # split on the delimiter and each element of the path then describes the
+    # child of the current Element to traverse.
+    #
+    # Attributes are specified with an @ prefix.
+    #
+    # Each element name in the path can be followed by a bracket expression
+    # that narrows the paths to traverse. Supported expressions are numbers
+    # with a preceeding qualifier. Qualifiers are -, +, <, and >. The +
+    # qualifier is the default. A - qualifier indicates the index begins at
+    # the end of the children just like for Ruby Arrays. The < and >
+    # qualifiers indicates all elements either less than or greater than
+    # should be matched. Note that unlike XPath, the element index starts at 0
+    # similar to Ruby be contrary to XPath.
+    #
+    # Element names can also be wildcard characters. A * indicates any
+    # decendent should be followed. A ? indicates any single Element can
+    # match the wildcard.
+    #
+    # Examples are:
+    # * <code>element.locate("Family/Pete/*")</code> returns all children of the Pete Element.
+    # * <code>element.locate("Family/?[1]")</code> returns the first element in the Family Element.
+    # * <code>element.locate("Family/?[<3]")</code> returns the first 3 elements in the Family Element.
+    # * <code>element.locate("Family/?/@age")</code> returns the arg attribute for each child in the Family Element.
+    # * <code>element.locate("Family/*/@type")</code> returns the type attribute value for decendents of the Family.
+    #
+    # @param [String] path path to the Nodes to locate
+    def locate(path)
+      return [self] if path.nil?
+      found = []
+      pa = path.split('/')
+      alocate(pa, found)
+      found
+    end
+    
+    # @param [Array] path array of steps in a path
+    # @param [Array] found matching nodes
+    def alocate(path, found)
+      #puts "*** locate_dig(#{path}, #{found})"
+      step = path[0]
+      #puts "***  #{step}"
+      if step.start_with?('@') # attribute
+        raise InvalidPath.new(path) unless 1 == path.size
+        step = step[1..-1]
+        sym_step = step.to_sym
+        @attributes.each do |k,v|
+          found << v if ('?' == step or k == step or k == sym_step)
+        end
+      else # element name
+        if (i = step.index('[')).nil? # just name
+          name = step
+          qual = nil
+        else
+          name = step[0..i-1]
+          raise InvalidPath.new(path) unless step.end_with?(']')
+          i += 1
+          qual = step[i]
+          if '0' <= qual and qual <= '9'
+            qual = '+'
+          else
+            i += 1
+          end
+          index = step[i..-2].to_i
+        end
+        if '?' == name or '*' == name
+          match = nodes
+        else
+          match = @nodes.select { |e| e.is_a?(Element) and name == e.name }
+        end
+        unless qual.nil? or match.empty?
+          case qual
+          when '+'
+            match = index < match.size ? [match[index]] : []
+          when '-'
+            match = index <= match.size ? [match[-index]] : []
+          when '<'
+            match = 0 < index ? match[0..index - 1] : []
+          when '>'
+            match = index <= match.size ? match[index + 1..-1] : []
+          else
+            raise InvalidPath.new(path)
+          end
+        end
+        if (1 == path.size)
+          match.each { |n| found << n }
+        elsif '*' == name
+          match.each { |n| n.alocate(path, found) if n.is_a?(Element) }
+          match.each { |n| n.alocate(path[1..-1], found) if n.is_a?(Element) }
+        else
+          match.each { |n| n.alocate(path[1..-1], found) if n.is_a?(Element) }
+        end
+      end
+    end
 
   end # Element
 end # Ox

data/lib/ox/invalidpath.rb

@@ -0,0 +1,10 @@
+module Ox
+
+  # 
+  class InvalidPath < Exception
+    def initialize(path)
+      super("#{path.join('/')} is not a valid location.")
+    end
+
+  end # InvalidPath
+end # Ox

data/lib/ox/version.rb

@@ -1,5 +1,5 @@
 
 module Ox
   # Current version of the module. 
-  VERSION = '1.3.5'
+  VERSION = '1.4.0'
 end

data/test/bug3.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby -wW1
+
+$: << '../lib'
+$: << '../ext'
+
+require 'ox'
+
+def name_it()
+  begin
+    "x".foo
+  rescue Exception => e
+    #puts e.message
+    xml = Ox.dump(e, effort: :tolerant)
+    puts xml
+    o = Ox.load(xml, mode: :object)
+    puts o.message
+    puts Ox.dump(e)
+  end
+end
+
+name_it()

data/test/func.rb

@@ -383,7 +383,137 @@ class Func < ::Test::Unit::TestCase
     obj = Ox.load(xml, :mode => :object) # should convert it to an object
     assert_equal(nil, obj)
   end
+  
+  def locate_xml()
+    %{<?xml?>
+<Family real="false">
+  <Pete age="57" type="male">
+    <Kid1 age="32"/>
+    <Kid2 age="31"/>
+  </Pete>
+</Family>
+}
+  end
+  
+  def test_locate_self
+    doc = Ox.parse(locate_xml)
+    nodes = doc.locate(nil)
+    assert_equal(doc, nodes[0])
+  end
+
+  def test_locate_top
+    doc = Ox.parse(locate_xml)
+    nodes = doc.locate('Family')
+    assert_equal([doc.nodes[0]], nodes)
+  end
+
+  def test_locate_top_wild
+    doc = Ox.parse(locate_xml)
+    nodes = doc.locate('?')
+    assert_equal([doc.nodes[0]], nodes)
+  end
+
+  def test_locate_child
+    doc = Ox.parse(locate_xml)
+
+    nodes = doc.locate('Family/?')
+    assert_equal(['Pete'], nodes.map { |n| n.name })
+
+    nodes = doc.locate('Family/?/?')
+    assert_equal(['Kid1', 'Kid2'], nodes.map { |n| n.name })
+
+    nodes = doc.locate('Family/Pete/?')
+    assert_equal(['Kid1', 'Kid2'], nodes.map { |n| n.name })
+
+    nodes = doc.locate('Family/Makie/?')
+    assert_equal([], nodes.map { |n| n.name })
+  end
+
+  def test_locate_child_wild_wild
+    doc = Ox.parse(locate_xml)
+    nodes = doc.locate('Family/?/?')
+    assert_equal(['Kid1', 'Kid2'], nodes.map { |n| n.name })
+  end
+
+  def test_locate_child_wild
+    doc = Ox.parse(locate_xml)
+    nodes = doc.locate('Family/Pete/?')
+    assert_equal(['Kid1', 'Kid2'], nodes.map { |n| n.name })
+  end
+
+  def test_locate_child_wild_missing
+    doc = Ox.parse(locate_xml)
+    nodes = doc.locate('Family/Makie/?')
+    assert_equal([], nodes.map { |n| n.name })
+  end
+
+  def test_locate_attribute
+    doc = Ox.parse(locate_xml)
 
+    nodes = doc.locate('Family/@?')
+    assert_equal(['false'], nodes)
+
+    nodes = doc.locate('Family/@real')
+    assert_equal(['false'], nodes)
+
+    nodes = doc.locate('Family/Pete/@?')
+    assert_equal(['57', 'male'], nodes.sort)
+
+    nodes = doc.locate('Family/Pete/@age')
+    assert_equal(['57'], nodes)
+
+    nodes = doc.locate('Family/Makie/@?')
+    assert_equal([], nodes)
+
+    nodes = doc.locate('Family/Pete/?/@age')
+    assert_equal(['31', '32'], nodes.sort)
+
+    nodes = doc.locate('Family/*/@age')
+    assert_equal(['31', '32', '57'], nodes.sort)
+
+    nodes = doc.locate('*/@?')
+    assert_equal(['31', '32', '57', 'false', 'male'], nodes.sort)
+
+    assert_raise(::Ox::InvalidPath) {
+      nodes = doc.locate('Family/@age/?')
+    }
+
+    assert_raise(::Ox::InvalidPath) {
+      nodes = doc.locate('Family/?[/?')
+    }
+  end
+
+  def test_locate_qual_index
+    doc = Ox.parse(locate_xml)
+    nodes = doc.locate('Family/Pete/?[0]')
+    assert_equal(['Kid1'], nodes.map { |e| e.name } )
+    nodes = doc.locate('Family/Pete/?[1]')
+    assert_equal(['Kid2'], nodes.map { |e| e.name } )
+  end
+
+  def test_locate_qual_less
+    doc = Ox.parse(locate_xml)
+    nodes = doc.locate('Family/Pete/?[<1]')
+    assert_equal(['Kid1'], nodes.map { |e| e.name } )
+  end
+
+  def test_locate_qual_great
+    doc = Ox.parse(locate_xml)
+    nodes = doc.locate('Family/Pete/?[>0]')
+    assert_equal(['Kid2'], nodes.map { |e| e.name } )
+  end
+
+  def test_locate_qual_last
+    doc = Ox.parse(locate_xml)
+    nodes = doc.locate('Family/Pete/?[-1]')
+    assert_equal(['Kid2'], nodes.map { |e| e.name } )
+  end
+
+  def test_locate_qual_last_attr
+    doc = Ox.parse(locate_xml)
+    nodes = doc.locate('Family/Pete/?[-1]/@age')
+    assert_equal(['31'], nodes )
+  end
 end
 
 class Bag

data/test/sax_example.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby -wW1
+
+$: << '../lib'
+$: << '../ext'
+
+require 'stringio'
+require 'ox'
+
+class Sample < ::Ox::Sax
+  def start_element(name); puts "start: #{name}"; end
+  def end_element(name); puts "end: #{name}"; end
+  def attr(name, value); puts "  #{name} => #{value}"; end
+  def text(value); puts "text #{value}"; end
+end
+
+io = StringIO.new(%{
+<top name="sample">
+  <middle name="second">
+    <bottom name="third"/>
+  </middle>
+</top>
+})
+
+handler = Sample.new()
+Ox.sax_parse(handler, io)
+
+# outputs
+# start: top
+#   name => sample
+# start: middle
+#   name => second
+# start: bottom
+#   name => third
+# end: bottom
+# end: middle
+# end: top
+

metadata

@@ -1,30 +1,39 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: ox
-version: !ruby/object:Gem::Version
-  version: 1.3.5
-  prerelease: 
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 4
+  - 0
+  version: 1.4.0
 platform: ruby
-authors:
+authors: 
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-04 00:00:00.000000000Z
+
+date: 2011-10-18 00:00:00 +09:00
+default_executable: 
 dependencies: []
+
 description: A fast XML parser and object serializer that uses only standard C lib.
 email: peter@ohler.com
 executables: []
-extensions:
+
+extensions: 
 - ext/ox/extconf.rb
-extra_rdoc_files:
+extra_rdoc_files: 
 - README.md
-files:
+files: 
 - lib/ox/bag.rb
 - lib/ox/cdata.rb
 - lib/ox/comment.rb
 - lib/ox/doctype.rb
 - lib/ox/document.rb
 - lib/ox/element.rb
+- lib/ox/invalidpath.rb
 - lib/ox/node.rb
 - lib/ox/sax.rb
 - lib/ox/version.rb
@@ -47,6 +56,7 @@ files:
 - ext/ox/sax.c
 - test/bug1.rb
 - test/bug2.rb
+- test/bug3.rb
 - test/cache16_test.rb
 - test/cache8_test.rb
 - test/cache_test.rb
@@ -74,36 +84,45 @@ files:
 - test/perf_sax.rb
 - test/perf_write.rb
 - test/sample.rb
+- test/sax_example.rb
 - test/sax_test.rb
 - test/test.rb
 - test/Sample.graffle
 - LICENSE
 - README.md
+has_rdoc: true
 homepage: https://github.com/ohler55/ox
 licenses: []
+
 post_install_message: 
-rdoc_options:
+rdoc_options: 
 - --main
 - README.md
-require_paths:
+require_paths: 
 - lib
 - ext
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: ox
-rubygems_version: 1.8.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: A fast XML parser and object serializer.
 test_files: []
+