loc_mods 0.2.2 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66939abfdba314e93de07afbe306be58394fb4466de3d9203318e400b2a0f017
-  data.tar.gz: 5e9ffbdd0c405ac026e77138c5287c34d21cf93c84a7d98e94e5d6e987b015a0
+  metadata.gz: c4e669e85342e73695662fb8685879a283bd8b166c44a180de849a1a868d5db3
+  data.tar.gz: 93bd3bce5771da37094b7b2f4431c733fd5024be93fbde51900ea3e76a95af1b
 SHA512:
-  metadata.gz: 9e0cec87a093a33c3785376aaba4cbe7b05b3ee8e916c1fa238faa659668e01468b56ec08afc9478123a01adb0076e497e1f09a8dcdc4f330965aa6f82fddcc2
-  data.tar.gz: f5ed1dc6d38e5c6afec2edd7872963433e1cc699502686acd6045198b4b37fec1d27720f7777c2f08a1a5f2234c15d98ccf2beefe2babfca3cf897007b7ee6c5
+  metadata.gz: 3597a8790c984fb0e4666d334d44727952e46bed0822b8c999dc4bfa3a32669ebfdf6150cc6ab4c37762b7483dfb376f716b9437e27634d594852dc10732de65
+  data.tar.gz: 3d44d27786cea8ddd7024065b9ea8f8c5a0b08eebf6aa93d35dc24c9575c67f21a9a3ed69887b667332fa9e20af84dd003739b6853ec41b92960bd587132a8fc

data/README.adoc

@@ -28,15 +28,44 @@ LocMods::Collection.from_xml(File.read("reference/allrecords-MODS.xml"))
 
 === Command line interface
 
-LocMods provides a command-line interface (CLI) for various operations. The main
-executable is `loc-mods`.
+LocMods provides a command-line interface (CLI) for various operations.
+
+The main executable is `loc-mods`.
+
+[source,shell]
+----
+Commands:
+  loc-mods detect-duplicates PATH...  # Detect duplicate records in MODS XML files or directories
+  loc-mods help [COMMAND]             # Describe available commands or one specific command
+----
+
+
+
 
 ==== Detect duplicates
 
 The `detect-duplicates` command allows you to find duplicate MODS records based
 on using a "primary ID" that is their DOI (Digital Object Identifier).
 
+NOTE: The library assumes that every record has a DOI. If that is not the case,
+another way to setting the primary key needs to be defined.
+
+Usage:
+
+[source,shell]
+----
 Usage:
+  loc-mods detect-duplicates PATH...
+
+Options:
+  [--show-unchanged], [--no-show-unchanged] # Show unchanged attributes in the diff output
+                                            # Default: false
+  [--highlight-diff], [--no-highlight-diff] # Highlight only the differences
+                                            # Default: false
+  [--color=COLOR]                           # Use colors in the diff output (auto, on, off)
+                                            # Default: auto
+                                            # Possible values: auto, on, off
+----
 
 [source,shell]
 ----
@@ -45,15 +74,28 @@ $ loc-mods detect-duplicates [OPTIONS] <file_or_directory_path>
 
 Options:
 
-* `-r, --recursive`: Search for MODS files recursively in subdirectories.
-* `-v, --verbose`: Display more detailed output.
-* `-o, --output FILE`: Write the results to a file instead of stdout.
+`--show-unchanged`::
+(default: `false`)
+Show attributes of both objects even when they were not changed.
+
+`--highlight-diff`::
+(default: `false`)
+Highlight values only when they differ between two records.
+
+`--color=COLOR`::
+(default: `auto`) Use colors in the diff output. Values:
+
+`auto`::: the CLI will detect whether the terminal supports colors and display
+with colors if it does.
+`on`::: the CLI will always display with colors.
+`off`::: the CLI will never display with colors.
+
 
 Example:
 
 [source,shell]
 ----
-$ loc-mods detect-duplicates -r -v /path/to/mods/files
+$ loc-mods detect-duplicates  /path/to/mods/files
 ----
 
 This command will:

data/exe/loc-mods

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require "bundler/setup"
 require_relative "../lib/loc_mods/cli"

data/lib/loc_mods/base_mapper.rb

@@ -1,9 +1,26 @@
+# frozen_string_literal: true
+
 # lib/loc_mods/base_mapper.rb
 require "shale"
 require_relative "comparable_mapper"
 
 module LocMods
