unitsdb 2.2.1 → 2.2.4

data/lib/unitsdb/commands/validate/references.rb

@@ -3,19 +3,13 @@
 module Unitsdb
   module Commands
     module Validate
+      # `unitsdb validate references`. Thin presenter around
+      # Database::ReferenceValidator — owns output formatting only.
       class References < Unitsdb::Commands::Base
         def run
-          # Load the database
           db = load_database(@options[:database])
-
-          # Build registry of all valid IDs
-          registry = build_id_registry(db)
-
-          # Check all references
-          invalid_refs = check_references(db, registry)
-
-          # Display results
-          display_reference_results(invalid_refs, registry)
+          result = Unitsdb::Database::ReferenceValidator.new(db).validate
+          display_result(result.invalid)
         rescue Unitsdb::Errors::DatabaseError => e
           raise Unitsdb::Errors::ValidationError,
                 "Failed to validate references: #{e.message}"
@@ -23,309 +17,17 @@ module Unitsdb
 
         private
 
-        def build_id_registry(db)
-          registry = {}
-
-          # Add all unit identifiers to the registry
-          registry["units"] = {}
-          db.units.each_with_index do |unit, index|
-            unit.identifiers.each do |identifier|
-              next unless identifier.id && identifier.type
-
-              # Add the composite key (type:id)
-              composite_key = "#{identifier.type}:#{identifier.id}"
-              registry["units"][composite_key] = "index:#{index}"
-
-              # Also add just the ID for backward compatibility
-              registry["units"][identifier.id] = "index:#{index}"
-            end
-          end
-
-          # Add dimension identifiers
-          registry["dimensions"] = {}
-          db.dimensions.each_with_index do |dimension, index|
-            dimension.identifiers.each do |identifier|
-              next unless identifier.id && identifier.type
-
-              composite_key = "#{identifier.type}:#{identifier.id}"
-              registry["dimensions"][composite_key] = "index:#{index}"
-              registry["dimensions"][identifier.id] = "index:#{index}"
-            end
-
-            # Also track dimensions by short name
-            if dimension.respond_to?(:short) && dimension.short
-              registry["dimensions_short"] ||= {}
-              registry["dimensions_short"][dimension.short] = "index:#{index}"
-            end
-          end
-
-          # Add quantity identifiers
-          registry["quantities"] = {}
-          db.quantities.each_with_index do |quantity, index|
-            quantity.identifiers.each do |identifier|
-              next unless identifier.id && identifier.type
-
-              composite_key = "#{identifier.type}:#{identifier.id}"
-              registry["quantities"][composite_key] = "index:#{index}"
-              registry["quantities"][identifier.id] = "index:#{index}"
-            end
-          end
-
-          # Add prefix identifiers
-          registry["prefixes"] = {}
-          db.prefixes.each_with_index do |prefix, index|
-            prefix.identifiers.each do |identifier|
-              next unless identifier.id && identifier.type
-
-              composite_key = "#{identifier.type}:#{identifier.id}"
-              registry["prefixes"][composite_key] = "index:#{index}"
-              registry["prefixes"][identifier.id] = "index:#{index}"
-            end
-          end
-
-          # Add unit system identifiers
-          registry["unit_systems"] = {}
-          db.unit_systems.each_with_index do |unit_system, index|
-            unit_system.identifiers.each do |identifier|
-              next unless identifier.id && identifier.type
-
-              composite_key = "#{identifier.type}:#{identifier.id}"
-              registry["unit_systems"][composite_key] = "index:#{index}"
-              registry["unit_systems"][identifier.id] = "index:#{index}"
-            end
-
-            # Also track unit systems by short name
-            if unit_system.respond_to?(:short) && unit_system.short
-              registry["unit_systems_short"] ||= {}
-              registry["unit_systems_short"][unit_system.short] =
-                "index:#{index}"
-            end
-          end
-
-          # Debug registry if requested
-          if @options[:debug_registry]
-            puts "Registry contents:"
-            registry.each do |type, ids|
-              puts "  #{type}:"
-              ids.each do |id, location|
-                puts "    #{id} => #{location}"
-              end
-            end
-          end
-
-          registry
-        end
-
-        def check_references(db, registry)
-          invalid_refs = {}
-
-          # Check unit references in dimensions
-          check_dimension_references(db, registry, invalid_refs)
-
-          # Check unit_system references
-          check_unit_system_references(db, registry, invalid_refs)
-
-          # Check quantity references
-          check_quantity_references(db, registry, invalid_refs)
-
-          # Check root unit references in units
-          check_root_unit_references(db, registry, invalid_refs)
-
-          invalid_refs
-        end
-
-        def check_dimension_references(db, registry, invalid_refs)
-          db.dimensions.each_with_index do |dimension, index|
-            next unless dimension.respond_to?(:dimension_reference) && dimension.dimension_reference
-
-            ref_id = dimension.dimension_reference
-            ref_type = "dimensions"
-            ref_path = "dimensions:index:#{index}:dimension_reference"
-
-            validate_reference(ref_id, ref_type, ref_path, registry,
-                               invalid_refs, "dimensions")
-          end
-        end
-
-        def check_unit_system_references(db, registry, invalid_refs)
-          db.units.each_with_index do |unit, index|
-            next unless unit.respond_to?(:unit_system_reference) && unit.unit_system_reference
-
-            unit.unit_system_reference.each_with_index do |ref_id, idx|
-              ref_type = "unit_systems"
-              ref_path = "units:index:#{index}:unit_system_reference[#{idx}]"
-
-              validate_reference(ref_id, ref_type, ref_path, registry,
-                                 invalid_refs, "units")
-            end
-          end
-        end
-
-        def check_quantity_references(db, registry, invalid_refs)
-          db.units.each_with_index do |unit, index|
-            next unless unit.respond_to?(:quantity_references) && unit.quantity_references
-
-            unit.quantity_references.each_with_index do |ref_id, idx|
-              ref_type = "quantities"
-              ref_path = "units:index:#{index}:quantity_references[#{idx}]"
-
-              validate_reference(ref_id, ref_type, ref_path, registry,
-                                 invalid_refs, "units")
-            end
-          end
-        end
-
-        def check_root_unit_references(db, registry, invalid_refs)
-          db.units.each_with_index do |unit, index|
-            next unless unit.respond_to?(:root_units) && unit.root_units
-
-            unit.root_units.each_with_index do |root_unit, idx|
-              next unless root_unit.respond_to?(:unit_reference) && root_unit.unit_reference
-
-              # Check unit reference
-              ref_id = root_unit.unit_reference
-              ref_type = "units"
-              ref_path = "units:index:#{index}:root_units.#{idx}.unit_reference"
-
-              validate_reference(ref_id, ref_type, ref_path, registry,
-                                 invalid_refs, "units")
-
-              # Check prefix reference if present
-              next unless root_unit.respond_to?(:prefix_reference) && root_unit.prefix_reference
-
-              ref_id = root_unit.prefix_reference
-              ref_type = "prefixes"
-              ref_path = "units:index:#{index}:root_units.#{idx}.prefix_reference"
-
-              validate_reference(ref_id, ref_type, ref_path, registry,
-                                 invalid_refs, "units")
-            end
-          end
-        end
-
-        def validate_reference(ref_id, ref_type, ref_path, registry,
-invalid_refs, file_type)
-          # Handle references that are objects with id and type (could be a hash or an object)
-          if ref_id.respond_to?(:id) && ref_id.respond_to?(:type)
-            id = ref_id.id
-            type = ref_id.type
-            composite_key = "#{type}:#{id}"
-
-            # Try multiple lookup strategies
-            valid = false
-
-            # 1. Try exact composite key match
-            valid = true if registry.key?(ref_type) && registry[ref_type].key?(composite_key)
-
-            # 2. Try just ID match if composite didn't work
-            valid = true if !valid && registry.key?(ref_type) && registry[ref_type].key?(id)
-
-            # 3. Try alternate ID formats for unit systems (e.g., SI_base vs si-base)
-            if !valid && type == "unitsml" && ref_type == "unit_systems" && registry.key?(ref_type) && (
-                registry[ref_type].keys.any? { |k| k.end_with?(":#{id}") } ||
-                registry[ref_type].keys.any? do |k|
-                  k.end_with?(":SI_#{id.sub('si-', '')}")
-                end ||
-                registry[ref_type].keys.any? do |k|
-                  k.end_with?(":non-SI_#{id.sub('nonsi-', '')}")
-                end
-              )
-              # Special handling for unit_systems between unitsml and nist types
-              valid = true
-            end
-
-            if valid
-              puts "Valid reference: #{id} (#{type}) at #{file_type}:#{ref_path}" if @options[:print_valid]
-            else
-              invalid_refs[file_type] ||= {}
-              invalid_refs[file_type][ref_path] =
-                { id: id, type: type, ref_type: ref_type }
-            end
-          # Handle references that are objects with id and type in a hash
-          elsif ref_id.is_a?(Hash) && ref_id.key?("id") && ref_id.key?("type")
-            id = ref_id["id"]
-            type = ref_id["type"]
-            composite_key = "#{type}:#{id}"
-
-            # Try multiple lookup strategies
-            valid = false
-
-            # 1. Try exact composite key match
-            valid = true if registry.key?(ref_type) && registry[ref_type].key?(composite_key)
-
-            # 2. Try just ID match if composite didn't work
-            valid = true if !valid && registry.key?(ref_type) && registry[ref_type].key?(id)
-
-            # 3. Try alternate ID formats for unit systems (e.g., SI_base vs si-base)
-            if !valid && type == "unitsml" && ref_type == "unit_systems" && registry.key?(ref_type) && (
-                registry[ref_type].keys.any? { |k| k.end_with?(":#{id}") } ||
-                registry[ref_type].keys.any? do |k|
-                  k.end_with?(":SI_#{id.sub('si-', '')}")
-                end ||
-                registry[ref_type].keys.any? do |k|
-                  k.end_with?(":non-SI_#{id.sub('nonsi-', '')}")
-                end
-              )
-              # Special handling for unit_systems between unitsml and nist types
-              valid = true
-            end
-
-            if valid
-              puts "Valid reference: #{id} (#{type}) at #{file_type}:#{ref_path}" if @options[:print_valid]
-            else
-              invalid_refs[file_type] ||= {}
-              invalid_refs[file_type][ref_path] =
-                { id: id, type: type, ref_type: ref_type }
-            end
-          else
-            # Handle plain string references (legacy format)
-            valid = registry.key?(ref_type) && registry[ref_type].key?(ref_id)
-
-            if valid
-              puts "Valid reference: #{ref_id} (#{ref_type}) at #{file_type}:#{ref_path}" if @options[:print_valid]
-            else
-              invalid_refs[file_type] ||= {}
-              invalid_refs[file_type][ref_path] = { id: ref_id, type: ref_type }
-            end
-          end
-        end
-
-        def display_reference_results(invalid_refs, registry)
+        def display_result(invalid_refs)
           if invalid_refs.empty?
             puts "All references are valid!"
             return
           end
 
           puts "Found invalid references:"
