axml 0.0.2 → 0.0.3

data/README

@@ -2,78 +2,108 @@ 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).
+hood) that can serve as a drop in replacement for a subset of basic libxml
+functionality (e.g., each, children, child, find_first, find, next).  
 
-Description
------------
+'AXML' means 'ax XML' which succinctly describes the occasional feeling of a
+programmer towards XML or its myriad parsers.  AXML won't solve all your
+problems, but it does make working with XML much less painful.
+
+Features
+--------
+
+* *fast*: it's implemented in XMLParser (expat under the hood)
+* *lean*: as in 'lines of code' (~220 w/ blank lines) and as in 'memory consumption' (nodes implemented as Struct, children in Array)
+* *easy to extend*: code your Grandmother could read and understand (if she reads ruby)
+* *quacks like libxml*: implements a very useful subset of libxml methods for near drop in replacement.
 
-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
+
+    require 'axml'  # currently requires 'xmlparser' be installed
+                    # Windows: already in one-click-installer
+                    # Ubuntu: sudo apt-get install libxml-parser-ruby1.8
+                    # Cygwin: see http://mspire.rubyforge.org/tutorial/cygwin_mspire.html
+
+    # a little example xml string to use
+    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('path/to/file')   
+
+### Access children
+
     n1_node.children # -> [array]
     n1_node.each {|child|  # do something with child }
 
-## Get attributes and text
+### 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
+### 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
+### Does a little xpath
+
+    # find_first (returns the first node)
     n3_node = n1_node.find_first('descendant::n3')
+    other_n3_node = n3_node.find_first('following-sibling::n3')
     n1_node.find_first('child::n3')    # -> nil
+
+    # find (returns an array)
     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
+### Switch to libxml
+
+This is all it takes to get all of the above code to work under libxml:
+
+    require 'xml/libxml'   # instead of:  require 'axml'
+
+    # A file
+    REPLACE: n1_node = AXML.parse_file(file)
+    WITH:    n1_node = XML::Document.file(file).root          # note the .root call on the end!
+
+    # A string
+    REPLACE: n1_node = AXML.parse(string)
+    WITH:    n1_node = XML::Parser.string(string).parse.root  # note the .root call on the end!
+
+Wallah!  All the above method calls work under libxml
+
+
+See `specs/axml_spec.rb` for more examples and functionality
+
+Detailed 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).
 
 Installation
 ------------
 
-gem install axml
-
+    gem install axml

data/Rakefile

@@ -4,7 +4,8 @@ require 'rake/rdoctask'
 require 'rake/gempackagetask'
 require 'rake/clean'
 require 'fileutils'
-require 'spec/rake/spectask'
+#require 'spec/rake/spectask'
+require 'email_encrypt'
 
 ###############################################
 # GLOBAL
@@ -12,6 +13,7 @@ require 'spec/rake/spectask'
 
 FL = FileList
 NAME = "axml"
+FU = FileUtils
 
 readme = "README"
 
@@ -33,6 +35,7 @@ if WIN32
   end
 end
 
+
 ###############################################
 # DOC
 ###############################################
@@ -42,6 +45,32 @@ Rake::RDocTask.new do |rd|
   rd.options.push( *rdoc_options )
 end
 
+task :html_docs do
+  css = 'doc/src/style.css'
+  FU.mkpath 'doc/output'
+  FU.cp css, 'doc/output/'
+  index = 'doc/output/index.html'
+  header = 'doc/src/header'
+  File.open(index, 'w') do |index|
+    index.puts '<html>'
+    index.puts IO.read(header)
+    index.puts '<html><body>'
+    index.puts `bluecloth --fragment #{readme}`
+
+    # add contact info:
+    index.puts '<h2>Contact</h2>'
+    index.puts 'jprince@icmb.utexas.edu'.email_encrypt
+
+    index.puts '</body></html>'
+  end
+end
+
+desc "create and upload docs to server"
+task :upload_docs => :html_docs do
+  sh "scp -i ~/.ssh/rubyforge_key -r doc/output/* jtprince@rubyforge.org:/var/www/gforge-projects/axml/"
+end
+
+
 ###############################################
 # TESTS
 ###############################################
@@ -59,36 +88,36 @@ task :ensure_gem_is_uninstalled do
   end
 end
 