+  # Base class for all object definitions
   class BaseMapper < Shale::Mapper
     include ComparableMapper
   end
+
+  # Nil class substitute for comparison
+  class ComparableNil < BaseMapper
+  end
+
+  # Comparison of two values for ComparableMapper
+  class Comparison
+    attr_accessor :original, :updated
+
+    def initialize(original:, updated:)
+      @original = original
+      @updated = updated
+    end
+  end
 end

data/lib/loc_mods/cli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # lib/loc_mods/cli.rb
 require "thor"
 require "loc_mods"
@@ -5,6 +7,10 @@ require "loc_mods"
 module LocMods
   class Cli < Thor
     desc "detect-duplicates PATH...", "Detect duplicate records in MODS XML files or directories"
+    method_option :show_unchanged, type: :boolean, default: false, desc: "Show unchanged attributes in the diff output"
+    method_option :highlight_diff, type: :boolean, default: false, desc: "Highlight only the differences"
+    method_option :color, type: :string, enum: %w[auto on off], default: "auto",
+                          desc: "Use colors in the diff output (auto, on, off)"
 
     def detect_duplicates(*paths)
       all_records = []
@@ -23,33 +29,35 @@ module LocMods
       records_by_url = {}
       all_records.each do |record|
         urls = record[:record].location.flat_map { |loc| loc.url.map(&:content) }.compact
-        if urls.any?
-          urls.each do |url|
-            records_by_url[url] ||= []
-            records_by_url[url] << record
-          end
-        else
+        unless urls.any?
           puts "Warning: Record without URL found in file: #{record[:file]}"
+          next
+        end
+
+        urls.each do |url|
+          records_by_url[url] ||= []
+          records_by_url[url] << record
         end
       end
 
       duplicate_count = 0
       records_by_url.each do |url, records|
-        if records.size > 1
-          duplicate_count += 1
-          puts "Duplicate set ##{duplicate_count} found for URL: #{url}"
-          records.combination(2).each_with_index do |(record1, record2), index|
-            puts "  Comparison #{index + 1}:"
-            puts "  File 1: #{record1[:file]}"
-            puts "  File 2: #{record2[:file]}"
-            differences = record1[:record].compare(record2[:record])
-            if differences
-              puts "  ----"
-              print_differences(differences)
-              puts "  ----"
-            end
-            puts "\n"
-          end
+        next unless records.size > 1
+
+        duplicate_count += 1
+        puts "Duplicate set ##{duplicate_count} found for URL: #{url}"
+        records.combination(2).each_with_index do |(record1, record2), index|
+          puts "  Comparison #{index + 1}:"
+          puts "  File 1: #{record1[:file]}"
+          puts "  File 2: #{record2[:file]}"
+          print_differences(
+            record1[:record],
+            record2[:record],
+            options[:show_unchanged],
+            options[:highlight_diff],
+            color_enabled?
+          )
+          puts "\n"
         end
       end
     end
@@ -64,38 +72,51 @@ module LocMods
       end
     end
 
-    def print_differences(differences, prefix = "", path = [])
-      differences.each do |key, value|
-        current_path = path + [key]
-        if value.is_a?(Hash) && value.keys.all? { |k| k.is_a?(Integer) }
-          value.each do |index, sub_value|
-            print_differences(sub_value, prefix, current_path + [index])
-          end
-        elsif value.is_a?(Hash) && (value[:self] || value[:other])
-          puts "  #{format_path(current_path)}:"
-          puts "  #{prefix}  Record 1: #{format_value(value[:self])}"
-          puts "  #{prefix}  Record 2: #{format_value(value[:other])}"
-          puts
-        elsif value.is_a?(Hash)
-          print_differences(value, prefix, current_path)
-        end
-      end
+    def print_differences(record1, record2, show_unchanged, highlight_diff, use_colors)
+      diff_score, diff_tree = LocMods::BaseMapper.diff_with_score(
+        record1,
+        record2,
+        show_unchanged: show_unchanged,
+        highlight_diff: highlight_diff,
+        use_colors: use_colors,
+        indent: "  ",
+      )
+      similarity_percentage = (1 - diff_score) * 100
+
+      puts "  Differences:"
+      puts diff_tree
+      puts "  Similarity score: #{similarity_percentage.round(2)}%"
     end
 
