unitsdb 2.1.0 → 2.2.1

data/lib/unitsdb/commands/ucum.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Unitsdb
+  module Commands
+    module Ucum
+      autoload :Check, "unitsdb/commands/ucum/check"
+      autoload :Update, "unitsdb/commands/ucum/update"
+      autoload :Formatter, "unitsdb/commands/ucum/formatter"
+      autoload :Matcher, "unitsdb/commands/ucum/matcher"
+      autoload :Updater, "unitsdb/commands/ucum/updater"
+      autoload :XmlParser, "unitsdb/commands/ucum/xml_parser"
+    end
+
+    class UcumCommand < Thor
+      # Inherit trace option from parent CLI
+      class_option :trace, type: :boolean, default: false,
+                           desc: "Show full backtrace on error"
+
+      desc "check", "Check UCUM references in UnitsDB"
+      option :entity_type, type: :string, aliases: "-e",
+                           desc: "Entity type to check (units, prefixes). If not specified, all types are checked"
+      option :ucum_file, type: :string, required: true, aliases: "-u",
+                         desc: "Path to the UCUM essence XML file"
+      option :output_updated_database, type: :string, aliases: "-o",
+                                       desc: "Directory path to write updated YAML files with added UCUM references"
+      option :direction, type: :string, default: "both", aliases: "-r",
+                         desc: "Direction to check: 'to_ucum' (UnitsDB→UCUM), 'from_ucum' (UCUM→UnitsDB), or 'both'"
+      option :include_potential_matches, type: :boolean, default: false, aliases: "-p",
+                                         desc: "Include potential matches when updating references (default: false)"
+      option :database, type: :string, required: true, aliases: "-d",
+                        desc: "Path to UnitsDB database (required)"
+      def check
+        run_command(Ucum::Check, options)
+      end
+
+      desc "update", "Update UnitsDB with UCUM references"
+      option :entity_type, type: :string, aliases: "-e",
+                           desc: "Entity type to update (units, prefixes). If not specified, all types are updated"
+      option :ucum_file, type: :string, required: true, aliases: "-u",
+                         desc: "Path to the UCUM essence XML file"
+      option :output_dir, type: :string, aliases: "-o",
+                          desc: "Directory path to write updated YAML files (defaults to database path)"
+      option :include_potential_matches, type: :boolean, default: false, aliases: "-p",
+                                         desc: "Include potential matches when updating references (default: false)"
+      option :database, type: :string, required: true, aliases: "-d",
+                        desc: "Path to UnitsDB database (required)"
+      def update
+        run_command(Ucum::Update, 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/validate/identifiers.rb

@@ -3,15 +3,15 @@
 module Unitsdb
   module Commands
     module Validate
-      class Identifiers < Base
+      class Identifiers < Unitsdb::Commands::Base
         def run
           db = load_database
           all_dups = db.validate_uniqueness
 
           display_results(all_dups)
         rescue Unitsdb::Errors::DatabaseError => e
-          puts "Error: #{e.message}"
-          exit(1)
+          raise Unitsdb::Errors::ValidationError,
+                "Failed to validate identifiers: #{e.message}"
         end
 
         private

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Unitsdb
+  module Commands
+    module Validate
+      class QudtReferences < Unitsdb::Commands::Base
+        def run
+          # Load the database
+          db = load_database(@options[:database])
+
+          # Check for duplicate QUDT references
+          duplicates = check_qudt_references(db)
+
+          # Display results
+          display_duplicate_results(duplicates)
+        rescue Unitsdb::Errors::DatabaseError => e
+          raise Unitsdb::Errors::ValidationError,
+                "Failed to validate QUDT references: #{e.message}"
+        end
+
+        private
+
+        def check_qudt_references(db)
+          duplicates = {}
+
+          # Check units
+          check_entity_qudt_references(db.units, "units", duplicates)
+
+          # Check quantities
+          check_entity_qudt_references(db.quantities, "quantities", duplicates)
+
+          # Check dimensions
+          check_entity_qudt_references(db.dimensions, "dimensions", duplicates)
+
+          # Check unit_systems
+          check_entity_qudt_references(db.unit_systems, "unit_systems",
+                                       duplicates)
+
+          duplicates
+        end
+
+        def check_entity_qudt_references(entities, entity_type, duplicates)
+          # Track QUDT references by URI
+          qudt_refs = {}
+
+          entities.each_with_index do |entity, index|
+            # Skip if no references
+            next unless entity.respond_to?(:references) && entity.references
+
+            # Check each reference
+            entity.references.each do |ref|
+              # Only interested in qudt references
+              next unless ref.authority == "qudt"
+
+              # 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
+              qudt_refs[ref.uri] ||= []
+              qudt_refs[ref.uri] << {
+                entity_id: entity_id,
+                entity_name: entity.respond_to?(:names) ? entity.names.first : entity.short,
+                index: index,
+              }
+            end
+          end
+
+          # Find duplicates (URIs with more than one entity)
+          qudt_refs.each do |uri, entities|
+            next unless entities.size > 1
+
+            # Record this duplicate
+            duplicates[entity_type] ||= {}
+            duplicates[entity_type][uri] = entities
+          end
+        end
+
+        def display_duplicate_results(duplicates)
+          if duplicates.empty?
+            puts "No duplicate QUDT references found! Each QUDT reference URI is used by at most one entity of each type."
+            return
+          end
+
+          puts "Found duplicate QUDT references:"
+
+          duplicates.each do |entity_type, uri_duplicates|
+            puts "\n  #{entity_type.capitalize}:"
+
+            uri_duplicates.each do |uri, entities|
+              puts "    QUDT 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 ""
+            end
+          end
+
+          puts "\nEach QUDT 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
+  end
+end

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

@@ -3,7 +3,7 @@
 module Unitsdb
   module Commands
     module Validate
-      class References < Base
+      class References < Unitsdb::Commands::Base
         def run
           # Load the database
           db = load_database(@options[:database])
@@ -17,8 +17,8 @@ module Unitsdb
           # Display results
           display_reference_results(invalid_refs, registry)
         rescue Unitsdb::Errors::DatabaseError => e
-          puts "Error: #{e.message}"
-          exit(1)
+          raise Unitsdb::Errors::ValidationError,
+                "Failed to validate references: #{e.message}"
         end
 
         private
@@ -97,7 +97,8 @@ module Unitsdb
             # 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}"
+              registry["unit_systems_short"][unit_system.short] =
+                "index:#{index}"
             end
           end
 
@@ -141,7 +142,8 @@ module Unitsdb
             ref_type = "dimensions"
             ref_path = "dimensions:index:#{index}:dimension_reference"
 
-            validate_reference(ref_id, ref_type, ref_path, registry, invalid_refs, "dimensions")
+            validate_reference(ref_id, ref_type, ref_path, registry,
+                               invalid_refs, "dimensions")
           end
         end
 
@@ -153,7 +155,8 @@ module Unitsdb
               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")
+              validate_reference(ref_id, ref_type, ref_path, registry,
+                                 invalid_refs, "units")
             end
           end
         end
@@ -166,7 +169,8 @@ module Unitsdb
               ref_type = "quantities"
               ref_path = "units:index:#{index}:quantity_references[#{idx}]"
 
-              validate_reference(ref_id, ref_type, ref_path, registry, invalid_refs, "units")
+              validate_reference(ref_id, ref_type, ref_path, registry,
+                                 invalid_refs, "units")
             end
           end
         end
@@ -183,7 +187,8 @@ module Unitsdb
               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")
+              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
@@ -192,12 +197,14 @@ module Unitsdb
               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")
+              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)
+        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
@@ -216,8 +223,12 @@ module Unitsdb
             # 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? { |k| k.end_with?(":SI_#{id.sub("si-", "")}") } ||
