axml 0.0.2

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2006, The University of Texas at Austin("U.T. Austin"). All rights reserved.  
+
+Software by John T. Prince under the direction of Edward M. Marcotte.
+
+By using this software the USER indicates that he or she has read, understood and will comply with the following:
+
+U. T. Austin hereby grants USER permission to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of this software and its documentation for any purpose and without fee, provided that a full copy of this notice is included with the software and its documentation.
+
+Title to copyright this software and its associated documentation shall at all times remain with U. T. Austin. No right is granted to use in advertising, publicity or otherwise any trademark, service mark, or the name of U. T. Austin.
+
+This software and any associated documentation are provided "as is," and U. T. AUSTIN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESSED OR IMPLIED, INCLUDING THOSE OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, OR THAT USE OF THE SOFTWARE, MODIFICATIONS, OR ASSOCIATED DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER INTELLECTUAL PROPERTY RIGHTS OF A THIRD PARTY. U. T. Austin, The University of Texas System, its Regents, officers, and employees shall not be liable under any circumstances for any direct, indirect, special, incidental, or consequential damages with respect to any claim by USER or any third party on account of or arising from the use, or inability to use, this software or its associated documentation, even if U. T. Austin has been advised of the possibility of those damages.
+
+Submit software operation questions to: John T. Prince, Institute for Cellular and Molecular Biology, U. T. Austin, Austin, Texas 78712.

data/README