-    def format_path(path)
-      path.map.with_index do |part, index|
-        if index == 0
-          part.to_s
-        elsif part.is_a?(Integer)
-          "[#{part}]"
-        else
-          ".#{part}"
-        end
-      end.join
+    def color_enabled?
+      case options[:color]
+      when "on"
+        true
+      when "off"
+        false
+      else
+        supports_color?
+      end
     end
 
-    def format_value(value)
-      value.nil? ? "(nil)" : "\"#{value}\""
+    def supports_color?
+      return false unless $stdout.tty?
+
+      if RbConfig::CONFIG["host_os"] =~ /mswin|mingw|cygwin/
+        return true if ENV["ANSICON"]
+        return true if ENV["ConEmuANSI"] == "ON"
+        return true if ENV["TERM"] == "xterm"
+      end
+
+      return true if ENV["COLORTERM"]
+
+      term = ENV["TERM"]
+      return false if term.nil? || term.empty?
+
+      color_terms = %w[ansi color console cygwin gnome konsole kterm
+                       linux msys putty rxvt screen tmux vt100 xterm]
+
+      color_terms.any? { |ct| term.include?(ct) }
     end
   end
 end

data/lib/loc_mods/comparable_mapper.rb

@@ -1,96 +1,501 @@
-# lib/loc_mods/comparable_mapper.rb
+# frozen_string_literal: true
 
 module LocMods
+  # ComparableMapper module provides functionality to compare and diff two objects
+  # of the same class, based on their attribute values.
   module ComparableMapper
-    # def self.included(base)
-    #   base.extend(ClassMethods)
-    # end
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
 
-    # module ClassMethods
-    #   def attribute_mapping
-    #     @attribute_mapping ||= attributes.to_h do |name, attribute|
-    #       [name, attribute.type]
-    #     end
-    #   end
-    # end
+    # Checks if two objects are equal based on their attributes
+    # @param other [Object] The object to compare with
+    # @return [Boolean] True if objects are equal, false otherwise
+    def eql?(other)
+      other.class == self.class &&
+        self.class.attributes.all? { |attr, _| send(attr) == other.send(attr) }
+    end
 
-    def compare(other)
-      return {} unless other.is_a?(self.class)
+    alias == eql?
 
-      differences = {}
+    # Generates a hash value for the object
+    # @return [Integer] The hash value
+    def hash
+      ([self.class] + self.class.attributes.map { |attr, _| send(attr).hash }).hash
+    end
 
-      # puts "Debugging: Attributes for #{self.class.name}"
-      # pp self.class.attributes.keys
+    # Class methods added to the class that includes ComparableMapper
+    module ClassMethods
+      # Generates a diff tree between two objects of the same class
+      # @param obj1 [Object] The first object to compare
+      # @param obj2 [Object] The second object to compare
+      # @param options [Hash] Options for diff generation
+      # @return [String] A string representation of the diff tree
+      def diff_tree
+        if @obj1.nil? && @obj2.nil?
+          @root_tree = Tree.new("Both objects are nil")
+        elsif @obj1.nil?
+          @root_tree = Tree.new("First object is nil")
+          format_single_value(@obj2, @root_tree, @obj2.class.to_s)
+        elsif @obj2.nil?
+          @root_tree = Tree.new("Second object is nil")
+          format_single_value(@obj1, @root_tree, @obj1.class.to_s)
+        else
+          traverse_diff do |name, type, value1, value2, is_last|
+            format_attribute_diff(name, type, value1, value2, is_last)
+          end
+        end
 
-      self.class.attributes.each_key do |attr|
-        self_value = self.send(attr)
-        other_value = other.send(attr)
+        @root_tree.to_s
+      end
 
-        # puts "Debugging: Comparing attribute '#{attr}'"
-        # puts "  Self value: #{self_value.inspect}"
-        # puts "  Other value: #{other_value.inspect}"
+      # Generates a diff tree and calculates a diff score between two objects of the same class
+      # @param obj1 [Object] The first object to compare
+      # @param obj2 [Object] The second object to compare
+      # @param options [Hash] Options for diff generation
+      # @return [Array<Float, String>] An array containing the normalized diff score and the diff tree
+      def diff_with_score(obj1, obj2, **options)
+        context = DiffContext.new(obj1, obj2, **options)
+        indent = options[:indent] || ""
+        [context.calculate_diff_score, context.diff_tree(indent)]
+      end
+    end
+
+    class Tree
+      attr_accessor :content, :children, :color
+
+      def initialize(content, color: nil)
+        @content = content
+        @children = []
+        @color = color
+      end
+
+      def add_child(child)
+        @children << child
+      end
 