-                registry[ref_type].keys.any? { |k| k.end_with?(":non-SI_#{id.sub("nonsi-", "")}") }
+                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
@@ -227,7 +238,8 @@ module Unitsdb
               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 }
+              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")
@@ -247,8 +259,12 @@ module Unitsdb
             # 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? { |k| k.end_with?(":SI_#{id.sub("si-", "")}") } ||
-                registry[ref_type].keys.any? { |k| k.end_with?(":non-SI_#{id.sub("nonsi-", "")}") }
+                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
@@ -258,7 +274,8 @@ module Unitsdb
               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 }
+              invalid_refs[file_type][ref_path] =
+                { id: id, type: type, ref_type: ref_type }
             end
           else
             # Handle plain string references (legacy format)
@@ -290,7 +307,8 @@ module Unitsdb
 
               puts "  #{type}:"
               ids.each do |id, location|
-                puts "    #{id}: {type: #{type.sub("s", "")}, source: #{location}}"
+                puts "    #{id}: {type: #{type.sub('s',
+                                                   '')}, source: #{location}}"
               end
             end
           end
@@ -302,7 +320,8 @@ module Unitsdb
               # Suggest corrections
               next unless registry.key?(ref[:ref_type])
 
-              similar_ids = Unitsdb::Utils.find_similar_ids(ref[:id], registry[ref[:ref_type]].keys)
+              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}" }

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../base"
-
 module Unitsdb
   module Commands
     module Validate
@@ -16,8 +14,8 @@ module Unitsdb
           # Display results
           display_duplicate_results(duplicates)
         rescue Unitsdb::Errors::DatabaseError => e
-          puts "Error: #{e.message}"
-          exit(1)
+          raise Unitsdb::Errors::ValidationError,
+                "Failed to validate SI references: #{e.message}"
         end
 
         private
