# encoding: UTF-8


module LibXML
  module XML
    class Attr 
      include Enumerable

      # call-seq:

      #    attr.child? -> (true|false)

      #

      # Returns whether this attribute has child attributes.

      #

      def child?
        not self.children.nil?
      end

      # call-seq:

      #    attr.doc? -> (true|false)

      #

      # Determine whether this attribute is associated with an

      # XML::Document.

      def doc?
        not self.doc.nil?
      end

      # call-seq:

      #    attr.last? -> (true|false)

      #

      # Determine whether this is the last attribute.

      def last?
        self.last.nil?
      end

      # call-seq:

      #    attr.next? -> (true|false)

      #

      # Determine whether there is a next attribute.

      def next?
        not self.next.nil?
      end

      # call-seq:

      #    attr.ns? -> (true|false)

      #

      # Determine whether this attribute has an associated

      # namespace.

      def ns?
        not self.ns.nil?
      end

      # call-seq:

      #   attr.namespacess -> XML::Namespaces

      #

      # Returns this node's XML::Namespaces object,

      # which is used to access the namespaces

      # associated with this node.

      def namespaces
        @namespaces ||= XML::Namespaces.new(self)
      end
      
      #

      # call-seq:

      #    attr.parent? -> (true|false)

      #

      # Determine whether this attribute has a parent.

      def parent?
        not self.parent.nil?
      end

      # call-seq:

      #    attr.prev? -> (true|false)

      #

      # Determine whether there is a previous attribute.

      def prev?
        not self.prev.nil?
      end

      # Returns this node's type name

      def node_type_name
        if node_type == Node::ATTRIBUTE_NODE
          'attribute'
        else
          raise(UnknownType, "Unknown node type: %n", node.node_type);
        end
      end

      # Iterates nodes and attributes

      def siblings(node, &blk)
        if n = node
          loop do
            blk.call(n)
            break unless n = n.next
          end
        end
      end

      def each_sibling(&blk)
        siblings(self,&blk)
      end
  
      alias :each_attr :each_sibling
      alias :each :each_sibling
  
      def to_h
        inject({}) do |h,a|
          h[a.name] = a.value
          h
        end
      end

      def to_a
        inject([]) do |ary,a| 
          ary << [a.name, a.value]
          ary
        end
      end
  
      def to_s
        "#{name} = #{value}"
      end
    end
  end
end