-        compared = compare_values(self_value, other_value)
-        if compared
-          # puts "DETECTED DIFFERENCE! #{compared.inspect}"
-          differences[attr] = compared
+      def to_s(indent = "", is_last = true)
+        prefix = is_last ? "└── " : "├── "
+        result = "#{indent}#{colorize(prefix + @content, @color)}\n"
+        @children.each_with_index do |child, index|
+          is_last_child = index == @children.size - 1
+          child_indent = indent + (is_last ? "    " : "#{colorize("│", @color)}   ")
+          result += child.to_s(child_indent, is_last_child)
         end
+        result
       end
 
-      # unless differences.empty?
-      #   puts "DIFFERENCES ARE"
-      #   pp differences
-      # end
+      private
 
-      differences.empty? ? nil : differences
+      def colorize(text, color)
+        return text unless color
+
+        color_codes = { red: 31, green: 32, blue: 34 }
+        "\e[#{color_codes[color]}m#{text}\e[0m"
+      end
     end
 
-    private
+    # DiffContext handles the comparison between two objects
+    class DiffContext
+      attr_reader :obj1, :obj2, :show_unchanged, :highlight_diff, :use_colors
+      attr_accessor :level, :tree_lines, :root_tree
+
+      # Initializes a new DiffContext
+      # @param obj1 [Object] The first object to compare
+      # @param obj2 [Object] The second object to compare
+      # @param options [Hash] Options for diff generation
+      def initialize(obj1, obj2, **options)
+        @obj1 = obj1
+        @obj2 = obj2
+        @show_unchanged = options.fetch(:show_unchanged, false)
+        @highlight_diff = options.fetch(:highlight_diff, false)
+        @use_colors = options.fetch(:use_colors, true)
+        @level = 0
+        @tree_lines = []
+        @root_tree = Tree.new(obj1.class.to_s)
+      end
 
-    def compare_values(self_value, other_value)
-      # puts "compare_values (self_value: #{self_value}, other_value: #{other_value})"
-      case self_value
-      when Array
-        # puts "compare_values case 1"
-        compare_arrays(self_value, other_value)
-      when Shale::Mapper
-        # puts "compare_values case 2"
-        self_value.compare(other_value)
-      else
-        if self_value != other_value
-          # puts "compare_values case 3"
-          { self: self_value, other: other_value }
+      # Generates a diff tree between the two objects
+      # @return [String] A string representation of the diff tree
+      def diff_tree(indent = "")
+        traverse_diff do |name, type, value1, value2, is_last|
+          format_attribute_diff(name, type, value1, value2, is_last)
         end
+        @root_tree.to_s(indent)
       end
-    end
 
