axml 0.0.3 → 0.0.4

data/lib/axml/autoload.rb

@@ -0,0 +1,106 @@
+
+require 'axml'
+
+module AXML
+  module Autoload
+    class << self
+      # if given a name, loads the parser class name if no arg (or nil) tries
+      # to load a parser from the AXML::PREFERRED list, returning the first
+      # one that works.  Sets AXML::DEFAULT[:parser] with the parser name if
+      # it is available and raises any warnings in AXML::WARN.  Raises a
+      # RuntimeError if no parser is found.
+      def parser!(name=nil)
+        parser_name_to_use = nil
+        parser_obj = nil
+        if name.nil?
+          PREFERRED.each do |nm|
+            parser_obj = load(nm)
+            if parser_obj 
+              parser_name_to_use = nm
+              break
+            end
+          end
+        else
+          parser_name_to_use = name
+          parser_obj = parser(name)
+        end
+        if message = WARN[parser_obj]
+          warn message
+        end
+        if parser_obj
+          AXML::DEFAULTS[:parser] = parser_name_to_use
+        else
+          STDERR.puts "NO PARSERS CURRENTLY AVAILABLE!"
+          STDERR.puts "INSTALL INSTRUCTIONS:"
+          STDERR.puts "*****************************************************"
+          STDERR.puts install_instructions(:all)
+          STDERR.puts "*****************************************************"
+          raise RuntimeError, "no parser currently available!"
+        end
+        parser_obj
+      end
+
+      # loads the parser (if available) and returns an object ( that should
+      # respond_to parse_io and parse_string. If the parser is not available
+      # returns nil.
+      def parser(name)
+        req = 'axml/' << name.to_s.gsub('_', '/')
+        begin
+          require req
+          const_str = AXML::CLASS_MAPPINGS[name]
+          if AXML.const_defined?(const_str)
+            AXML.const_get(const_str)
+          else
+            nil
+          end
+        rescue LoadError
+          nil
+        end
+      end
+
+      def install_instructions(name)
+        if name == :all
+          doublets = AXML::PREFERRED.map do |nm|
+            [nm, install_instructions(nm)]
+          end
+          string = ""
+          doublets.each do |k,v|
+            if v
+              string << '-' * k.to_s.size << "\n"
+              string << "#{k}\n"
+              string << '-' * k.to_s.size << "\n"
+              string << "#{v}"
+            end
+          end
+          string
+        else
+          case name
+          when :xmlparser
+            string = <<END
+debian/ubuntu: sudo apt-get install libxml-parser-ruby1.8
+
+cygwin:
+   Download the XMLParser module: http://www.yoshidam.net/Ruby.html
+   Build and install:
+       ruby extconf.rb --with-expat-lib=/usr/lib \ 
+                     --with-expat-include=/usr/include
+       make
+       make site-install
+
+windows: included in one-click-installer
+END
+          when :libxml
+            string = <<END 
+deb/ubuntu: sudo apt-get install libxml-ruby
+
+install as gem:
+    sudo gem install -r libxml-ruby
+
+for more info: http://libxml.rubyforge.org/install.xml
+END
+          end
+        end
+      end
+    end
+  end
+end

data/lib/axml/el.rb

@@ -0,0 +1,208 @@
+
+require 'axml/traverse'
+
+module AXML ; end
+
+AXML::El = Struct.new(:parent, :name, :attrs, :text, :children, :array_index)
+
+class AXML::El
+  include Enumerable
+  include Traverseable
+
+  # 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
+
+  alias_method  :content, :text
+  alias_method  :content=, :text=
+  alias_method  :kids, :children
+  alias_method  :kids=, :children=
+
+  def [](attribute_string)
+    attrs[attribute_string]
+  end
+
+  def []=(attribute_string, value)
+    attrs[attribute_string] = value
+  end
+
+  # has text?
+  def text?
+    !!text
+  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
+
+  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(indent=0)
+    attstring = ""
+    if attrs.size > 0
+      attstring = " " + attrs.collect { |k,v| "#{k}=\"#{escape(v)}\"" }.join(" ")
+    end
+    string = "#{Indentation[indent]}<#{name}#{attstring}"
+    if children.size > 0
+      string << ">"
+      if text?
+        string << escape(text)
+      end
+      string << "\n"
+      string << children.collect {|child| child.to_s(indent+1) }.join("")
+      string << "#{Indentation[indent]}</#{name}>\n"
+    elsif text?
+      string << ">" << escape(text) << "</#{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
+
+  ########################################################################
+  # 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
+

data/lib/axml/libxml.rb

