xqsr3-xml 0.1.1 → 0.1.3

data/lib/xqsr3/xml/utilities/compare.rb

@@ -1,18 +1,18 @@
-
+# frozen_string_literal: true
 # ######################################################################## #
-# File:         lib/xqsr3/xml/_utilities/compare.rb
+# File:     lib/xqsr3/xml/_utilities/compare.rb
 #
-# Purpose:      Definition of the ::Xqsr3::XML::Utilities::Compare
-#               module
+# Purpose:  Definition of the ::Xqsr3::XML::Utilities::Compare module
 #
-# Created:      30th July 2017
-# Updated:      16th August 2018
+# Created:  30th July 2017
+# Updated:  19th August 2026
 #
-# Home:         http://github.com/synesissoftware/xqsr3
+# Home:     http://github.com/synesissoftware/xqsr3
 #
-# Author:       Matthew Wilson
+# Author:   Matthew Wilson
 #
-# Copyright (c) 2017-2018, Matthew Wilson and Synesis Software
+# Copyright (c) 2019-2026, Matthew Wilson and Synesis Information Systems
+# Copyright (c) 2017-2019, Matthew Wilson and Synesis Software
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -63,475 +63,475 @@ module Utilities
 
 module Compare
 
-	# Class that represents the result of an XML comparison
-	#
-	# NOTE: Sadly, we cannot create instances of +FalseClass+/+TrueClass+,
-	# to which we could then add a +reason+ attribute, so instead we must
-	# have a results class
-	class Result
+  # Class that represents the result of an XML comparison
+  #
+  # NOTE: Sadly, we cannot create instances of +FalseClass+/+TrueClass+,
+  # to which we could then add a +reason+ attribute, so instead we must
+  # have a results class
+  class Result
 
-		include ::Xqsr3::Quality::ParameterChecking
+    include ::Xqsr3::Quality::ParameterChecking
 
-		protected :check_parameter
+    protected :check_parameter
 
-		#
-		# Options:
-		#
-		# +:different_attributes+
-		# +:different_attribute_count+
-		# +:different_attribute_order+
-		# +:different_child_node_count+
-		# +:different_child_node_order+
-		# +:different_child_nodes+
-		# +:different_node_names+
-		# +:different_node_contents+
-		# +:parameter_is_empty+
-		# +:parameter_is_nil+
-		# +:+
+    #
+    # Options:
+    #
+    # +:different_attributes+
+    # +:different_attribute_count+
+    # +:different_attribute_order+
+    # +:different_child_node_count+
+    # +:different_child_node_order+
+    # +:different_child_nodes+
+    # +:different_node_names+
+    # +:different_node_contents+
+    # +:parameter_is_empty+
+    # +:parameter_is_nil+
+    # +:+
 
-		def initialize status, reason, **options
+    def initialize status, reason, **options
 
-			@call_stack	=	caller(2)
+      @call_stack = caller(2)
 
-			check_parameter status, 'status', types: [ ::FalseClass, ::TrueClass ]
-			check_parameter reason, 'reason', type: ::Symbol, allow_nil: true
+      check_parameter status, 'status', types: [ ::FalseClass, ::TrueClass ]
+      check_parameter reason, 'reason', type: ::Symbol, allow_nil: true
 
-			@status		=	status
-			@reason		=	reason
+      @status   = status
+      @reason   = reason
 
-			@lhs_node	=	options[:lhs_node]
-			@rhs_node	=	options[:rhs_node]
-		end
+      @lhs_node = options[:lhs_node]
+      @rhs_node = options[:rhs_node]
+    end
 
-		def self.return status, reason, **options
+    def self.return status, reason, **options
 
-			return self.new status, reason, **options
-		end
+      return self.new status, reason, **options
+    end
 
-		def self.same reason = nil, **options
+    def self.same reason = nil, **options
 
-			return self.new true, reason, **options
-		end
+      return self.new true, reason, **options
+    end
 
-		def self.different reason, **options
+    def self.different reason, **options
 
-			return self.new false, reason, **options
-		end
+      return self.new false, reason, **options
+    end
 
-		attr_reader :call_stack
-		attr_reader :status
-		attr_reader :reason
+    attr_reader :call_stack
+    attr_reader :status
+    attr_reader :reason
 