-    def compare_arrays(self_array, other_array)
-      differences = {}
-      max_length = [self_array.size, other_array.size].max
+      # Calculates the normalized diff score
+      # @return [Float] The normalized diff score
+      def calculate_diff_score
+        total_score = 0
+        total_attributes = 0
+        traverse_diff do |_, _, value1, value2, _|
+          total_score += calculate_attribute_score(value1, value2)
+          total_attributes += 1
+        end
+        total_attributes.positive? ? total_score / total_attributes : 0
+      end
+
+      private
+
+      # Applies color to text if colors are enabled
+      # @param text [String] The text to color
+      # @param color [Symbol] The color to apply
+      # @return [String] The colored text
+      def colorize(text, color)
+        return text unless @use_colors
+
+        color_codes = { red: 31, green: 32, blue: 34 }
+        "\e[#{color_codes[color]}m#{text}\e[0m"
+      end
+
+      # Traverses the attributes of the objects and yields each attribute's details
+      # @yield [String, Symbol, Object, Object, Boolean] Yields the name, type, value1, value2, and is_last for each attribute
+      def traverse_diff
+        return yield nil, nil, obj1, obj2, true if obj1.class != obj2.class
+
+        obj1.class.attributes.each_with_index do |(name, type), index|
+          yield name, type, obj1.send(name), obj2.send(name), index == obj1.class.attributes.length - 1
+        end
+      end
+
+      # Generates the prefix for tree lines
+      # @return [String] Prefix for tree lines
+      def tree_prefix
+        @tree_lines.map { |enabled| enabled ? "│   " : "    " }.join
+      end
+
+      # Formats a line in the tree structure
+      # @param is_last [Boolean] Whether this is the last item in the current level
+      # @param content [String] The content to be displayed in the line
+      # @return [String] Formatted tree line
+      def tree_line(is_last, content)
+        "#{tree_prefix}#{is_last ? "└── " : "├── "}#{content}\n"
+      end
+
+      # Calculates the diff score for a single attribute
+      # @param value1 [Object] The value of the attribute in the first object
+      # @param value2 [Object] The value of the attribute in the second object
+      # @return [Float] The diff score for the attribute
+      def calculate_attribute_score(value1, value2)
+        if value1 == value2
+          0
+        elsif value1.is_a?(Array) && value2.is_a?(Array)
+          calculate_array_score(value1, value2)
+        else
+          value1.instance_of?(value2.class) ? 0.5 : 1
+        end
+      end
+
+      # Calculates the diff score for array attributes
+      # @param arr1 [Array] The array from the first object
+      # @param arr2 [Array] The array from the second object
+      # @return [Float] The diff score for the arrays
+      def calculate_array_score(arr1, arr2)
+        max_length = [arr1.length, arr2.length].max
+        return 0.0 if max_length.zero?
+
+        total_score = max_length.times.sum do |i|
+          if i < arr1.length && i < arr2.length
+            if arr1[i] == arr2[i]
+              0.0
+            elsif arr1[i].is_a?(ComparableMapper) && arr2[i].is_a?(ComparableMapper)
+              DiffContext.new(arr1[i], arr2[i], show_unchanged: @show_unchanged).calculate_diff_score
+            else
+              calculate_attribute_score(arr1[i], arr2[i])
+            end
+          else
+            1.0
+          end
+        end
+
+        total_score / max_length
+      end
+
+      # Formats a value for display in the diff output
+      # @param value [Object] The value to format
+      # @return [String] Formatted value
+      def format_value(value)
+        case value
+        when nil
+          "(nil)"
+        when String
+          "(String) \"#{value}\""
+        when Array
+          if value.empty?
+            "(Array) 0 items"
+          else
+            items = value.map { |item| format_value(item) }.join(", ")
+            "(Array) [#{items}]"
+          end
+        when Hash
+          "(Hash) #{value.keys.length} keys"
+        when ComparableMapper
+          "(#{value.class})"
+        else
+          "(#{value.class}) #{value}"
+        end
+      end
+
+      # Formats the diff output for a single attribute
+      # @param name [String] The name of the attribute
+      # @param type [Symbol] The type of the attribute
+      # @param value1 [Object] The value of the attribute in the first object
+      # @param value2 [Object] The value of the attribute in the second object
+      # @param is_last [Boolean] Whether this is the last attribute in the list
+      # @return [String] Formatted diff output for the attribute
+      def format_attribute_diff(name, type, value1, value2, _is_last)
+        return if value1 == value2 && !@show_unchanged
+
+        node = Tree.new("#{name} (#{obj1.class.attributes[name].collection? ? "collection" : type_name(type)}):")
+        @root_tree.add_child(node)
+
+        if obj1.class.attributes[name].collection?
+          format_collection(value1, value2, node)
+        elsif value1 == value2
+          format_single_value(value1, node, "")
+        else
+          format_value_tree(value1, value2, node, "", type_name(type))
+        end
+      end
+
+      # Formats a collection (array) for diff output
+      # @param array1 [Array] The first array to compare
+      # @param array2 [Array] The second array to compare
+      # @return [String] Formatted diff output for the collection
+      def format_collection(array1, array2, parent_node)
+        array2 = [] if array2.nil?
+        max_length = [array1.length, array2.length].max
+
+        if max_length.zero?
+          parent_node.content += " (nil)"
+          return
+        end
+
+        max_length.times do |index|
+          item1 = array1[index]
+          item2 = array2[index]
+
+          next if item1 == item2 && !@show_unchanged
 
