htree 0.7.0

data/lib/htree/display.rb

@@ -0,0 +1,46 @@
+require 'htree/output'
+
+module HTree
+  module Node
+    # HTree::Node#display_xml prints the node as XML.
+    #
+    # The first optional argument, <i>out</i>,
+    # specifies output target.
+    # It should respond to <tt><<</tt>.
+    # If it is not specified, $stdout is used.
+    #
+    # The second optional argument, <i>encoding</i>,
+    # specifies output MIME charset (character encoding).
+    # If it is not specified, HTree::Encoder.internal_charset is used.
+    #
+    # HTree::Node#display_xml returns <i>out</i>.
+    def display_xml(out=$stdout, encoding=HTree::Encoder.internal_charset)
+      encoder = HTree::Encoder.new(encoding)
+      self.output(encoder, HTree::DefaultContext)
+      # don't call finish_with_xmldecl because self already has a xml decl.
+      out << encoder.finish
+      out
+    end
+
+    # HTree::Node#display_html prints the node as HTML.
+    #
+    # The first optional argument, <i>out</i>,
+    # specifies output target.
+    # It should respond to <tt><<</tt>.
+    # If it is not specified, $stdout is used.
+    #
+    # The second optional argument, <i>encoding</i>,
+    # specifies output MIME charset (character encoding).
+    # If it is not specified, HTree::Encoder.internal_charset is used.
+    #
+    # HTree::Node#display_html returns <i>out</i>.
+    def display_html(out=$stdout, encoding=HTree::Encoder.internal_charset)
+      encoder = HTree::Encoder.new(encoding)
+      encoder.html_output = true
+      self.output(encoder, HTree::HTMLContext)
+      out << encoder.finish
+      out
+    end
+
+  end
+end

data/lib/htree/doc.rb

@@ -0,0 +1,149 @@
+require 'htree/modules'
+require 'htree/container'
+
+module HTree
+  class Doc
+    # :stopdoc:
+    class << self
+      alias new! new
+    end
+    # :startdoc:
+
+    # The arguments should be a sequence of follows.
+    # [String object] specified string is converted to HTree::Text.
+    # [HTree::Node object] used as a child.
+    # [HTree::Doc object]
+    #   used as children.
+    #   It is expanded except HTree::XMLDecl and HTree::DocType objects.
+    # [Array of String, HTree::Node and HTree::Doc] used as children.
+    #
+    def Doc.new(*args)
+      children = []
+      args.each {|arg|
+        arg = arg.to_node if HTree::Location === arg
+        case arg
+        when Array
+          arg.each {|a|
+            a = a.to_node if HTree::Location === a
+            case a
+            when HTree::Doc
+              children.concat(a.children.reject {|c|
+                HTree::XMLDecl === c || HTree::DocType === c
+              })
+            when HTree::Node
+              children << a
+            when String
+              children << Text.new(a)
+            else
+              raise TypeError, "unexpected argument: #{arg.inspect}"
+            end
+          }
+        when HTree::Doc
+          children.concat(arg.children.reject {|c|
+            HTree::XMLDecl === c || HTree::DocType === c
+          })
+        when HTree::Node
+          children << arg
+        when String
+          children << Text.new(arg)
+        else
+          raise TypeError, "unexpected argument: #{arg.inspect}"
+        end
+      }
+      new!(children)
+    end
+
+    def initialize(children=[]) # :notnew:
+      @children = children.dup.freeze
+      unless @children.all? {|c| c.kind_of?(HTree::Node) and !c.kind_of?(HTree::Doc) }
+        unacceptable = @children.reject {|c| c.kind_of?(HTree::Node) and !c.kind_of?(HTree::Doc) }
+        unacceptable = unacceptable.map {|uc| uc.inspect }.join(', ')
+        raise TypeError, "Unacceptable document child: #{unacceptable}"
+      end
+    end 
+
+    def get_subnode_internal(index) # :nodoc:
+      unless Integer === index
+        raise TypeError, "invalid index: #{index.inspect}"
+      end
+      if index < 0 || @children.length <= index
+        nil
+      else
+        @children[index]
+      end
+    end
+
+    #   doc.subst_subnode(pairs) -> doc
+    #
+    # The argument _pairs_ should be a hash or an assocs.
+    # Its key should be an integer which means an index for children.
+    #
+    # Its value should be one of follows.
+    # [HTree::Node object] specified object is used as is.
+    # [String object] specified string is converted to HTree::Text
+    # [Array of above] specified HTree::Node and String is used in that order.
+    # [nil] delete corresponding node.
+    #
+    #   d = HTree('<a/><b/><c/>')        
+    #   p d.subst_subnode({0=>HTree('<x/>'), 2=>HTree('<z/>')})
+    #   p d.subst_subnode([[0,HTree('<x/>')], [2,HTree('<z/>')]])
+    #   # =>
+    #   #<HTree::Doc {emptyelem <x>} {emptyelem <b>} {emptyelem <z>}>
+    #   #<HTree::Doc {emptyelem <x>} {emptyelem <b>} {emptyelem <z>}>
+    #
+    def subst_subnode(pairs)
+      hash = {}
+      pairs.each {|index, value|
+        unless Integer === index
+          raise TypeError, "invalid index: #{index.inspect}"
+        end
+        value = value.to_node if HTree::Location === value
+        case value
+        when Node
+          value = [value]
+        when String
+          value = [value]
+        when Array
+          value = value.dup
+        when nil
+          value = []
+        else
+          raise TypeError, "invalid value: #{value.inspect}"
+        end
+        value.map! {|v|
+          v = v.to_node if HTree::Location === v
+          case v
+          when Node
+            v
+          when String
+            Text.new(v)
+          else
+            raise TypeError, "invalid value: #{v.inspect}"
+          end
+        }
+        if !hash.include?(index)
+          hash[index] = []
+        end
+        hash[index].concat value
+      }
+
+      children_left = []
+      children = @children.dup
+      children_right = []
+
+      hash.keys.sort.each {|index|
+        value = hash[index]
+        if index < 0
+          children_left << value
+        elsif children.length <= index
+          children_right << value
+        else
+          children[index] = value
+        end
+      }
+
+      children = [children_left, children, children_right].flatten.compact
+      Doc.new(children)
+    end
+  end 
+end