-		def different?
+    def different?
 
-			!status
-		end
+      !status
+    end
 
-		def same?
+    def same?
 
-			status
-		end
+      status
+    end
 
-		def details
+    def details
 
-			r	=	reason.to_s.gsub(/_/, ' ')
+      r = reason.to_s.gsub(/_/, ' ')
 
-			qualifying	=	''
+      qualifying  = ''
 
-			if @lhs_node
+      if @lhs_node
 
-				qualifying	+=	'; ' unless qualifying.empty?
-				qualifying	+=	"lhs-node=#{@lhs_node}"
-			end
+        qualifying  +=  '; ' unless qualifying.empty?
+        qualifying  +=  "lhs-node=#{@lhs_node}"
+      end
 
-			if @rhs_node
+      if @rhs_node
 
-				qualifying	+=	'; ' unless qualifying.empty?
-				qualifying	+=	"rhs-node=#{@rhs_node}"
-			end
+        qualifying  +=  '; ' unless qualifying.empty?
+        qualifying  +=  "rhs-node=#{@rhs_node}"
+      end
 
-			r = "#{r}: #{qualifying}" unless qualifying.empty?
+      r = "#{r}: #{qualifying}" unless qualifying.empty?
 
-			r
-		end
+      r
+    end
 
-		def to_s
+    def to_s
 
-			return 'same' if same?
+      return 'same' if same?
 
-			"different, because: #{details}"
-		end
-	end
+      "different, because: #{details}"
+    end
+  end
 
-	module Internal_Compare_
+  module Internal_Compare_
 
-		include ::Xqsr3::XML::Utilities::Navigation
+    include ::Xqsr3::XML::Utilities::Navigation
 
-		extend ::Xqsr3::Quality::ParameterChecking
+    extend ::Xqsr3::Quality::ParameterChecking
 
-		DEFAULT_OPTIONS = {
+    DEFAULT_OPTIONS = {
 
-			debug: false,
-#			element_order: false,
-			equate_nil_and_empty: false,
-			ignore_attributes: false,
-			ignore_attribute_order: true,
-			ignore_child_node_order: true,
-			ignore_content: false,
-			ignore_content_case: false,
-			ignore_xml_declarations: true,
-			normalise_whitespace: true,
-#			normalize_whitespace: true,
-			validate_params: true,
-		}
+      debug: false,
+#     element_order: false,
+      equate_nil_and_empty: false,
+      ignore_attributes: false,
+      ignore_attribute_order: true,
+      ignore_child_node_order: true,
+      ignore_content: false,
+      ignore_content_case: false,
+      ignore_xml_declarations: true,
+      normalise_whitespace: true,
+#     normalize_whitespace: true,
+      validate_params: true,
+    }
 
-		ORDER_OPTIONS_SYMBOLS = [
+    ORDER_OPTIONS_SYMBOLS = [
 
-			:element_order,
-			:ignore_attribute_order,
-			:ignore_child_node_order,
-			:ignore_content,
-			:ignore_content_case,
-		]
+      :element_order,
+      :ignore_attribute_order,
+      :ignore_child_node_order,
+      :ignore_content,
+      :ignore_content_case,
+    ]
 
-		WHITESPACE_OPTIONS_SYMBOLS = [
+    WHITESPACE_OPTIONS_SYMBOLS = [
 
-			:normalise_whitespace,
-			:normalize_whitespace,
-		]
+      :normalise_whitespace,
+      :normalize_whitespace,
+    ]
 
-		def self.derive_options_ given_options
+    def self.derive_options_ given_options
 
-			default_options	=	DEFAULT_OPTIONS
-			derived_options	=	{}.merge given_options
+      default_options = DEFAULT_OPTIONS
+      derived_options = {}.merge given_options
 
 
-			# sort whitespace
+      # sort whitespace
 
-			if WHITESPACE_OPTIONS_SYMBOLS.any? { |sym| given_options.has_key? sym }
+      if WHITESPACE_OPTIONS_SYMBOLS.any? { |sym| given_options.has_key? sym }
 