-      max_length.times do |index|
-        self_item = self_array[index]
-        other_item = other_array[index]
+          prefix = item2.nil? ? "- " : (item1.nil? ? "+ " : "")
+          color = item2.nil? ? :red : (item1.nil? ? :green : nil)
+          type = item1&.class || item2&.class
+
+          node = Tree.new("#{prefix}[#{index + 1}] (#{type_name(type)})", color: color)
+          parent_node.add_child(node)
+
+          if item1.nil?
+            format_diff_item(item2, :green, node)
+          elsif item2.nil?
+            format_diff_item(item1, :red, node)
+          else
+            format_value_tree(item1, item2, node, "")
+          end
+        end
+      end
+
+      # Formats a removed item in the diff output
+      # @param item [Object] The removed item
+      # @param is_last [Boolean] Whether this is the last item in the current level
+      # @param index [Integer] The index of the removed item
+      # @return [String] Formatted output for the removed item
+      def format_removed_item(item, _parent_node)
+        format_diff_item(item, :red)
+      end
 
-        if index >= self_array.size
-          compared = compare_values(other_item, nil)
-          differences[index] = { self: compared[:other], other: compared[:self] }
-        elsif index >= other_array.size
-          differences[index] = compare_values(self_item, nil)
+      # Formats an added item in the diff output
+      # @param item [Object] The added item
+      # @param is_last [Boolean] Whether this is the last item in the current level
+      # @param index [Integer] The index of the added item
+      # @return [String] Formatted output for the added item
+      def format_added_item(item, _parent_node)
+        format_diff_item(item, :green)
+      end
+
+      # Formats a diff item (added or removed)
+      # @param item [Object] The item to format
+      # @param is_last [Boolean] Whether this is the last item in the current level
+      # @param index [Integer] The index of the item
+      # @param color [Symbol] The color to use for the item
+      # @param prefix [String] The prefix to use for the item (+ or -)
+      # @return [String] Formatted output for the diff item
+      def format_diff_item(item, color, parent_node)
+        if item.is_a?(ComparableMapper)
+          return format_comparable_mapper(item, parent_node, color)
+        end
+
+        parent_node.add_child(Tree.new(format_value(item), color: color))
+      end
+
+      # Formats the content of an object for diff output
+      # @param obj [Object] The object to format
+      # @return [String] Formatted content of the object
+      def format_object_content(obj)
+        return format_value(obj) unless obj.is_a?(ComparableMapper)
+
+        obj.class.attributes.map do |attr, _|
+          "#{attr}: #{format_value(obj.send(attr))}"
+        end.join("\n")
+      end
+
+      # Formats and colors the content for diff output
+      # @param content [String] The content to format and color
+      # @param color [Symbol] The color to apply
+      # @param is_last [Boolean] Whether this is the last item in the current level
+      # @return [String] Formatted and colored content
+      def format_colored_content(content, color, is_last)
+        lines = content.split("\n")
+        lines.map.with_index do |line, index|
+          if index.zero?
+            "" # Skip the first line as it's already been output
+          else
+            prefix = index == lines.length - 1 && is_last ? "└── " : "├── "
+            tree_line(index == lines.length - 1 && is_last, colorize("#{prefix}#{line}", color))
+          end
+        end.join
+      end
+
+      # Gets the name of a type
+      # @param type [Class, Object] The type to get the name for
+      # @return [String] The name of the type
+      def type_name(type)
+        if type.is_a?(Class)
+          type.name
+        elsif type.respond_to?(:type)
+          type.type.name
         else
-          compared = compare_values(self_item, other_item)
-          differences[index] = compared if compared
+          type.class.name
         end
       end
 