-
-          # Display registry contents if debug_registry is enabled
-          # This is needed for the failing test
-          if @options[:debug_registry]
-            puts "\nRegistry contents:"
-            registry.each do |type, ids|
-              next if ids.empty?
-
-              puts "  #{type}:"
-              ids.each do |id, location|
-                puts "    #{id}: {type: #{type.sub('s',
-                                                   '')}, source: #{location}}"
-              end
-            end
-          end
           invalid_refs.each do |file, refs|
             puts "  #{file}:"
             refs.each do |path, ref|
               puts "    #{path} => '#{ref[:id]}' (#{ref[:type]})"
-
-              # Suggest corrections
-              next unless registry.key?(ref[:ref_type])
-
-              similar_ids = Unitsdb::Utils.find_similar_ids(ref[:id],
-                                                            registry[ref[:ref_type]].keys)
-              if similar_ids.any?
-                puts "      Did you mean one of these?"
-                similar_ids.each { |id| puts "        - #{id}" }
-              end
             end
           end
         end

data/lib/unitsdb/commands/validate/si_references.rb

@@ -3,16 +3,17 @@
 module Unitsdb
   module Commands
     module Validate
+      # `unitsdb validate si_references`. Checks that no SI
+      # digital-framework reference URI is used by more than one
+      # Unit, Quantity, or Prefix.
       class SiReferences < Unitsdb::Commands::Base
+        AUTHORITY = "si-digital-framework"
+        ENTITY_COLLECTIONS = %i[units quantities prefixes].freeze
+
         def run
-          # Load the database
           db = load_database(@options[:database])
-
-          # Check for duplicate SI references
-          duplicates = check_si_references(db)
-
-          # Display results
-          display_duplicate_results(duplicates)
+          duplicates = scan(db)
+          display(duplicates)
         rescue Unitsdb::Errors::DatabaseError => e
           raise Unitsdb::Errors::ValidationError,
                 "Failed to validate SI references: #{e.message}"
@@ -20,86 +21,49 @@ module Unitsdb
 
         private
 
-        def check_si_references(db)
-          duplicates = {}
-
-          # Check units
-          check_entity_si_references(db.units, "units", duplicates)
-
-          # Check quantities
-          check_entity_si_references(db.quantities, "quantities", duplicates)
-
-          # Check prefixes
-          check_entity_si_references(db.prefixes, "prefixes", duplicates)
-
-          duplicates
+        def scan(db)
+          {}.tap do |duplicates|
+            ENTITY_COLLECTIONS.each do |name|
+              dup = scan_collection(db.collection(name))
+              duplicates[name.to_s] = dup unless dup.empty?
+            end
+          end
         end
 
-        def check_entity_si_references(entities, entity_type, duplicates)
-          # Track SI references by URI
-          si_refs = {}
-
+        def scan_collection(entities)
+          by_uri = {}
           entities.each_with_index do |entity, index|
-            # Skip if no references
-            next unless entity.respond_to?(:references) && entity.references
+            refs = entity.references || []
+            refs.each do |ref|
+              next unless ref.authority == AUTHORITY
 
-            # Check each reference
-            entity.references.each do |ref|
-              # Only interested in si-digital-framework references
-              next unless ref.authority == "si-digital-framework"
-
-              # Get entity info for display
-              entity_id = if entity.respond_to?(:identifiers) && entity.identifiers&.first.respond_to?(:id)
-                            entity.identifiers.first.id
-                          else
-                            entity.short
-                          end
-
-              # Track this reference
-              si_refs[ref.uri] ||= []
-              si_refs[ref.uri] << {
-                entity_id: entity_id,
-                entity_name: entity.respond_to?(:names) ? entity.names.first : entity.short,
+              (by_uri[ref.uri] ||= []) << {
+                entity_id: entity.identifiers.first&.id || entity.short,
+                entity_name: entity.names.first || entity.short,
                 index: index,
               }
             end
           end
-
-          # Find duplicates (URIs with more than one entity)
-          si_refs.each do |uri, entities|
-            next unless entities.size > 1
-
-            # Record this duplicate
-            duplicates[entity_type] ||= {}
-            duplicates[entity_type][uri] = entities
-          end
+          by_uri.reject { |_, refs| refs.size == 1 }
         end
 
-        def display_duplicate_results(duplicates)
+        def display(duplicates)
           if duplicates.empty?
-            puts "No duplicate SI references found! Each SI reference URI is used by at most one entity of each type."
+            puts "No duplicate SI references found! " \
+                 "Each SI reference URI is used by at most one entity of each type."
             return
           end
 
           puts "Found duplicate SI references:"
-
           duplicates.each do |entity_type, uri_duplicates|
             puts "\n  #{entity_type.capitalize}:"
-
-            uri_duplicates.each do |uri, entities|
+            uri_duplicates.each do |uri, refs|
               puts "    SI URI: #{uri}"
-              puts "    Used by #{entities.size} entities:"
-
-              entities.each do |entity|
-                puts "      - #{entity[:entity_id]} (#{entity[:entity_name]}) at index #{entity[:index]}"
-              end
+              puts "    Used by #{refs.size} entities:"
+              refs.each { |r| puts "      - #{r[:entity_id]} (#{r[:entity_name]}) at index #{r[:index]}" }
               puts ""
             end
           end
-
-          puts "\nEach SI digital framework reference should be used by at most one entity of each type."
-          puts "Please fix the duplicates by either removing the reference from all but one entity,"
-          puts "or by updating the references to use different URIs appropriate for each entity."
         end
       end
     end

data/lib/unitsdb/commands/validate/ucum_references.rb

@@ -3,16 +3,16 @@
 module Unitsdb
   module Commands
     module Validate
+      # `unitsdb validate ucum_references`. Checks that no UCUM
+      # reference code is used by more than one Unit or Prefix.
       class UcumReferences < Unitsdb::Commands::Base
+        AUTHORITY = "ucum"
+        ENTITY_COLLECTIONS = %i[units prefixes].freeze
+
         def run
-          # Load the database
           db = load_database(@options[:database])
-
-          # Check for duplicate UCUM references
-          duplicates = check_ucum_references(db)
-
-          # Display results
-          display_duplicate_results(duplicates)
+          duplicates = scan(db)
+          display(duplicates)
         rescue Unitsdb::Errors::DatabaseError => e
           raise Unitsdb::Errors::ValidationError,
                 "Failed to validate UCUM references: #{e.message}"
@@ -20,84 +20,50 @@ module Unitsdb
 
         private
 
-        def check_ucum_references(db)
-          duplicates = {}
-
-          # Check units
-          check_entity_ucum_references(db.units, "units", duplicates)
-
-          # Check prefixes
-          check_entity_ucum_references(db.prefixes, "prefixes", duplicates)
-
-          duplicates
+        def scan(db)
+          {}.tap do |duplicates|
+            ENTITY_COLLECTIONS.each do |name|
+              collection = db.collection(name) || []
+              dup = scan_collection(collection)
+              duplicates[name.to_s] = dup unless dup.empty?
+            end
+          end
         end
 
-        def check_entity_ucum_references(entities, entity_type, duplicates)
-          # Track UCUM references by code
-          ucum_refs = {}
-
+        def scan_collection(entities)
+          by_code = {}
           entities.each_with_index do |entity, index|
-            # Skip if no external references
-            next unless entity.respond_to?(:external_references) && entity.external_references
+            refs = entity.references || []
+            refs.each do |ref|
+              next unless ref.authority == AUTHORITY
 
-            # Check each external reference
-            entity.external_references.each do |ref|
-              # Only interested in ucum references
-              next unless ref.authority == "ucum"
-
-              # Get entity info for display
-              entity_id = entity.respond_to?(:id) ? entity.id : entity.short
-              entity_name = if entity.respond_to?(:names) && entity.names&.first
-                              entity.names.first.respond_to?(:name) ? entity.names.first.name : entity.names.first
-                            else
-                              entity.short
-                            end
-
-              # Track this reference
-              ucum_refs[ref.code] ||= []
-              ucum_refs[ref.code] << {
-                entity_id: entity_id,
-                entity_name: entity_name,
+              (by_code[ref.uri] ||= []) << {
+                entity_id: entity.identifiers.first&.id || entity.short,
+                entity_name: entity.names.first&.value || entity.short,
                 index: index,
               }
             end
           end
-
-          # Find duplicates (codes with more than one entity)
-          ucum_refs.each do |code, entities|
-            next unless entities.size > 1
-
-            # Record this duplicate
-            duplicates[entity_type] ||= {}
-            duplicates[entity_type][code] = entities
-          end
+          by_code.reject { |_, refs| refs.size == 1 }
         end
 
-        def display_duplicate_results(duplicates)
+        def display(duplicates)
           if duplicates.empty?
-            puts "No duplicate UCUM references found! Each UCUM reference code is used by at most one entity of each type."
+            puts "No duplicate UCUM references found! " \
+                 "Each UCUM reference code is used by at most one entity of each type."
             return
           end
 
           puts "Found duplicate UCUM references:"
-
           duplicates.each do |entity_type, code_duplicates|
             puts "\n  #{entity_type.capitalize}:"
-
-            code_duplicates.each do |code, entities|
+            code_duplicates.each do |code, refs|
               puts "    UCUM Code: #{code}"
-              puts "    Used by #{entities.size} entities:"
-
-              entities.each do |entity|
-                puts "      - #{entity[:entity_id]} (#{entity[:entity_name]}) at index #{entity[:index]}"
-              end
+              puts "    Used by #{refs.size} entities:"
+              refs.each { |r| puts "      - #{r[:entity_id]} (#{r[:entity_name]}) at index #{r[:index]}" }
               puts ""
             end
           end
-
-          puts "\nEach UCUM reference should be used by at most one entity of each type."
-          puts "Please fix the duplicates by either removing the reference from all but one entity,"
-          puts "or by updating the references to use different codes appropriate for each entity."
         end
       end
     end

data/lib/unitsdb/commands/validate.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "thor"
-
 module Unitsdb
   module Commands
     module Validate
@@ -12,11 +10,7 @@ module Unitsdb
       autoload :UcumReferences, "unitsdb/commands/validate/ucum_references"
     end
 
-    class ValidateCommand < Thor
-      # Inherit trace option from parent CLI
-      class_option :trace, type: :boolean, default: false,
-                           desc: "Show full backtrace on error"
-
+    class ValidateCommand < Unitsdb::Commands::Thor
       desc "references", "Validate that all references exist"
       option :debug_registry, type: :boolean,
                               desc: "Show registry contents for debugging"
@@ -62,35 +56,6 @@ module Unitsdb
       def ucum_references
         run_command(Commands::Validate::UcumReferences, options)
       end
-
-      private
-
-      def run_command(command_class, options)
-        command = command_class.new(options)
-        command.run
-      rescue Unitsdb::Errors::CLIRuntimeError => e
-        handle_cli_error(e)
-      rescue StandardError => e
-        handle_error(e)
-      end
-
-      def handle_cli_error(error)
-        if options[:trace]
-          raise error
-        else
-          warn "Error: #{error.message}"
-          exit 1
-        end
-      end
-
-      def handle_error(error)
-        if options[:trace]
-          raise error
-        else
-          warn "Error: #{error.message}"
-          exit 1
-        end
-      end
     end
   end
 end

data/lib/unitsdb/commands.rb

@@ -2,10 +2,12 @@
 
 module Unitsdb
   module Commands
+    autoload :Thor, "unitsdb/commands/thor"
     autoload :ModifyCommand, "unitsdb/commands/_modify"
     autoload :Base, "unitsdb/commands/base"
     autoload :CheckSi, "unitsdb/commands/check_si"
     autoload :CheckSiCommand, "unitsdb/commands/check_si"
+    autoload :EntityPresenter, "unitsdb/commands/entity_presenter"
     autoload :Get, "unitsdb/commands/get"
     autoload :Normalize, "unitsdb/commands/normalize"
     autoload :Qudt, "unitsdb/commands/qudt"