-				default_options	=	default_options.reject { |k, v| WHITESPACE_OPTIONS_SYMBOLS.include? k }
-			end
+        default_options = default_options.reject { |k, v| WHITESPACE_OPTIONS_SYMBOLS.include? k }
+      end
 
-			if given_options.has_key? :normalise_whitespace
+      if given_options.has_key? :normalise_whitespace
 
-				derived_options.delete :normalize_whitespace
-			elsif given_options.has_key? :normalize_whitespace
+        derived_options.delete :normalize_whitespace
+      elsif given_options.has_key? :normalize_whitespace
 
-				derived_options[:normalise_whitespace] = given_options[:normalize_whitespace]
+        derived_options[:normalise_whitespace] = given_options[:normalize_whitespace]
 
-				derived_options.delete :normalize_whitespace
-			end
+        derived_options.delete :normalize_whitespace
+      end
 
 
-			# sort element-order
+      # sort element-order
 
-			if ORDER_OPTIONS_SYMBOLS.any? { |sym| given_options.has_key? sym }
+      if ORDER_OPTIONS_SYMBOLS.any? { |sym| given_options.has_key? sym }
 
-				default_options	=	default_options.reject { |k, v| ORDER_OPTIONS_SYMBOLS.include? k }
-			end
+        default_options = default_options.reject { |k, v| ORDER_OPTIONS_SYMBOLS.include? k }
+      end
 
-			if given_options.has_key? :element_order
+      if given_options.has_key? :element_order
 
-				element_order	=	given_options[:element_order]
+        element_order = given_options[:element_order]
 
-				derived_options[:ignore_attribute_order]	=	!element_order
-				derived_options[:ignore_child_node_order]	=	!element_order
-			end
+        derived_options[:ignore_attribute_order]  = !element_order
+        derived_options[:ignore_child_node_order] = !element_order
+      end
 
-			derived_options[:ignore_attribute_order]	=	given_options[:ignore_attribute_order] if given_options.has_key? :ignore_attribute_order
-			derived_options[:ignore_child_node_order]	=	given_options[:ignore_child_node_order] if given_options.has_key? :ignore_child_node_order
+      derived_options[:ignore_attribute_order]  = given_options[:ignore_attribute_order] if given_options.has_key? :ignore_attribute_order
+      derived_options[:ignore_child_node_order] = given_options[:ignore_child_node_order] if given_options.has_key? :ignore_child_node_order
 
-			default_options.merge derived_options
-		end
+      default_options.merge derived_options
+    end
 
-		def self.one_line_ s
+    def self.one_line_ s
 
-			s = s.to_s.gsub(/\s+/, ' ')
-		end
+      s = s.to_s.gsub(/\s+/, ' ')
+    end
 
-		#
-		# +:debug+
-		# +:element_order+
-		# +:equate_nil_and_empty+
-		# +:ignore_attributes+
-		# +:ignore_attribute_order+
-		# +:ignore_xml_declarations+
-		# +:normalise_whitespace+
-		# +:normalize_whitespace+
-		# +:validate_params+
-		#
+    #
+    # +:debug+
+    # +:element_order+
+    # +:equate_nil_and_empty+
+    # +:ignore_attributes+
+    # +:ignore_attribute_order+
+    # +:ignore_xml_declarations+
+    # +:normalise_whitespace+
+    # +:normalize_whitespace+
+    # +:validate_params+
+    #
 
-		def self.xml_compare_ lhs, rhs, options
+    def self.xml_compare_ lhs, rhs, options
 
-			$stderr.puts "#{self}#{__method__}(lhs (#{lhs.class})=#{self.one_line_ lhs}, rhs (#{rhs.class})=#{self.one_line_ rhs}, options (#{options.class})=#{options})" if $DEBUG
+      $stderr.puts "#{self}#{__method__}(lhs (#{lhs.class})=#{self.one_line_ lhs}, rhs (#{rhs.class})=#{self.one_line_ rhs}, options (#{options.class})=#{options})" if $DEBUG
 
-			# validate parameter(s)
+      # validate parameter(s)
 
-			check_parameter options, 'options', type: ::Hash if $DEBUG
+      check_parameter options, 'options', type: ::Hash if $DEBUG
 