-      if self_array.size != other_array.size
-        differences[:array_size_difference] = {
-          self: self_array.size,
-          other: other_array.size,
-        }
+      # Formats the attributes of an object for diff output
+      # @param obj1 [Object] The first object
+      # @param obj2 [Object] The second object
+      # @return [String] Formatted attributes of the objects
+      def format_object_attributes(obj1, obj2, parent_node)
+        obj1.class.attributes.each_key do |attr|
+          value1 = obj1.send(attr)
+          value2 = obj2&.send(attr)
+
+          attr_type = obj1.class.attributes[attr].collection? ? "collection" : type_name(obj1.class.attributes[attr])
+
+          if value1 == value2
+            format_single_value(value1, parent_node, "#{attr} (#{attr_type})") if @show_unchanged
+          else
+            format_value_tree(value1, value2, parent_node, attr, attr_type)
+          end
+        end
+      end
+
+      # Formats the value tree for diff output
+      # @param value1 [Object] The first value
+      # @param value2 [Object] The second value
+      # @param is_last [Boolean] Whether this is the last item in the current level
+      # @param label [String] The label for the value
+      # @param type_info [String, nil] Additional type information
+      # @return [String] Formatted value tree
+      def format_value_tree(value1, value2, parent_node, label, type_info = nil)
+        return if value1 == value2 && !@show_unchanged
+
+        if value1 == value2
+          if @show_unchanged
+            return format_single_value(
+                     value1,
+                     parent_node,
+                     "#{label}#{type_info ? " (#{type_info})" : ""}"
+                   )
+          end
+
+          return if @highlight_diff
+        end
+
+        case value1
+        when Array
+          format_collection(value1, value2, parent_node)
+        when Hash
+          format_hash_tree(value1, value2, parent_node)
+        when ComparableMapper
+          format_object_attributes(value1, value2, parent_node)
+        else
+          node = Tree.new("#{label}#{type_info ? " (#{type_info})" : ""}:")
+          parent_node.add_child(node)
+          node.add_child(Tree.new("- #{format_value(value1)}", color: :red))
+          node.add_child(Tree.new("+ #{format_value(value2)}", color: :green))
+        end
+      end
+
+      # Formats a single value for diff output
+      # @param value [Object] The value to format
+      # @param is_last [Boolean] Whether this is the last item in the current level
+      # @param label [String] The label for the value
+      # @return [String] Formatted single value
+      def format_single_value(value, parent_node, label, color = nil)
+        node = Tree.new("#{label}#{label.empty? ? "" : ":"}", color: color)
+        parent_node.add_child(node)
+
+        case value
+        when ComparableMapper
+          format_comparable_mapper(value, node, color)
+        when Array
+          if value.empty?
+            node.add_child(Tree.new("(nil)", color: color))
+          else
+            format_collection(value, value, node)
+          end
+        else
+          node.content += " #{format_value(value)}"
+        end
+      end
+
+      # Formats a ComparableMapper object for diff output
+      # @param obj [ComparableMapper] The object to format
+      # @return [String] Formatted ComparableMapper object
+      def format_comparable_mapper(obj, parent_node, color = nil)
+        obj.class.attributes.each do |attr_name, attr_type|
+          attr_value = obj.send(attr_name)
+          attr_node = Tree.new("#{attr_name} (#{type_name(attr_type)}):", color: color)
+          parent_node.add_child(attr_node)
+          if attr_value.is_a?(ComparableMapper)
+            format_comparable_mapper(attr_value, attr_node, color)
+          else
+            value_node = Tree.new(format_value(attr_value), color: color)
+            attr_node.add_child(value_node)
+          end
+        end
       end
 
-      differences.empty? ? nil : differences
+      # Formats a hash tree for diff output
+      # @param hash1 [Hash] The first hash to compare
+      # @param hash2 [Hash] The second hash to compare
+      # @return [String] Formatted hash tree
+      def format_hash_tree(hash1, hash2, parent_node)
+        keys = (hash1.keys + hash2.keys).uniq
+        keys.each do |key|
+          value1 = hash1[key]
+          value2 = hash2[key]
+
+          if value1 == value2
+            format_single_value(value1, parent_node, key) if @show_unchanged
+          else
+            format_value_tree(value1, value2, parent_node, key)
+          end
+        end
+      end
+    end
+  end
+
+  # Generates a tree representation of the object
+  # @return [String] A string representation of the object's attribute tree
+  def to_tree
+    output = "#{self.class}\n"
+    self.class.attributes.each_with_index do |(name, type), index|
+      value = send(name)
+      is_last = index == self.class.attributes.length - 1
+      context = DiffContext.new(nil, nil, show_unchanged: false)
+      formatted = context.format_value(value)
+      output << context.tree_line(is_last, "#{name} (#{type}): #{formatted}")
     end
+    output
   end
 end

data/lib/loc_mods/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LocMods
-  VERSION = "0.2.2"
+  VERSION = "0.2.4"
 end

data/references/allrecords-MODS.xml

@@ -1863916,4 +1863916,4 @@
          </languageOfCataloging>
       </recordInfo>
    </mods>
-</modsCollection>
+</modsCollection>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: loc_mods
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.4
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-07-13 00:00:00.000000000 Z
+date: 2024-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri