loc_mods 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66939abfdba314e93de07afbe306be58394fb4466de3d9203318e400b2a0f017
-  data.tar.gz: 5e9ffbdd0c405ac026e77138c5287c34d21cf93c84a7d98e94e5d6e987b015a0
+  metadata.gz: 2b206d76220e77a18fd6609c3f7646eaf8fb836ac2d69a7d6da019db5820f24d
+  data.tar.gz: ffd23bb7508ad1fef1e0b165eb07620fc0a2420b6c436ac34cec8208affb6463
 SHA512:
-  metadata.gz: 9e0cec87a093a33c3785376aaba4cbe7b05b3ee8e916c1fa238faa659668e01468b56ec08afc9478123a01adb0076e497e1f09a8dcdc4f330965aa6f82fddcc2
-  data.tar.gz: f5ed1dc6d38e5c6afec2edd7872963433e1cc699502686acd6045198b4b37fec1d27720f7777c2f08a1a5f2234c15d98ccf2beefe2babfca3cf897007b7ee6c5
+  metadata.gz: 9f56bbb4bfdab2dd2820ef67d94461ac5caa47d62937762a5cbeacbea8e70497c75968d92b3ce23f5d7e79f6a737c98c43058d6e11b774d0777340f040808fea
+  data.tar.gz: 0ac7feedcebe5df178f6ad313ba811004de126c82adc0f5289f44b43212a26ef2acfa3f09a45afa9cd4b158b7b4ef97976413ac357b4eb11749ab227c801a168

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"
@@ -23,33 +25,34 @@ 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"
+        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]}"
+          differences = record1[:record].compare(record2[:record])
+          if differences
+            puts "  ----"
+            print_differences(differences)
+            puts "  ----"
           end
+          puts "\n"
         end
       end
     end
@@ -65,26 +68,68 @@ module LocMods
     end
 
     def print_differences(differences, prefix = "", path = [])
+      if differences.is_a?(Comparison)
+        print_difference(differences, path)
+        return
+      end
+
+      # Differences is a Hash here
       differences.each do |key, value|
+        # puts "key #{key}, value #{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])
+        # This is a comparison
+        if value.is_a?(Comparison)
+          print_difference(value, path)
+          next
+        end
+
+        raise "Differences must be in form of a Hash" unless value.is_a?(Hash)
+
+        # This is not array, end here
+        next unless value.keys.any? do |k|
+          k.is_a?(Integer) || k == :_array_size_difference
+        end
+
+        # if value[:_array_size_difference]
+        #   puts "  #{format_path(current_path)} [_array_size_difference]:"
+        #   puts "    Record 1: #{format_value(value[:_array_size_difference].original)}"
+        #   puts "    Record 2: #{format_value(value[:_array_size_difference].updated)}"
+        #   puts
+        # end
+
+        value.each do |subkey, subvalue|
+          # if [:self, :other].include?(subkey)
+          #   raise "Subkey is self or other"
+          # end
+          # puts "subkey (#{subkey})"
+          # puts "subvalue #{subvalue}, prefix #{prefix}, current_path + [subkey] #{current_path + [subkey]}"
+
+          if subkey.is_a?(Integer)
+            print_differences(subvalue, prefix, current_path + [subkey])
+          else
+            if subvalue.is_a?(Comparison)
+              print_difference(subvalue, current_path + [subkey])
+              next
+            end
+
+            raise "In an array diff but not an Integer!"
           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
     end
 
+    def print_difference(value, current_path)
+      return unless value.original || value.updated
+
+      puts "  #{format_path(current_path)}:"
+      puts "    Record 1: #{format_value(value.original)}"
+      puts "    Record 2: #{format_value(value.updated)}"
+      puts
+    end
+
     def format_path(path)
       path.map.with_index do |part, index|
-        if index == 0
+        if index.zero?
           part.to_s
         elsif part.is_a?(Integer)
           "[#{part}]"
@@ -95,7 +140,14 @@ module LocMods
     end
 
     def format_value(value)
-      value.nil? ? "(nil)" : "\"#{value}\""
+      case value
+      when nil, ComparableNil
+        "(nil)"
+      when String
+        "\"#{value}\""
+      else
+        value.to_s
+      end
     end
   end
 end

data/lib/loc_mods/comparable_mapper.rb

@@ -1,30 +1,42 @@
+# frozen_string_literal: true
+
 # lib/loc_mods/comparable_mapper.rb
 
 module LocMods
+  # Enable comparison of two class models solely based on attribute values in
+  # a recursive manner.
   module ComparableMapper
-    # def self.included(base)
-    #   base.extend(ClassMethods)
+    # TODO: Implement Comparable
+    # include Comparable
+    # def <=>(other)
+    #   attributes.foo <=> other.attributes.foo
     # end
-
-    # module ClassMethods
-    #   def attribute_mapping
-    #     @attribute_mapping ||= attributes.to_h do |name, attribute|
-    #       [name, attribute.type]
-    #     end
-    #   end
+    # def inspect
+    #   @foo
     # end
 
-    def compare(other)
-      return {} unless other.is_a?(self.class)
+    def eql?(other)
+      other.class == self.class &&
+        self.class.attributes.all? do |attr|
+          send(attr) == other.send(attr)
+        end
+    end
 
+    alias == eql?
+
+    def hash
+      ([self.class] + self.class.attributes.map(&:hash)).hash
+    end
+
+    def compare(other)
       differences = {}
 
       # puts "Debugging: Attributes for #{self.class.name}"
       # pp self.class.attributes.keys
 
       self.class.attributes.each_key do |attr|
-        self_value = self.send(attr)
-        other_value = other.send(attr)
+        self_value = respond_to?(attr) ? send(attr) : nil
+        other_value = other.respond_to?(attr) ? other.send(attr) : nil
 
         # puts "Debugging: Comparing attribute '#{attr}'"
         # puts "  Self value: #{self_value.inspect}"
@@ -52,14 +64,14 @@ module LocMods
       case self_value
       when Array
         # puts "compare_values case 1"
-        compare_arrays(self_value, other_value)
-      when Shale::Mapper
+        compare_arrays(self_value, other_value || [])
+      when ComparableMapper
         # 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 }
+          Comparison.new(original: self_value, updated: other_value)
         end
       end
     end
@@ -69,25 +81,27 @@ module LocMods
       max_length = [self_array.size, other_array.size].max
 
       max_length.times do |index|
-        self_item = self_array[index]
-        other_item = other_array[index]
-
-        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)
-        else
-          compared = compare_values(self_item, other_item)
-          differences[index] = compared if compared
-        end
+        self_item = self_array[index] || ComparableNil.new
+        other_item = other_array[index] || ComparableNil.new
+
+        compared = compare_values(self_item, other_item)
+        differences[index] = compared if compared
+
+        # if index >= self_array.size
+        #   puts "case 1 #{compared}"
+        #   # differences[index] = compared
+        # elsif index >= other_array.size
+        #   puts "case 2.1 #{self_item}"
+        #   puts "case 2.2 #{compared}"
+        #   # differences[index] = compared
+        # end
       end
 
       if self_array.size != other_array.size
-        differences[:array_size_difference] = {
-          self: self_array.size,
-          other: other_array.size,
-        }
+        differences[:_array_size_difference] = Comparison.new(
+          original: self_array.size,
+          updated: other_array.size
+        )
       end
 
       differences.empty? ? nil : differences

data/lib/loc_mods/version.rb

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

metadata

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