-			validate_params	=	$DEBUG || options[:debug] || options[:validate_params]
+      validate_params = $DEBUG || options[:debug] || options[:validate_params]
 
-			check_parameter lhs, 'lhs', types: [ ::String, ::Nokogiri::XML::Node ], allow_nil: true if validate_params
-			check_parameter rhs, 'rhs', types: [ ::String, ::Nokogiri::XML::Node ], allow_nil: true if validate_params
+      check_parameter lhs, 'lhs', types: [ ::String, ::Nokogiri::XML::Node ], allow_nil: true if validate_params
+      check_parameter rhs, 'rhs', types: [ ::String, ::Nokogiri::XML::Node ], allow_nil: true if validate_params
 
-			options			=	self.derive_options_ options
+      options     = self.derive_options_ options
 
-			# deal with nil(s)
+      # deal with nil(s)
 
-			return Result.same if lhs.nil? && rhs.nil?
+      return Result.same if lhs.nil? && rhs.nil?
 
-			if lhs.nil?
+      if lhs.nil?
 
-				return Result.same if options[:equate_nil_and_empty] && ::String === rhs && rhs.empty?
+        return Result.same if options[:equate_nil_and_empty] && ::String === rhs && rhs.empty?
 
-				return Result.different :parameter_is_nil
-			end
+        return Result.different :parameter_is_nil
+      end
 
-			if rhs.nil?
+      if rhs.nil?
 
-				return Result.same if options[:equate_nil_and_empty] && ::String === lhs && lhs.empty?
+        return Result.same if options[:equate_nil_and_empty] && ::String === lhs && lhs.empty?
 
-				return Result.different :parameter_is_nil
-			end
+        return Result.different :parameter_is_nil
+      end
 
 
-			# deal with string(s)
+      # deal with string(s)
 
-			lhs	=	Nokogiri::XML(lhs) if ::String === lhs
-			rhs	=	Nokogiri::XML(rhs) if ::String === rhs
+      lhs = Nokogiri::XML(lhs) if ::String === lhs
+      rhs = Nokogiri::XML(rhs) if ::String === rhs
 
 
 
-			# deal with XML Declaration(s)
+      # deal with XML Declaration(s)
 
-			if options[:ignore_xml_declarations]
+      if options[:ignore_xml_declarations]
 
-				if ::Nokogiri::XML::Document === lhs
+        if ::Nokogiri::XML::Document === lhs
 
-					lhs_root	=	lhs.root
-					lhs			=	lhs_root if lhs_root
-				end
+          lhs_root  = lhs.root
+          lhs     = lhs_root if lhs_root
+        end
 
-				if ::Nokogiri::XML::Document === rhs
+        if ::Nokogiri::XML::Document === rhs
 
-					rhs_root	=	rhs.root
-					rhs			=	rhs_root if rhs_root
-				end
-			end
+          rhs_root  = rhs.root
+          rhs     = rhs_root if rhs_root
+        end
+      end
 
 
-			self.xml_compare_nodes_ lhs, rhs, options
-		end
+      self.xml_compare_nodes_ lhs, rhs, options
+    end
 
-		def self.xml_compare_nodes_ lhs, rhs, options
+    def self.xml_compare_nodes_ lhs, rhs, options
 
-			$stderr.puts "#{self}#{__method__}(lhs (#{lhs.class})=#{self.one_line_ lhs}, rhs (#{rhs.class})=#{self.one_line_ rhs}, options (#{options.class})=#{options})" if $DEBUG
+      $stderr.puts "#{self}#{__method__}(lhs (#{lhs.class})=#{self.one_line_ lhs}, rhs (#{rhs.class})=#{self.one_line_ rhs}, options (#{options.class})=#{options})" if $DEBUG
 
 
-			# Compare:
-			#
-			# - name
-			# - attributes
-			# - content
-			# - children
-			# - 
+      # Compare:
+      #
+      # - name
+      # - attributes
+      # - content
+      # - children
+      # -
 
 
-			# ##########################
-			# name
+      # ##########################
+      # name
 
-			lhs_name	=	lhs.name
-			rhs_name	=	rhs.name
+      lhs_name  = lhs.name
+      rhs_name  = rhs.name
 