@@ -62,7 +60,7 @@ module Unitsdb
               si_refs[ref.uri] << {
                 entity_id: entity_id,
                 entity_name: entity.respond_to?(:names) ? entity.names.first : entity.short,
-                index: index
+                index: index,
               }
             end
           end
@@ -103,12 +101,6 @@ module Unitsdb
           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
-
-        def load_database(path)
-          Unitsdb::Database.from_db(path)
-        rescue StandardError => e
-          raise Unitsdb::Errors::DatabaseError, "Failed to load database: #{e.message}"
-        end
       end
     end
   end

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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Unitsdb
+  module Commands
+    module Validate
+      class UcumReferences < Unitsdb::Commands::Base
+        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)
+        rescue Unitsdb::Errors::DatabaseError => e
+          raise Unitsdb::Errors::ValidationError,
+                "Failed to validate UCUM references: #{e.message}"
+        end
+
+        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
+        end
+
+        def check_entity_ucum_references(entities, entity_type, duplicates)
+          # Track UCUM references by code
+          ucum_refs = {}
+
+          entities.each_with_index do |entity, index|
+            # Skip if no external references
+            next unless entity.respond_to?(:external_references) && entity.external_references
+
+            # 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,
+                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
+        end
+
+        def display_duplicate_results(duplicates)
+          if duplicates.empty?
+            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|
+              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 ""
+            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
+  end
+end

data/lib/unitsdb/commands/validate.rb

@@ -4,16 +4,28 @@ require "thor"
 
 module Unitsdb
   module Commands
+    module Validate
+      autoload :Identifiers, "unitsdb/commands/validate/identifiers"
+      autoload :QudtReferences, "unitsdb/commands/validate/qudt_references"
+      autoload :References, "unitsdb/commands/validate/references"
+      autoload :SiReferences, "unitsdb/commands/validate/si_references"
+      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"
+
       desc "references", "Validate that all references exist"
-      option :debug_registry, type: :boolean, desc: "Show registry contents for debugging"
+      option :debug_registry, type: :boolean,
+                              desc: "Show registry contents for debugging"
       option :database, type: :string, required: true, aliases: "-d",
                         desc: "Path to UnitsDB database (required)"
-      option :print_valid, type: :boolean, default: false, desc: "Print valid references too"
+      option :print_valid, type: :boolean, default: false,
+                           desc: "Print valid references too"
       def references
-        require_relative "validate/references"
-
-        Commands::References.new(options).run
+        run_command(Commands::Validate::References, options)
       end
 
       desc "identifiers", "Check for uniqueness of identifier fields"
@@ -21,19 +33,63 @@ module Unitsdb
                         desc: "Path to UnitsDB database (required)"
 
       def identifiers
-        require_relative "validate/identifiers"
-
-        Commands::Identifiers.new(options).run
+        run_command(Commands::Validate::Identifiers, options)
       end
 
-      desc "si_references", "Validate that each SI digital framework reference is unique per entity type"
+      desc "si_references",
+           "Validate that each SI digital framework reference is unique per entity type"
       option :database, type: :string, required: true, aliases: "-d",
                         desc: "Path to UnitsDB database (required)"
 
       def si_references
-        require_relative "validate/si_references"
+        run_command(Commands::Validate::SiReferences, options)
+      end
+
+      desc "qudt_references",
+           "Validate that each QUDT reference is unique per entity type"
+      option :database, type: :string, required: true, aliases: "-d",
+                        desc: "Path to UnitsDB database (required)"
+
+      def qudt_references
+        run_command(Commands::Validate::QudtReferences, options)
+      end
+
+      desc "ucum_references",
+           "Validate that each UCUM reference is unique per entity type"
+      option :database, type: :string, required: true, aliases: "-d",
+                        desc: "Path to UnitsDB database (required)"
+
+      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
 
-        Validate::SiReferences.new(options).run
+      def handle_error(error)
+        if options[:trace]
+          raise error
+        else
+          warn "Error: #{error.message}"
+          exit 1
+        end
       end
     end
   end

data/lib/unitsdb/commands.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Unitsdb
+  module Commands
+    autoload :ModifyCommand, "unitsdb/commands/_modify"
+    autoload :Base, "unitsdb/commands/base"
+    autoload :CheckSi, "unitsdb/commands/check_si"
+    autoload :CheckSiCommand, "unitsdb/commands/check_si"
+    autoload :Get, "unitsdb/commands/get"
+    autoload :Normalize, "unitsdb/commands/normalize"
+    autoload :Qudt, "unitsdb/commands/qudt"
+    autoload :QudtCommand, "unitsdb/commands/qudt"
+    autoload :Release, "unitsdb/commands/release"
+    autoload :Search, "unitsdb/commands/search"
+    autoload :Ucum, "unitsdb/commands/ucum"
+    autoload :UcumCommand, "unitsdb/commands/ucum"
+    autoload :Validate, "unitsdb/commands/validate"
+    autoload :ValidateCommand, "unitsdb/commands/validate"
+  end
+end