-namespace :spec do
-  task :autotest do
-    require './specs/rspec_autotest'
-    RspecAutotest.run
-  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"
+#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 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
+#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
@@ -154,6 +183,7 @@ def get_description(readme)
   get_section('Description', readme)
 end
 
+
 tm = Time.now
 gemspec = Gem::Specification.new do |t|
   description = get_description(readme)
@@ -185,7 +215,6 @@ task :remove_pkg do
   FileUtils.rm_rf "pkg"
 end
 
-
 task :install => [:reinstall]
 
 desc "uninstalls the package, packages a fresh one, and installs"

data/lib/axml.rb

@@ -2,17 +2,35 @@ require 'xmlparser'
 
 class AXML
 
+  NotBlankText_re = /[^\s+]+/m
+
   def self.parse_file(file)
     root = nil
-    File.open(file) do |fh|
-      root = parse(fh)       
-    end
+    File.open(file) {|fh| root = parse(fh) }
     root
   end
 
   # Returns the root node (as Element) or nodes (as Array)
-  def self.parse(stream)
+  # options:
+  #   :keep_blanks => *true | false
+  def self.parse(stream, opts={:keep_blanks => false})
     parser = AXML::XMLParser.new
+    if opts[:keep_blanks] == false
+      parser.set_no_keep_blanks
+    end
+    if ti = opts[:text_indices]
+      if ti.is_a?(Array) && ti.size > 1
+        raise NotImplementedError, "currently only supports a single element"
+      else
+        ti = 
+          if ti.is_a?(Array)
+            ti.first.to_s
+          else
+            ti.to_s
+          end
+        parser.set_single_text_indices(ti)
+      end
+    end
     parser.parse(stream)
     parser.root
   end
@@ -22,13 +40,16 @@ end
 AXML::El = Struct.new(:parent, :name, :attrs, :text, :children, :array_index)
 
 class AXML::El
-  @@tabs = ["", "  ", "    ", "      ", "        ", "          ", "            "]
   include Enumerable
 
+  # use AXML::El::Indent.replace to swap without warning
+  # ["", "  ", "    ", "      ", "        ", "          ", ... ]
+  Indent = '  '
+  # use AXML::El::Indentation.replace to replace w/o warning
+  Indentation = (0...30).to_a.map {|num| Indent*num }
+
+  # current depth
   @@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=
@@ -39,88 +60,32 @@ class AXML::El
     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
+  def []=(attribute_string, value)
+    attrs[attribute_string] = value
   end
 
-  def find_children(name)
-    children.select {|v| v.name == name }
+  # has text?
+  def text?
+    !!text
   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
+  def children?
+    children.size > 0
   end
+  alias_method :child?, :children?
 
-  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
+  # full traversal from the initial node
+  def traverse(type=:pre, &block)
+    if type == :pre
+      block.call(self)
     end
-    return nil
-  end
-
-  def find_first_child(name)
-    self.each do |child_node| 
-      if child_node.name == name
-        return child_node
-      end
+    children.each do |child|
+      child.traverse(type, &block)
     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
+    if type == :post
+      block.call(self)
     end
-    node
-  end
-
-  def children?
-    children.size > 0
   end
-  alias_method :child?, :children?
-
 
   def each(&block)
     children.each do |child|
@@ -149,21 +114,44 @@ class AXML::El
   end
 
   def tabs