-			return Result.different :different_node_names, lhs_node: lhs, rhs_node: rhs if lhs_name != rhs_name
+      return Result.different :different_node_names, lhs_node: lhs, rhs_node: rhs if lhs_name != rhs_name
 
 
-			# ##########################
-			# attributes
+      # ##########################
+      # attributes
 
-			unless options[:ignore_attributes]
+      unless options[:ignore_attributes]
 
-				lhs_attributes	=	lhs.attribute_nodes
-				rhs_attributes	=	rhs.attribute_nodes
+        lhs_attributes  = lhs.attribute_nodes
+        rhs_attributes  = rhs.attribute_nodes
 
-				return Result.different :different_attribute_count, lhs_node: lhs, rhs_node: rhs if lhs_attributes.count != rhs_attributes.count
+        return Result.different :different_attribute_count, lhs_node: lhs, rhs_node: rhs if lhs_attributes.count != rhs_attributes.count
 
 
-				lhs_attr_list	=	lhs_attributes.map { |attr| [ attr.name, attr.content ] }
-				rhs_attr_list	=	rhs_attributes.map { |attr| [ attr.name, attr.content ] }
+        lhs_attr_list = lhs_attributes.map { |attr| [ attr.name, attr.content ] }
+        rhs_attr_list = rhs_attributes.map { |attr| [ attr.name, attr.content ] }
 
-				if lhs_attr_list != rhs_attr_list
+        if lhs_attr_list != rhs_attr_list
 
-					# do the sort first
+          # do the sort first
 
-					lhs_attr_list.sort! { |l, r| l[0] <=> r[0] }
-					rhs_attr_list.sort! { |l, r| l[0] <=> r[0] }
+          lhs_attr_list.sort! { |l, r| l[0] <=> r[0] }
+          rhs_attr_list.sort! { |l, r| l[0] <=> r[0] }
 
-					# Now there are four possibiliies:
-					#
-					# 1. Different attributes
-					# 2. Different attribute order
-					# 3. Same (when reordered)
+          # Now there are four possibiliies:
+          #
+          # 1. Different attributes
+          # 2. Different attribute order
+          # 3. Same (when reordered)
 
-					if lhs_attr_list == rhs_attr_list
+          if lhs_attr_list == rhs_attr_list
 
-						if options[:ignore_attribute_order]
+            if options[:ignore_attribute_order]
 
-							# 3
-						else
+              # 3
+            else
 
-							# 2
+              # 2
 
-							return Result.different :different_attribute_order, lhs_node: lhs, rhs_node: rhs
-						end
-					else
+              return Result.different :different_attribute_order, lhs_node: lhs, rhs_node: rhs
+            end
+          else
 
-						return Result.different :different_attributes, lhs_node: lhs, rhs_node: rhs
-					end
-				end
-			end
+            return Result.different :different_attributes, lhs_node: lhs, rhs_node: rhs
+          end
+        end
+      end
 
-			# ##########################
-			# content
+      # ##########################
+      # content
 
-			unless options[:ignore_content]
+      unless options[:ignore_content]
 
-				lhs_texts		=	self.get_descendants(lhs).select { |el| el.text? }.map { |el| el.content }
-				rhs_texts		=	self.get_descendants(rhs).select { |el| el.text? }.map { |el| el.content }
+        lhs_texts   = self.get_descendants(lhs).select { |el| el.text? }.map { |el| el.content }
+        rhs_texts   = self.get_descendants(rhs).select { |el| el.text? }.map { |el| el.content }
 
-				content_same	=	lhs_texts == rhs_texts
+        content_same  = lhs_texts == rhs_texts
 
-				unless content_same
+        unless content_same
 
-					if options[:normalise_whitespace]
+          if options[:normalise_whitespace]
 
-						lhs_texts		=	lhs_texts.reject { |s| s.strip.empty? }
-						rhs_texts		=	rhs_texts.reject { |s| s.strip.empty? }
+            lhs_texts   = lhs_texts.reject { |s| s.strip.empty? }
+            rhs_texts   = rhs_texts.reject { |s| s.strip.empty? }
 