@@ -0,0 +1,79 @@
+AXML
+====
+
+AXML - Provides a simple DOM for working with XML (using XMLParser under the
+hood) that can serve as a drop in replacement for much of the basic libxml
+functionality (e.g., each, children, child, find_first, find, next).  AXML
+comes from the idea that XML should be AXED (or at least simple to use!)
+to use).
+
+Description
+-----------
+
+Parses elements, attributes, and text(content), and nothing more.  Should be
+very easy to extend and modify for special cases.  It is roughly as fast as
+libxml, although it currently reads in the entire document first (however,
+this is memory efficient - nodes are implemented using Struct).
+
+Examples
+--------
+string_or_io = "
+<n1>
+  <n2 size='big'>
+    <n3>words here</n3>
+    <n3></n3>
+  </n2>
+  <n2 size='small'>
+    <n3 id='3'></n3)
+  </n2>
+</n1>
+"
+
+## Read a string or io
+   n1_node = AXML.parse(string_or_io)   
+
+## Read a file
+    n1_node = AXML.parse_file(filename)   
+
+## Access children
+    n1_node.children # -> [array]
+    n1_node.each {|child|  # do something with child }
+
+## Get attributes and text
+    n2_node['size'] == 'big'
+    n3_node = n2_node.child
+    n3_node.text    # -> 'words here'
+    n3_node.content # -> [same]
+
+## Traverse nodes with next and child
+    n2_node = n1_node.child
+    the_other_n2_node = n2_node.next
+    the_other_n2_node.next = nil
+
+## Does a little xpath
+    n3_node = n1_node.find_first('descendant::n3')
+    n1_node.find_first('child::n3')    # -> nil
+    n1_node.find('descendant::n3')     # -> [array of all 3 <n3> nodes]
+    n1_node.find('child::n2')          # -> [array of 2 <n2> nodes]
+
+All Examples (see specs/axml_spec.rb)
+
+- reads xml strings with "AXML.parse"
+- reads file handles with "AXML.parse"
+- reads files with "AXML.parse_file"
+- can access subnodes with "children" or "kids"
+- accesses attributes with "[]"
+- can "find_first_descendant"
+- can "find_first_child"
+- can "find" with a little xpath
+- can do some find_first xpath
+- can drop nodes with "drop"
+- can return "child" node
+- can return "next" node
+- "to_s" gives xml
+
+Installation
+------------
+
+gem install axml
+

data/Rakefile

@@ -0,0 +1,203 @@
+require 'rake'
+require 'rubygems'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/clean'
+require 'fileutils'
+require 'spec/rake/spectask'
+
+###############################################
+# GLOBAL
+###############################################
+
+FL = FileList
+NAME = "axml"
+
+readme = "README"
+
+rdoc_extra_includes = [readme, "LICENSE"]
+rdoc_options = ['--main', readme, '--title', NAME]
+
+lib_files = FL["lib/**/*"]
+dist_files = lib_files + FL[readme, "LICENSE", "Rakefile", "{specs}/**/*"]
+changelog = 'CHANGELOG'
+
+###############################################
+# ENVIRONMENT
+###############################################
+ENV["OS"] == "Windows_NT" ? WIN32 = true : WIN32 = false
+$gemcmd = "gem"
+if WIN32
+  unless ENV["TERM"] == "cygwin"
+    $gemcmd << ".cmd"
+  end
+end
+
+###############################################
+# DOC
+###############################################
+Rake::RDocTask.new do |rd|
+  rd.main = readme
+  rd.rdoc_files.include rdoc_extra_includes
+  rd.options.push( *rdoc_options )
+end
+
+###############################################
+# TESTS
+###############################################
+
+
+task :ensure_gem_is_uninstalled do
+  reply = `#{$gemcmd} list -l #{NAME}`
+  if reply.include? NAME + " ("
+    puts "GOING to uninstall gem '#{NAME}' for testing"
+    if WIN32
+      %x( #{$gemcmd} uninstall -x #{NAME} )
+    else
+      %x( sudo #{$gemcmd} uninstall -x #{NAME} )
+    end
+  end
+end
+
+namespace :spec do
+  task :autotest do
+    require './specs/rspec_autotest'
+    RspecAutotest.run
+  end
+end
+
+desc "Run specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+  Rake::Task[:ensure_gem_is_uninstalled].invoke
+  t.libs = ['lib']
+  t.spec_files = FileList['specs/**/*_spec.rb']
+end
+
+desc "Run specs and output specdoc"
+Spec::Rake::SpecTask.new('specl') do |t|
+  Rake::Task[:ensure_gem_is_uninstalled].invoke
+  t.spec_files = FileList['specs/**/*_spec.rb']
+  t.libs = ['lib']
+  t.spec_opts = ['--format', 'specdoc' ]
+end
+
+desc "Run all specs with RCov"
+Spec::Rake::SpecTask.new('rcov') do |t|
+  Rake::Task[:ensure_gem_is_uninstalled].invoke
+  t.spec_files = FileList['specs/**/*_spec.rb']
+  t.rcov = true
+  t.libs = ['lib']
+  t.rcov_opts = ['--exclude', 'specs']
+end
+
+#task :spec do
+#  uninstall_gem
+#  # files that match a key word
+#  files_to_run = ENV['SPEC'] || FileList['specs/**/*_spec.rb']
+#  if ENV['SPECM']
+#    files_to_run = files_to_run.select do |file|
+#      file.include?(ENV['SPECM'])
+#    end
+#  end
+#  files_to_run.each do |spc|
+#    system "ruby -I lib -S spec #{spc} --format specdoc"
+#  end
+#end
+
+###############################################
+# PACKAGE / INSTALL / UNINSTALL
+###############################################
+
+def get_summary(readme)
+  string = ''
+  collect = false
+  IO.foreach(readme) do |line|
+    if collect
+      if line =~ /[^\s]/
+        string << line
+      else
+        break
+      end
+    elsif line =~ /^AXML - .*/
+      string << line
+      collect = true
+    end
+  end
+  string.gsub!("\n", " ")
+end
+
+# looks for a header, collects the paragraph after the space
+def get_section(header, file)
+  get_space = false
+  found_space = false
+  string = ''
+  IO.foreach(file) do |line|
+    if found_space
+      if line =~ /[^\s]/
+        string << line
+      else
+        break
+      end
+    elsif get_space
+      if line !~ /[^\s]/
+        found_space = true
+        get_space = false
+      end
+    elsif line =~ /^#{header}/ 
+      get_space = true
+    end
+  end
+  string.gsub!("\n", ' ')
+end
+
+def get_description(readme)
+  get_section('Description', readme)
+end
+
+tm = Time.now
+gemspec = Gem::Specification.new do |t|
+  description = get_description(readme)
+  summary = get_summary(readme)
+  t.platform = Gem::Platform::RUBY
+  t.name = NAME
+  t.version =  IO.readlines(changelog).grep(/##.*version/).pop.split(/\s+/).last.chomp
+  t.summary = summary
+  t.date = "#{tm.year}-#{tm.month}-#{tm.day}"
+  t.email = "jprince@icmb.utexas.edu"
+  t.description = description
+  t.has_rdoc = true
+  t.authors = ["John Prince"]
+  t.files = dist_files
+  t.rdoc_options = rdoc_options
+  t.extra_rdoc_files = rdoc_extra_includes
+  t.executables = FL["bin/*"].map {|file| File.basename(file) }
+  t.requirements << 'xmlparser is needed right now'
+  t.test_files = FL["specs/*_spec.rb"]
+end
+
+desc "Create packages."
+Rake::GemPackageTask.new(gemspec) do |pkg|
+  #pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+task :remove_pkg do 
+  FileUtils.rm_rf "pkg"
+end
+
+
+task :install => [:reinstall]
+
+desc "uninstalls the package, packages a fresh one, and installs"
+task :reinstall => [:remove_pkg, :clean, :package] do
+  reply = `#{$gemcmd} list -l #{NAME}`
+  if reply.include?(NAME + " (")
+    %x( #{$gemcmd} uninstall -a -x #{NAME} )
+  end
+  FileUtils.cd("pkg") do
+    cmd = "#{$gemcmd} install #{NAME}*.gem"
+    puts "EXECUTING: #{cmd}" 
+    system cmd
+  end
+end
+

data/lib/axml.rb

@@ -0,0 +1,227 @@
+require 'xmlparser'
+
+class AXML
+
+  def self.parse_file(file)
+    root = nil
+    File.open(file) do |fh|
+      root = parse(fh)       
+    end
+    root
+  end
+
+  # Returns the root node (as Element) or nodes (as Array)
+  def self.parse(stream)
+    parser = AXML::XMLParser.new
+    parser.parse(stream)
+    parser.root
+  end
+
+end
+
+AXML::El = Struct.new(:parent, :name, :attrs, :text, :children, :array_index)
+
+class AXML::El
+  @@tabs = ["", "  ", "    ", "      ", "        ", "          ", "            "]
+  include Enumerable
+
+  @@depth = 0
+  #attr_accessor :name, :attrs, :text, :children, :parent
+  # keeps track of location in array
+  #attr_accessor :array_index
+
+  alias_method  :content, :text
+  alias_method  :content=, :text=
+  alias_method  :kids, :children
+  alias_method  :kids=, :children=
+
+  def [](attribute_string)
+    attrs[attribute_string]
+  end
+
+  # accepts same xpath strings as find_first
+  # returns an array of nodes
+  def find(string)
+    (tp, name) = string.split('::')
+    case tp
+    when 'child'
+      find_children(name)
+    when 'descendant'
+      find_descendants(name)
+    when 'following-sibling'
+      find_following_siblings(name)
+    end
+  end
+
+  def find_descendants(name, collect_descendants=[])
+    children.each do |child|
+      collect_descendants.push(child) if child.name == name
+      child.find_descendants(name, collect_descendants)
+    end
+    collect_descendants
+  end
+
+  def find_children(name)
+    children.select {|v| v.name == name }
+  end
+
+
+  # currently must be called with descendent:: or child:: string prefix! e.g.
+  # "descendant::<name>" and "child::<name>" where <name> is the name of the
+  # node you seek) 
+  def find_first(string)
+    (tp, name) = string.split('::')
+    case tp
+    when 'child'
+      find_first_child(name)
+    when 'descendant'
+      find_first_descendant(name)
+    when 'following-sibling'
+      find_first_following_sibling(name)
+    end
+  end
+
+  def find_first_descendant(name)
+    self.each do |child_node| 
+      if child_node.name == name
+        return child_node
+      else
+        return child_node.find_first_descendant(name) 
+      end
+    end
+    return nil
+  end
+
+  def find_first_child(name)
+    self.each do |child_node| 
+      if child_node.name == name
+        return child_node
+      end
+    end
+    return nil
+  end
+
+  def find_following_siblings(name)
+    parent.children[(array_index+1)..-1].select {|v| v.name == name }
+  end
+
+  def find_first_following_sibling(name)
+    node = nil
+    parent.children[(array_index+1)..-1].each do |sibling| 
+      if sibling.name == name 
+        node = sibling
+        break
+      end
+    end
+    node
+  end
+
+  def children?
+    children.size > 0
+  end
+  alias_method :child?, :children?
+
+
+  def each(&block)
+    children.each do |child|
+      block.call(child)
+    end
+  end
+
+  # drops the current element from the list of its parents children
+  def drop
+    parent.children.delete(self)
+  end
+
+  def drop_child(node)
+    found_it = false
+    found_index = nil
+    children.each_with_index do |v,i| 
+      if found_it
+        v.array_index = i - 1
+      end
+      if v.object_id == node.object_id 
+        found_index = i
+        found_it = true
+      end
+    end
+    children.delete_at(found_index) if found_index
+  end
+
+  def tabs
+    @@tabs[@@depth]
+  end
+
+  def to_s
+    attstring = ""
+    if attrs.size > 0
+      attstring = " " + attrs.collect { |k,v| "#{k}=\"#{v}\"" }.join(" ")
+    end
+    string = "#{tabs}<#{name}#{attstring}"
+    if children.size > 0
+      string << ">\n"
+      @@depth += 1
+      string << children.collect {|child| child.to_s }.join("")
+      @@depth -= 1
+      string << "#{tabs}</#{name}>\n"
+    else
+      string << "/>\n"
+    end
+    string
+  end
+
+  def inspect
+    "<name='#{name}' attrs='#{attrs.inspect}' children.size=#{children.size}>"
+  end
+
+  # the next node
+  def next
+    parent.children[array_index+1]
+  end
+
+  # the first child (equivalent to children.first)
+  def child
+    children.first
+  end
+
+  def add_node(node)
+    node.array_index = children.size
+    children.push( node )
+  end
+
+end
+
+class AXML::XMLParser < XMLParser
+
+  attr_writer :root
+
+  # returns the first node found in the document
+  def root
+    @root.child
+  end
+
+  def initialize
+    @root = AXML::El.new(nil, "root", {}, '', [])
+    @cur = @root
+  end
+
+  def startElement(name, attributes)
+    new_el = AXML::El.new(@cur, name, attributes, '', [])
+    # add the new node to the previous parent node
+    @cur.add_node(new_el)
+    # notice the change in @cur node
+    @cur = new_el
+    #@cur.text = "" ## in initialization now..
+  end
+
+  def endElement(name)
+    @cur = @cur.parent
+  end
+
+  def character(data)
+    @cur.text << data
+  end
+
+end
+
+

data/specs/axml_spec.rb

@@ -0,0 +1,222 @@
+require File.expand_path( File.dirname(__FILE__) + '/spec_helper' )
+
+require 'axml'
+
+describe AXML do
+
+  before(:each) do
+    @xml_string = <<END
+<xml>
+  <doc1>
+    <dog name="spot" height="23" weight="13">
+      <flea name="ouchy" height="20" weight="10"/>
+      <flea name="crawly" height="22" weight="9"/>
+    </dog>
+  </doc1>
+  <doc2>
+    <dog name="billy" height="5" weight="3">
+    </dog>
+  </doc2>
+</xml>
+END
+    @small_xml_string = <<END
+<first>
+  <inner1 name="hello">
+  </inner1>
+  <inner2>
+  </inner2>
+</first>
+END
+    @xml_large_string = <<END
+<n1>
+    <n2 id='1'>
+      <n3 id='1'> </n3>
+      <n3 id='2'> </n3>
+      <n3b id='5'></n3b>
+      <n3b id='6'></n3b>
+    </n2>
+    <n2 id='2'>
+      <n3 id='3'> </n3>
+      <n3 id='4'> </n3>
+    </n2>
+</n1>
+END
+  end
+
+  it 'reads xml strings with "AXML.parse"' do
+    node = AXML.parse(@small_xml_string)
+
+    node.class.should == AXML::El
+    node.name.should == 'first'
+    node.children.first.name.should == 'inner1'
+    node.kids.first.name.should == 'inner1'
+  end
+
+  it 'reads file handles with "AXML.parse"' do
+    file = File.dirname(__FILE__) + '/axml.tmp'
+    File.open(file, 'w') {|fh| fh.puts @xml_string}
+    fh = File.open(file)
+    root = AXML.parse(fh)
+    fh.close
+    root.name.should == 'xml'
+    root.kids[0].kids.first.attrs["name"].should == 'spot'
+    File.unlink(file) if File.exist? file
+  end
+
+  it 'reads files with "AXML.parse_file"' do
+    file = File.dirname(__FILE__) + '/axml.tmp'
+    File.open(file, 'w') {|fh| fh.puts @xml_string}
+    root = AXML.parse_file(file)
+    root.name.should == 'xml'
+    root.kids[0].kids.first.attrs["name"].should == 'spot'
+    File.unlink(file) if File.exist? file
+  end
+
+  it 'can access subnodes with "children" or "kids"' do
+    node = AXML.parse(@small_xml_string) 
+    node.name.should == 'first'
+    node.kids.zip(%w(inner1 inner2)) do |kd,nm|
+      kd.name.should == nm
+    end
+  end
+
+  it 'accesses attributes with "[]"' do
+    root = AXML.parse(@xml_string)
+    dog_node = root.kids[0].kids[0]
+    dog_node.name.should == 'dog'
+    dog_node['name'].should == 'spot'
+    dog_node['height'].should == '23'
+  end
+
+  it 'can "find_first_descendant"' do
+    root = AXML.parse(@xml_string)
+    doc1_node = root.find_first_descendant('doc1')
+    doc1_node.name.should == 'doc1'
+    doc1_node.children.size.should == 1
+    doc1_node.find_first_descendant('xml').should == nil
+    doc1_node.find_first_descendant('doc1').should == nil
+    child_node = root.find_first_descendant('flea')
+    child_node.name.should == 'flea'
+    child_node['name'].should == 'ouchy'
+    child_node.find_first_descendant('flea').should == nil
+  end
+
+  it 'can "find_first_child"' do
+    root = AXML.parse(@xml_string)
+    doc1_node = root.find_first_child('doc1')
+    doc1_node.name.should == 'doc1'
+    doc1_node.children.size.should == 1
+    doc1_node.find_first_child('xml').should == nil
+    doc1_node.find_first_child('doc1').should == nil
+    dog_node = doc1_node.find_first_child('dog')
+    dog_node.name.should == 'dog'
+    dog_node['name'].should == 'spot'
+    doc2_node = root.find_first_child('doc2')
+    doc2_node.name.should == 'doc2'
+    doc2_node.children.size.should == 1
+  end
+
+  it 'can "find" with a little xpath' do
+    root = AXML.parse(@xml_large_string)
+    nodes = root.find('child::n2')
+    nodes.size.should == 2
+    nodes.each {|v| v.name.should == 'n2' }
+    nodes.each_with_index {|v,i| v['id'].should == (i+1).to_s } 
+
+    nodes = root.find('descendant::n3')
+    nodes.size.should == 4
+    nodes.each {|v| v.name.should == 'n3' }
+    nodes.each_with_index {|v,i| v['id'].should == (i+1).to_s } 
+  end
+
+  it 'can do some find_first xpath' do
+    root = AXML.parse(@xml_string)
+    flea_node = root.find_first('descendant::flea')
+    flea_node.name.should == 'flea'
+    flea_node['name'].should == 'ouchy'
+    root.find_first('child::flea').should be_nil
+    root.find_first('child::doc2').name.should == 'doc2'
+  end
+
+  it 'can drop nodes with "drop"' do
+    root = AXML.parse(@xml_string)
+    root.children[0].children[0].drop
+    to_string = <<END
+<xml>
+  <doc1/>
+  <doc2>
+    <dog name="billy" weight="3" height="5"/>
+  </doc2>
+</xml>
+END
+    root.to_s.should == to_string 
+  end
+
+  it 'can return "child" node' do
+    root = AXML.parse(@xml_string)
+    doc1 = root.child
+    doc1.name.should == 'doc1'
+    dog = doc1.child
+    dog.name.should == 'dog'
+    dog['name'].should == 'spot'
+    flea = dog.child
+    flea.name.should == 'flea'
+    flea['name'].should == 'ouchy'
+    flea.child.should == nil
+  end
+
+  it 'can return "next" node' do
+    root = AXML.parse(@xml_string)
+    root.next.should == nil
+    doc1 = root.child
+    doc2 = doc1.next
+    doc2.name.should == 'doc2'
+    doc2.next.should == nil
+    dog = doc1.child
+    dog.name.should == 'dog'
+    dog.next.should == nil
+    flea2 = dog.child.next
+    flea2.name.should == 'flea'
+    flea2['name'].should == 'crawly'
+    flea2.next.should == nil
+  end
+
+  it 'can find "following-sibling"' do
+    n1 = AXML.parse(@xml_large_string)
+    n3 = n1.child.child
+    n3.name.should == 'n3'
+    n3id2 = n3.find_first("following-sibling::n3")
+    n3id2['id'].should == '2'
+    n3b = n3.find_first("following-sibling::n3b")
+    n3b['id'].should == '5'
+    n3b.find_first("following-sibling::n3").should == nil
+  end
+
+  it '"to_s" gives xml' do
+    root = AXML.parse(@xml_string)
+    to_string = <<END
+<xml>
+  <doc1>
+    <dog name="spot" weight="13" height="23">
+      <flea name="ouchy" weight="10" height="20"/>
+      <flea name="crawly" weight="9" height="22"/>
+    </dog>
+  </doc1>
+  <doc2>
+    <dog name="billy" weight="3" height="5"/>
+  </doc2>
+</xml>
+END
+    root.to_s.should == to_string
+  end
+
+  it 'can get many attributes at once with values_at (not supported by libxml)' do
+    root = AXML.parse(@xml_string)
+    dog = root.child.child.child
+    exp = %w(ouchy 20 10)
+    reply = dog.attrs.values_at('name', 'height', 'weight')
+    reply.should == exp
+  end
+
+
+end

data/specs/spec_helper.rb

@@ -0,0 +1,57 @@
+
+gem 'rspec'
+
+
+def xdescribe(*args)
+  puts "#{args.join(' ')}"
+  puts "**SKIPPING**"
+end
+
+def Xdescribe(*args)
+  xdescribe(*args)
+end
+
+def xit(*args)
+  puts "- SKIPPING: #{args.join(' ')}"
+end
+
+def silent(&block)
+  tmp = $VERBOSE ; $VERBOSE = nil
+  block.call
+  $VERBOSE = tmp
+end
+
+silent {
+  ROOT_DIR = File.dirname(__FILE__) + '/..'
+  SPEC_DIR = File.dirname(__FILE__)
+}
+
+
+class String
+  #alias_method :exist?, exist_as_a_file?
+  #alias_method exist_as_a_file?, exist?
+  def exist?
+    File.exist? self
+  end
+  def exist_as_a_file?
+    File.exist? self
+  end
+end
+
+describe "a cmdline program", :shared => true do
+  before(:all) do
+    testdir = File.dirname(__FILE__)
+    libdir = testdir + '/../lib'
+    bindir = testdir +  '/../bin'
+    progname = "fasta_shaker.rb"
+    @cmd = "ruby -I #{libdir} #{bindir}/#{@progname} "
+  end
+
+  it 'gives usage when called with no args' do
+    reply = `#{@cmd}`
+    reply.should =~ /usage/i
+  end
+
+end
+
+

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: axml
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+date: 2007-10-19 00:00:00 -05:00
+summary: AXML - Provides a simple DOM for working with XML (using XMLParser under the hood) that can serve as a drop in replacement for much of the basic libxml functionality (e.g., each, children, child, find_first, find, next).  AXML comes from the idea that XML should be AXED (or at least simple to use!) to use).
+require_paths: 
+- lib
+email: jprince@icmb.utexas.edu
+homepage: 
+rubyforge_project: 
+description: Parses elements, attributes, and text(content), and nothing more.  Should be very easy to extend and modify for special cases.  It is roughly as fast as libxml, although it currently reads in the entire document first (however, this is memory efficient - nodes are implemented using Struct).
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- John Prince
+files: 
+- lib/axml.rb
+- README
+- LICENSE
+- Rakefile
+- specs/spec_helper.rb
+- specs/axml_spec.rb
+test_files: 
+- specs/axml_spec.rb
+rdoc_options: 
+- --main
+- README
+- --title
+- axml
+extra_rdoc_files: 
+- README
+- LICENSE
+executables: []
+
+extensions: []
+
+requirements: 
+- xmlparser is needed right now
+dependencies: []
+