data/lib/htree/elem.rb

@@ -0,0 +1,262 @@
+require 'htree/modules'
+require 'htree/tag'
+require 'htree/context'
+require 'htree/container'
+
+module HTree
+  class Elem
+    # :stopdoc:
+    class << self
+      alias new! new
+    end
+    # :startdoc:
+
+    # The first argument _name_ should be an instance of String or HTree::Name.
+    #
+    # The rest of arguments should be a sequence of follows.
+    # [Hash object] used as attributes.
+    # [String object] specified string is converted to HTree::Text.
+    # [HTree::Node object] used as a child.
+    # [HTree::Doc object]
+    #   used as children.
+    #   It is expanded except HTree::XMLDecl and HTree::DocType objects.
+    # [Array of String, HTree::Node, HTree::Doc] used as children.
+    # [HTree::Context object]
+    #   used as as context which represents XML namespaces.
+    #   This should apper once at most.
+    #
+    # HTree::Location object is accepted just as HTree::Node.
+    #
+    # If the rest arguments consists only
+    # Hash and HTree::Context, empty element is created.
+    #
+    #   p HTree::Elem.new("e").empty_element?     # => true
+    #   p HTree::Elem.new("e", []).empty_element? # => false
+    def Elem.new(name, *args)
+      attrs = []
+      children = []
+      context = nil
+      args.each {|arg|
+        arg = arg.to_node if HTree::Location === arg
+        case arg
+        when Context
+          raise ArgumentError, "multiple context" if context
+          context = arg
+        when Hash
+          arg.each {|k, v| attrs << [k, v] }
+        when Array
+          arg.each {|a|
+            a = a.to_node if HTree::Location === a
+            case a
+            when HTree::Doc
+              children.concat(a.children.reject {|c|
+                HTree::XMLDecl === c || HTree::DocType === c
+              })
+            when HTree::Node
+              children << a
+            when String
+              children << Text.new(a)
+            else
+              raise TypeError, "unexpected argument: #{arg.inspect}"
+            end
+          }
+        when HTree::Doc
+          children.concat(arg.children.reject {|c|
+            HTree::XMLDecl === c || HTree::DocType === c
+          })
+        when HTree::Node
+          children << arg
+        when String
+          children << Text.new(arg)
+
+        else
+          raise TypeError, "unexpected argument: #{arg.inspect}"
+        end
+      }
+      context ||= DefaultContext
+      if children.empty? && args.all? {|arg| Hash === arg || Context === arg }
+        children = nil
+      end
+      new!(STag.new(name, attrs, context), children)
+    end
+
+    def initialize(stag, children=nil, etag=nil) # :notnew:
+      unless stag.class == STag
+        raise TypeError, "HTree::STag expected: #{stag.inspect}"
+      end
+      unless !children || children.all? {|c| c.kind_of?(HTree::Node) and !c.kind_of?(HTree::Doc) }
+        unacceptable = children.reject {|c| c.kind_of?(HTree::Node) and !c.kind_of?(HTree::Doc) }
+        unacceptable = unacceptable.map {|uc| uc.inspect }.join(', ')
+        raise TypeError, "Unacceptable element child: #{unacceptable}"
+      end
+      unless !etag || etag.class == ETag
+        raise TypeError, "HTree::ETag expected: #{etag.inspect}"
+      end
+      @stag = stag
+      @children = (children ? children.dup : []).freeze
+      @empty = children == nil && etag == nil
+      @etag = etag
+    end
+
+    def context; @stag.context end
+
+    # +element_name+ returns the name of the element name as a Name object.
+    def element_name() @stag.element_name end
+
+    def empty_element?
+      @empty
+    end
+
+    def each_attribute(&block) # :yields: attr_name, attr_text
+      @stag.each_attribute(&block)
+    end
+
+    def get_subnode_internal(index) # :nodoc:
+      case index
+      when String
+        name = Name.parse_attribute_name(index, DefaultContext)
+        update_attribute_hash[name.universal_name]
+      when Name
+        update_attribute_hash[index.universal_name]
+      when Integer
+        if index < 0 || @children.length <= index
+          nil
+        else
+          @children[index]
+        end
+      else
+        raise TypeError, "invalid index: #{index.inspect}"
+      end
+    end
+
+    # call-seq:
+    #   elem.subst_subnode(pairs) -> elem
+    #
+    # The argument _pairs_ should be a hash or an assocs.
+    #
+    # The key of pairs should be one of following.
+    # [HTree::Name or String object] attribute name.
+    # [Integer object] child index.
+    #
+    # The value of pairs should be one of follows.
+    # [HTree::Node object] specified object is used as is.
+    # [String object] specified string is converted to HTree::Text
+    # [Array of above] specified HTree::Node and String is used in that order.
+    # [nil] delete corresponding node.
+    #
+    #   e = HTree('<r><a/><b/><c/></r>').root
+    #   p e.subst_subnode({0=>HTree('<x/>'), 2=>HTree('<z/>')})  
+    #   p e.subst_subnode([[0, HTree('<x/>')], [2,HTree('<z/>')]])
+    #   # =>
+    #   {elem <r> {emptyelem <x>} {emptyelem <b>} {emptyelem <z>}}
+    #   {elem <r> {emptyelem <x>} {emptyelem <b>} {emptyelem <z>}}
+    #
+    def subst_subnode(pairs)
+      hash = {}
+      pairs.each {|index, value|
+        case index
+        when Name, Integer
+        when String
+          index = Name.parse_attribute_name(index, DefaultContext)
+        else
+          raise TypeError, "invalid index: #{index.inspect}"
+        end
+        value = value.to_node if HTree::Location === value
+        case value
+        when Node
+          value = [value]
+        when String
+          value = [value]
+        when Array
+          value = value.dup
+        when nil
+          value = []
+        else
+          raise TypeError, "invalid value: #{value.inspect}"
+        end
+        value.map! {|v|
+          v = v.to_node if HTree::Location === v
+          case v
+          when Node
+            v
+          when String
+            Text.new(v)
+          else
+            raise TypeError, "invalid value: #{v.inspect}"
+          end
+        }
+        if !hash.include?(index)
+          hash[index] = []
+        end
+        hash[index].concat value
+      }
+
+      attrs = []
+      @stag.attributes.each {|k, v|
+        if hash.include? k
+          v = hash[k]
+          if !v.empty?
+            attrs << {k=>Text.concat(*v)}
+          end
+          hash.delete k
+        else
+          attrs << {k=>v}
+        end
+      }
+      hash.keys.each {|k|
+        if Name === k
+          v = hash[k]
+          if !v.empty?
+            attrs << {k=>Text.concat(*v)}
+          end
+          hash.delete k
+        end
+      }
+
+      children_left = []
+      children = @children.dup
+      children_right = []
+
+      hash.keys.sort.each {|index|
+        value = hash[index]
+        if index < 0
+          children_left << value
+        elsif children.length <= index
+          children_right << value
+        else
+          children[index] = value
+        end
+      }
+
+      children = [children_left, children, children_right].flatten
+
+      if children.empty? && @empty
+        Elem.new(
+          @stag.element_name,
+          @stag.context,
+          *attrs)
+      else 
+        Elem.new(
+          @stag.element_name,
+          @stag.context,
+          children,
+          *attrs)
+      end
+    end
+  end 
+
+  module Elem::Trav
+    private
+    def update_attribute_hash
+      if defined?(@attribute_hash)
+        @attribute_hash
+      else
+        h = {}
+        each_attribute {|name, text|
+          h[name.universal_name] = text
+        }
+        @attribute_hash = h
+      end
+    end
+  end
+end