-						content_same	=	lhs_texts == rhs_texts
-					end
-				end
+            content_same  = lhs_texts == rhs_texts
+          end
+        end
 
-				unless content_same
+        unless content_same
 
-					if options[:ignore_content_case]
+          if options[:ignore_content_case]
 
-						lhs_texts		=	lhs_texts.reject { |s| s.downcase }
-						rhs_texts		=	rhs_texts.reject { |s| s.downcase }
+            lhs_texts   = lhs_texts.reject { |s| s.downcase }
+            rhs_texts   = rhs_texts.reject { |s| s.downcase }
 
-						content_same	=	lhs_texts == rhs_texts
-					end
-				end
+            content_same  = lhs_texts == rhs_texts
+          end
+        end
 
-				unless content_same
+        unless content_same
 
-					if options[:ignore_child_node_order]
+          if options[:ignore_child_node_order]
 
-						lhs_texts		=	lhs_texts.sort
-						rhs_texts		=	rhs_texts.sort
+            lhs_texts   = lhs_texts.sort
+            rhs_texts   = rhs_texts.sort
 
-						content_same	=	lhs_texts == rhs_texts
-					end
-				end
+            content_same  = lhs_texts == rhs_texts
+          end
+        end
 
-				return Result.different :different_node_contents, lhs_node: lhs, rhs_node: rhs unless content_same
-			end
+        return Result.different :different_node_contents, lhs_node: lhs, rhs_node: rhs unless content_same
+      end
 
 
-			# ##########################
-			# children (preparation)
+      # ##########################
+      # children (preparation)
 
-			lhs_children		=	lhs.children.to_a
-			rhs_children		=	rhs.children.to_a
+      lhs_children    = lhs.children.to_a
+      rhs_children    = rhs.children.to_a
 
-			lhs_children.reject! { |child| child.text? && child.content.strip.empty? }
-			rhs_children.reject! { |child| child.text? && child.content.strip.empty? }
+      lhs_children.reject! { |child| child.text? && child.content.strip.empty? }
+      rhs_children.reject! { |child| child.text? && child.content.strip.empty? }
 
 
-			# ##########################
-			# children - count
+      # ##########################
+      # children - count
 
-			lhs_children_count	=	lhs_children.count
-			rhs_children_count	=	rhs_children.count
+      lhs_children_count  = lhs_children.count
+      rhs_children_count  = rhs_children.count
 
-			return Result.different :different_child_node_count, lhs_node: lhs, rhs_node: rhs if lhs_children_count != rhs_children_count
+      return Result.different :different_child_node_count, lhs_node: lhs, rhs_node: rhs if lhs_children_count != rhs_children_count
 
 
-			# ##########################
-			# children - names
+      # ##########################
+      # children - names
 
-			lhs_children_names	=	lhs_children.map { |ch| ch.name }
-			rhs_children_names	=	rhs_children.map { |ch| ch.name }
+      lhs_children_names  = lhs_children.map { |ch| ch.name }
+      rhs_children_names  = rhs_children.map { |ch| ch.name }
 
-			if lhs_children_names != rhs_children_names
+      if lhs_children_names != rhs_children_names
 
-				# At this point, the lists of names of child elements are
-				# different. This may be because there are different
-				# elements or because they are in a different order. Either
-				# way, in order to provide detailed reasons for
-				# inequivalency, we must do an order-independent comparison
+        # At this point, the lists of names of child elements are
+        # different. This may be because there are different
+        # elements or because they are in a different order. Either
+        # way, in order to provide detailed reasons for
+        # inequivalency, we must do an order-independent comparison
 
-				children_sorted_lhs	=	lhs_children.sort { |x, y| x.name <=> y.name }
-				children_sorted_rhs	=	rhs_children.sort { |x, y| x.name <=> y.name }
+        children_sorted_lhs = lhs_children.sort { |x, y| x.name <=> y.name }
+        children_sorted_rhs = rhs_children.sort { |x, y| x.name <=> y.name }
 
-				ch_names_sorted_lhs	=	children_sorted_lhs.map { |ch| ch.name }
-				ch_names_sorted_rhs	=	children_sorted_rhs.map { |ch| ch.name }
+        ch_names_sorted_lhs = children_sorted_lhs.map { |ch| ch.name }
+        ch_names_sorted_rhs = children_sorted_rhs.map { |ch| ch.name }
 