-    @@tabs[@@depth]
+    Indentation[@@depth]
+  end
+
+  EscapeCharsRe = /['"&><]/
+
+  # returns data escaped if necessary
+  def escape(data)
+    # modified slightly from xmlsimple.rb
+    return data if !data.is_a?(String) || data.nil? || data == ''
+    result = data.dup
+    if EscapeCharsRe.match(data)
+      result.gsub!('&', '&amp;')
+      result.gsub!('<', '&lt;')
+      result.gsub!('>', '&gt;')
+      result.gsub!('"', '&quot;')
+      result.gsub!("'", '&apos;')
+    end
+    result
   end
 
   def to_s
     attstring = ""
     if attrs.size > 0
-      attstring = " " + attrs.collect { |k,v| "#{k}=\"#{v}\"" }.join(" ")
+      attstring = " " + attrs.collect { |k,v| "#{k}=\"#{escape(v)}\"" }.join(" ")
     end
     string = "#{tabs}<#{name}#{attstring}"
     if children.size > 0
-      string << ">\n"
+      string << ">"
+      if text?
+        string << escape(text)
+      end
+      string << "\n"
       @@depth += 1
       string << children.collect {|child| child.to_s }.join("")
       @@depth -= 1
       string << "#{tabs}</#{name}>\n"
+    elsif text?
+      string << ">" << escape(text) << "</#{name}>\n"
     else
       string << "/>\n"
     end
@@ -189,6 +177,85 @@ class AXML::El
     children.push( node )
   end
 
+  ########################################################################
+  # FIND and FIND_FIRST (with a little useful xpath)
+  ########################################################################
+
+  # Returns an array of nodes.  Accepts same xpath strings as find_first.  
+  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
+
+  # currently must be called with descendant:: 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_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_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_children(name)
+    children.select {|v| v.name == name }
+  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
+
 end
 
 class AXML::XMLParser < XMLParser
@@ -200,28 +267,110 @@ class AXML::XMLParser < XMLParser
     @root.child
   end
 
+  def set_no_keep_blanks
+    instance_eval do
+      def endElement(name)
+        unless AXML::NotBlankText_re.match(@cur.text)
+          @cur.text = nil
+        end
+        @cur = @cur.parent
+      end
+    end
+  end
+
+  # returns text as an array for each occurence of the specified element: [start_index, num_bytes]
+  def set_single_text_indices(el_name)
+    @el_name = el_name
+    instance_eval do
+      def startElement(name, attributes)
+        text =
+          if name == @el_name ; []
+          else ; ''
+          end
+        new_el = ::AXML::El.new(@cur, name, attributes, text, [])
+        @cur.add_node(new_el)
+        @cur = new_el
+      end
+
+      def character(data)
+        if @cur.text.is_a? Array
+          @cur.text << byteIndex
+        else
+          @cur.text << data
+        end
+      end
+
+      def endElement(name)
+        if @cur.text.is_a? Array
+          @cur.text << (byteIndex - @cur.text.first)
+        end
+        @cur = @cur.parent
+      end
+    end
+  end
+
+  # takes opts from AXML::parse method
   def initialize
+    #@keep_blanks = opts[:keep_blanks]
     @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 character(data)
+    @cur.text << data
   end
 
   def endElement(name)
     @cur = @cur.parent
   end
 
+
+end
+
+
+
+=begin
+
+# This parser stores information about where the peaks information is in the
+# file
+# The content of the peaks node is an array where the first member is the
+# start index and the last member is the number of bytes.  All other members
+# should be ignored.
+class AXML::XMLParser::LazyPeaks < ::AXML::XMLParser
+
+  def startElement(name, attributes)
+    text =
+      if name == 'peaks' ; []
+      else ; ''
+      end
+    new_el = ::AXML::El.new(@cur, name, attributes, text, [])
+    # add the new node to the previous parent node
+    @cur.add_node(new_el)
+    # notice the change in @cur node
+    @cur = new_el
+  end
+
   def character(data)
-    @cur.text << data
+    if @cur.text.is_a? Array
+      @cur.text << byteIndex
+    else
+      @cur.text << data
+    end
   end
 
-end
+  def endElement(name)
+    if @cur.text.is_a? Array
+      @cur.text << (byteIndex - @cur.text.first)
+    end
+    @cur = @cur.parent
+  end
 
+end
 
+=end

metadata

@@ -1,55 +1,60 @@
 --- !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: 
+  version: 0.0.3
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - John Prince
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-07 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: jprince@icmb.utexas.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
 files: 
 - lib/axml.rb
 - README
 - LICENSE
 - Rakefile
-- specs/spec_helper.rb
-- specs/axml_spec.rb
-test_files: 
-- specs/axml_spec.rb
+has_rdoc: true
+homepage: 
+post_install_message: 
 rdoc_options: 
 - --main
 - README
 - --title
 - axml
-extra_rdoc_files: 
-- README
-- LICENSE
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: 
 - xmlparser is needed right now
-dependencies: []
+rubyforge_project: 
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: AXML - Provides a simple DOM for working with XML (using XMLParser under the hood) that can serve as a drop in replacement for a subset of basic libxml functionality (e.g., each, children, child, find_first, find, next).
+test_files: []
 

data/specs/axml_spec.rb

@@ -1,222 +0,0 @@
-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

@@ -1,57 +0,0 @@
-
-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
-
-