@@ -0,0 +1,110 @@
+
+require 'xml/libxml'
+require 'axml/traverse'
+
+module AXML ; end 
+
+# if using AXML::LibXML, LibXML::XML::Node behavior is slightly modified from
+# the default LibXML behavior:
+#     1. there are no 'text' nodes.  Some nodes have text, some do not
+#     2. :text? returns true if the node has text (in LibXML this returns true
+#     if the node *is* a text node)
+#     3.  text
+class AXML::LibXML
+  extend AXML
+  class << self
+
+    # beware that threading with different :keep_blanks values could cause
+    # problems since this is a global Libxml setting
+    def parse_io(io, opts={})
+      opts = AXML::DEFAULTS.merge opts
+      XML::Parser.default_keep_blanks = opts[:keep_blanks] if opts.key?(:keep_blanks)
+      XML::Parser.io(io).parse.root
+    end
+
+    # beware that threading with different :keep_blanks values could cause
+    # problems since this is a global Libxml setting
+    def parse_string(string, opts={})
+      opts = AXML::DEFAULTS.merge opts
+      XML::Parser.default_keep_blanks = opts[:keep_blanks] if opts.key?(:keep_blanks)
+      XML::Parser.string(string).parse.root
+    end
+  end
+end
+
+class LibXML::XML::Node
+  include Traverseable
+
+  alias_method :old_child, :child
+  alias_method :old_text?, :text?
+  alias_method :old_content, :content
+
+  def text?
+    self.old_child.old_text?
+  end
+
+  def text
+    cont = self.old_content
+    if cont == ""
+      nil
+    else
+      cont
+    end
+
+    #kid = self.old_child
+    #return nil unless kid
+    ##p(kid.methods - Object.methods)
+    #if kid.old_text?
+    #  kid.to_s
+    #end
+  end
+  alias_method :content, :text
+
+  def child
+    kid = self.old_child
+    return nil if kid.nil?
+    while kid.old_text?
+      kid = kid.old_child
+      return nil if kid.nil?
+    end
+    kid
+  end
+
+  def find_first_child(name)
+    find_first("child::#{name}")
+  end
+  def find_children(name)
+    find("child::#{name}")
+  end
+  def find_first_descendant(name)
+    find_first("descendant::#{name}")
+  end
+
+  # full traversal from the initial node
+  def traverse(type=:pre, &block)
+    if type == :pre
+      block.call(self) unless self.old_text?
+    end
+    children.each do |child|
+      child.traverse(type, &block)
+    end
+    if type == :post
+      block.call(self) unless self.old_text?
+    end
+  end
+
+
+  alias_method :kids, :children
+  alias_method :attrs, :attributes
+  alias_method :drop, :remove!
+
+end
+
+class LibXML::XML::Attributes
+  def values_at(*args)
+    args.map do |arg|
+      self[arg]
+    end
+  end
+end
+

data/lib/axml/traverse.rb

@@ -0,0 +1,15 @@
+
+module Traverseable
+  # full traversal from the initial node
+  def traverse(type=:pre, &block)
+    if type == :pre
+      block.call(self)
+    end
+    children.each do |child|
+      child.traverse(type, &block)
+    end
+    if type == :post
+      block.call(self)
+    end
+  end
+end

data/lib/axml/xmlparser.rb

@@ -0,0 +1,114 @@
+require 'xmlparser'
+require 'axml/el'
+
+class AXML::XMLParser
+  extend AXML
+
+  class << self
+
+    def parse_io(io, opts=DEFAULTS)
+      parser = AXML::XMLParser::Parser.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(io)
+      parser.root
+    end
+
+    def parse_string(arg, opts=DEFAULTS)
+      parse_io(arg, opts)
+    end
+
+  end
+end
+
+class AXML::XMLParser::Parser < XMLParser
+  NotBlankText_re = /[^\s+]+/m
+
+  attr_writer :root
+
+  # returns the first node found in the document
+  def root
+    @root.child
+  end
+
+  def set_no_keep_blanks
+    instance_eval do
+      def endElement(name)
+        unless 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
+
+      tmpvar = $VERBOSE ; $VERBOSE = nil
+      def endElement(name)
+        if @cur.text.is_a? Array
+          @cur.text << (byteIndex - @cur.text.first)
+        end
+        @cur = @cur.parent
+      end
+      $VERBOSE = tmpvar
+    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, '', [])
+    @cur.add_node(new_el)
+    @cur = new_el
+  end
+
+  def character(data)
+    @cur.text << data
+  end
+
+  def endElement(name)
+    @cur = @cur.parent
+  end
+
+end
+