module EquivalentXml

# File lib/equivalent-xml.rb, line 70
def compare_attributes(node_1, node_2, opts, &block)

  attr_names_match = node_1.name == node_2.name

  ignore_attrs = opts[ :ignore_attr_values ]

  if ignore_attrs && (ignore_attrs.empty? || ignore_attrs.include?( node_1.name ))
    attr_names_match
  else
    attr_names_match && (node_1.value == node_2.value)
  end
end

# File lib/equivalent-xml.rb, line 91
def compare_cdata(node_1, node_2, opts, &block)
  node_1.text == node_2.text
end

# File lib/equivalent-xml.rb, line 95
def compare_children(node_1, node_2, opts, &block)
  if ignore_content?(node_1, opts)
    # Stop recursion and state a match on the children
    result = true
  else
    nodeset_1 = as_nodeset(node_1.children, opts)
    nodeset_2 = as_nodeset(node_2.children, opts)
    result = self.compare_nodesets(nodeset_1,nodeset_2,opts,&block)
  end
  
  if node_1.respond_to?(:attribute_nodes)
    attributes_1 = node_1.attribute_nodes
    attributes_2 = node_2.attribute_nodes
    result = result && self.compare_nodesets(attributes_1,attributes_2,opts,&block)
  end
  result
end

# File lib/equivalent-xml.rb, line 62
def compare_documents(node_1, node_2, opts, &block)
  self.equivalent?(node_1.root,node_2.root,opts,&block)
end

# File lib/equivalent-xml.rb, line 66
def compare_elements(node_1, node_2, opts, &block)
  (node_1.name == node_2.name) && self.compare_children(node_1,node_2,opts,&block)
end

# File lib/equivalent-xml.rb, line 31
def compare_nodes(node_1, node_2, opts, &block)
  result = nil
  if [node_1, node_2].any? { |node| not node.respond_to?(:node_type) }
    result = node_1.to_s == node_2.to_s
  elsif (node_1.class != node_2.class) or self.same_namespace?(node_1,node_2) == false
    result = false
  else
    case node_1.node_type
    when Nokogiri::XML::Node::DOCUMENT_NODE
      result = self.compare_documents(node_1,node_2,opts,&block)
    when Nokogiri::XML::Node::ELEMENT_NODE
      result = self.compare_elements(node_1,node_2,opts,&block)
    when Nokogiri::XML::Node::ATTRIBUTE_NODE
      result = self.compare_attributes(node_1,node_2,opts,&block)
    when Nokogiri::XML::Node::CDATA_SECTION_NODE
      result = self.compare_cdata(node_1,node_2,opts,&block)
    when Nokogiri::XML::Node::TEXT_NODE
      result = self.compare_text(node_1,node_2,opts,&block)
    else
      result = self.compare_children(node_1,node_2,opts,&block)
    end
  end
  if block_given?
    block_result = yield(node_1, node_2, result)
    if block_result.is_a?(TrueClass) or block_result.is_a?(FalseClass)
      result = block_result
    end
  end
  return result
end

# File lib/equivalent-xml.rb, line 113
def compare_nodesets(nodeset_1, nodeset_2, opts, &block)
  local_set_1 = nodeset_1.dup
  local_set_2 = nodeset_2.dup
  
  if local_set_1.length != local_set_2.length
    return false
  end

  local_set_1.each do |search_node|
    found_node = local_set_2.find { |test_node| self.equivalent?(search_node,test_node,opts,&block) }

    if found_node.nil?
      return false
    else
      if search_node.is_a?(Nokogiri::XML::Element) and opts[:element_order]
        if search_node.parent.elements.index(search_node) != found_node.parent.elements.index(found_node)
          return false
        end
      end
      local_set_2.delete(found_node)
    end
  end
  return local_set_2.length == 0
end

# File lib/equivalent-xml.rb, line 83
def compare_text(node_1, node_2, opts, &block)
  if opts[:normalize_whitespace]
    node_1.text.strip.gsub(/\s+/,' ') == node_2.text.strip.gsub(/\s+/,' ')
  else
    node_1.text == node_2.text
  end
end

# File lib/equivalent-xml.rb, line 19
def equivalent?(node_1, node_2, opts = {}, &block)
  opts = DEFAULT_OPTS.merge(opts)
  if [node_1, node_2].any? { |node| node.is_a?(Nokogiri::XML::NodeSet)}
    self.compare_nodesets(as_nodeset(node_1, opts), as_nodeset(node_2, opts), opts, &block)
  else
    # Don't let one node to coerced to a DocumentFragment if the other one is a Document
    node_2 = Nokogiri::XML(node_2) if node_1.is_a?(Nokogiri::XML::Document) and !node_2.is_a?(Nokogiri::XML::Node)
    node_1 = Nokogiri::XML(node_1) if node_2.is_a?(Nokogiri::XML::Document) and !node_1.is_a?(Nokogiri::XML::Node)
    self.compare_nodes(as_node(node_1), as_node(node_2), opts, &block)
  end
end

# File lib/equivalent-xml.rb, line 142
def same_namespace?(node_1, node_2)
  args = [node_1,node_2]

  # CharacterData nodes shouldn't have namespaces. But in Nokogiri,
  # they do. And they're invisible. And they get corrupted easily.
  # So let's wilfully ignore them. And while we're at it, let's
  # ignore any class that doesn't know it has a namespace.
  if args.all? { |node| not node.respond_to?(:namespace) } or 
     args.any? { |node| node.is_a?(Nokogiri::XML::CharacterData) }
       return true
  end
  
  href1 = node_1.namespace.nil? ? '' : node_1.namespace.href
  href2 = node_2.namespace.nil? ? '' : node_2.namespace.href
  return href1 == href2
end

# File lib/equivalent-xml.rb, line 160
def as_node(data)
  if data.respond_to?(:node_type)
    return data
  else
    result = Nokogiri::XML.fragment(data)
    if result.respond_to?(:root) && result.root.nil?
      return data
    else
      return result
    end
  end
end

# File lib/equivalent-xml.rb, line 173
def as_nodeset(data, opts = {})
  ignore_proc = lambda do |child|
    child.node_type == Nokogiri::XML::Node::COMMENT_NODE ||
    child.node_type == Nokogiri::XML::Node::PI_NODE ||
    (opts[:normalize_whitespace] && child.node_type == Nokogiri::XML::Node::TEXT_NODE && child.text.strip.empty?)
  end

  if data.is_a?(Nokogiri::XML::NodeSet)
    data.reject { |child| ignore_proc.call(child) }
  else
    result = Nokogiri::XML("<root>#{data}</root>")
    result.root.nil? ? data : result.root.children.reject { |child| ignore_proc.call(child) }
  end
end

# File lib/equivalent-xml.rb, line 188
def ignore_content?(node, opts = {})
  ignore_list = Array(opts[:ignore_content]).flatten.compact
  return false if ignore_list.empty?

  ignore_list.each do |selector|
    return true if node.document.css(selector).include?(node)
  end

  return false
end