-				ignore_order		=	options[:ignore_child_node_order]
+        ignore_order    = options[:ignore_child_node_order]
 
-				if ignore_order
+        if ignore_order
 
-					return Result.different :different_child_nodes, lhs_node: lhs, rhs_node: rhs if ch_names_sorted_lhs != ch_names_sorted_rhs
+          return Result.different :different_child_nodes, lhs_node: lhs, rhs_node: rhs if ch_names_sorted_lhs != ch_names_sorted_rhs
 
-					# Since they are the same (when reordered), we need to
-					# adopt the ordered sequences so that the comparison of
-					# the children are meaningful
+          # Since they are the same (when reordered), we need to
+          # adopt the ordered sequences so that the comparison of
+          # the children are meaningful
 
-					lhs_children	=	children_sorted_lhs
-					rhs_children	=	children_sorted_rhs
-				else
+          lhs_children  = children_sorted_lhs
+          rhs_children  = children_sorted_rhs
+        else
 
-					# failed, so need to determine whether it's due to
-					# different nodes or different order
+          # failed, so need to determine whether it's due to
+          # different nodes or different order
 
-					if ch_names_sorted_lhs == ch_names_sorted_rhs
+          if ch_names_sorted_lhs == ch_names_sorted_rhs
 
-						return Result.different :different_child_node_order, lhs_node: lhs, rhs_node: rhs
-					else
+            return Result.different :different_child_node_order, lhs_node: lhs, rhs_node: rhs
+          else
 
-						return Result.different :different_child_nodes, lhs_node: lhs, rhs_node: rhs
-					end
-				end
-			end
+            return Result.different :different_child_nodes, lhs_node: lhs, rhs_node: rhs
+          end
+        end
+      end
 
-			(0 ... lhs_children.count).each do |index|
+      (0 ... lhs_children.count).each do |index|
 
-				ch_lhs	=	lhs_children[index]
-				ch_rhs	=	rhs_children[index]
+        ch_lhs  = lhs_children[index]
+        ch_rhs  = rhs_children[index]
 
-				r = self.xml_compare_nodes_ ch_lhs, ch_rhs, options
+        r = self.xml_compare_nodes_ ch_lhs, ch_rhs, options
 
-				return r unless r.status
-			end
+        return r unless r.status
+      end
 
-			return Result.same
-		end
-	end
+      return Result.same
+    end
+  end
 
-	def self.xml_compare lhs, rhs, **options
+  def self.xml_compare lhs, rhs, **options
 
-		$stderr.puts "#{self}#{__method__}(lhs (#{lhs.class})=#{Internal_Compare_.one_line_ lhs}, rhs (#{rhs.class})=#{Internal_Compare_.one_line_ rhs}, options (#{options.class})=#{options})" if $DEBUG
+    $stderr.puts "#{self}#{__method__}(lhs (#{lhs.class})=#{Internal_Compare_.one_line_ lhs}, rhs (#{rhs.class})=#{Internal_Compare_.one_line_ rhs}, options (#{options.class})=#{options})" if $DEBUG
 
-		Internal_Compare_.xml_compare_ lhs, rhs, options
-	end
+    Internal_Compare_.xml_compare_ lhs, rhs, options
+  end
 
-	def xml_compare lhs, rhs, **options
+  def xml_compare lhs, rhs, **options
 
-		$stderr.puts "#{self}#{__method__}(lhs (#{lhs.class})=#{Internal_Compare_.one_line_ lhs}, rhs (#{rhs.class})=#{Internal_Compare_.one_line_ rhs}, options (#{options.class})=#{options})" if $DEBUG
+    $stderr.puts "#{self}#{__method__}(lhs (#{lhs.class})=#{Internal_Compare_.one_line_ lhs}, rhs (#{rhs.class})=#{Internal_Compare_.one_line_ rhs}, options (#{options.class})=#{options})" if $DEBUG
 
-		Internal_Compare_.xml_compare_ lhs, rhs, options
-	end
+    Internal_Compare_.xml_compare_ lhs, rhs, options
+  end
 
 end # module Compare