unitsdb 2.1.1 → 2.2.1

data/lib/unitsdb/commands/ucum/update.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../base"
-require_relative "../../database"
-require_relative "xml_parser"
-require_relative "matcher"
-require_relative "updater"
 require "fileutils"
 
 module Unitsdb
@@ -37,17 +32,19 @@ module Unitsdb
             return 1
           end
           puts "Using UCUM file: #{ucum_file}"
-          puts "Include potential matches: #{include_potential ? "Yes" : "No"}"
+          puts "Include potential matches: #{include_potential ? 'Yes' : 'No'}"
 
           # Parse UCUM XML file
           ucum_data = XmlParser.parse_ucum_file(ucum_file)
 
           # Process entity types
           if entity_type && ENTITY_TYPES.include?(entity_type)
-            process_entity_type(entity_type, ucum_data, output_dir, include_potential)
+            process_entity_type(entity_type, ucum_data, output_dir,
+                                include_potential)
           else
             ENTITY_TYPES.each do |type|
-              process_entity_type(type, ucum_data, output_dir, include_potential)
+              process_entity_type(type, ucum_data, output_dir,
+                                  include_potential)
             end
           end
 
@@ -56,7 +53,8 @@ module Unitsdb
 
         private
 
-        def process_entity_type(entity_type, ucum_data, output_dir, include_potential)
+        def process_entity_type(entity_type, ucum_data, output_dir,
+include_potential)
           puts "\n========== Processing #{entity_type.upcase} References =========="
 
           # Get entities
@@ -64,19 +62,22 @@ module Unitsdb
           yaml_path = File.join(@options[:database], "#{entity_type}.yaml")
           entity_collection = klass.from_yaml(File.read(yaml_path))
 
-          ucum_entities = XmlParser.get_entities_from_ucum(entity_type, ucum_data)
+          ucum_entities = XmlParser.get_entities_from_ucum(entity_type,
+                                                           ucum_data)
 
           return if ucum_entities.nil? || ucum_entities.empty?
 
           # Match entities
-          _, missing_refs, = Matcher.match_db_to_ucum(entity_type, ucum_entities, entity_collection)
+          _, missing_refs, = Matcher.match_db_to_ucum(entity_type,
+                                                      ucum_entities, entity_collection)
 
           # Create output directory if it doesn't exist
-          FileUtils.mkdir_p(output_dir) unless Dir.exist?(output_dir)
+          FileUtils.mkdir_p(output_dir)
 
           # Update references in UnitsDB entities
           output_file = File.join(output_dir, "#{entity_type}.yaml")
-          Updater.update_references(entity_type, missing_refs, entity_collection, output_file, include_potential)
+          Updater.update_references(entity_type, missing_refs,
+                                    entity_collection, output_file, include_potential)
         end
       end
     end

data/lib/unitsdb/commands/ucum/updater.rb

@@ -13,7 +13,8 @@ module Unitsdb
         module_function
 
         # Update references in UnitsDB entities with UCUM references
-        def update_references(entity_type, matches, db_entities, output_file, include_potential = false)
+        def update_references(entity_type, matches, db_entities, output_file,
+include_potential = false)
           puts "Updating UCUM references for #{entity_type}..."
 
           # Create a map of entity IDs to their UCUM references
@@ -35,7 +36,7 @@ module Unitsdb
             entity_references[entity_id] = ExternalReference.new(
               uri: ucum_entity.identifier,
               type: "informative",
-              authority: UCUM_AUTHORITY
+              authority: UCUM_AUTHORITY,
             )
           end
 
@@ -57,7 +58,9 @@ module Unitsdb
 
             # Add new references
             if (ext_ref = entity_references[entity_id])
-              if entity.references.detect { |ref| ref.uri == ext_ref.uri && ref.authority == ext_ref.authority }
+              if entity.references.detect do |ref|
+                ref.uri == ext_ref.uri && ref.authority == ext_ref.authority
+              end
                 # Skip if reference already exists
                 puts "Reference already exists for entity ID: #{entity_id}"
               else
@@ -78,10 +81,41 @@ module Unitsdb
         def write_yaml_file(output_file, output_data)
           # Ensure the output directory exists
           output_dir = File.dirname(output_file)
-          FileUtils.mkdir_p(output_dir) unless Dir.exist?(output_dir)
+          FileUtils.mkdir_p(output_dir)
 
-          # Write to YAML file
-          File.write(output_file, output_data.to_yaml)
+          # Write to YAML file with proper formatting
+          yaml_content = output_data.to_yaml
+
+          # Preserve existing schema header or add default one
+          yaml_content = preserve_schema_header(output_file, yaml_content)
+
+          File.write(output_file, yaml_content)
+        end
+
+        # Preserve existing schema header or add default one
+        def preserve_schema_header(original_file, yaml_content)
+          schema_header = nil
+
+          # Extract existing schema header if file exists
+          if File.exist?(original_file)
+            original_content = File.read(original_file)
+            if (match = original_content.match(/^# yaml-language-server: \$schema=.+$/))
+              schema_header = match[0]
+            end
+          end
+
+          # Remove any existing schema header from new content to avoid duplication
+          yaml_content = yaml_content.gsub(
+            /^# yaml-language-server: \$schema=.+$\n/, ""
+          )
+
+          # Add preserved or default schema header
+          if schema_header
+            "#{schema_header}\n#{yaml_content}"
+          else
+            entity_type = File.basename(original_file, ".yaml")
+            "# yaml-language-server: $schema=schemas/#{entity_type}-schema.yaml\n#{yaml_content}"
+          end
         end
 
         # Get entity ID (either from identifiers array or directly)

data/lib/unitsdb/commands/ucum/xml_parser.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../../ucum"
-
 module Unitsdb
   module Commands
     module Ucum

data/lib/unitsdb/commands/ucum.rb

@@ -4,7 +4,20 @@ 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"
@@ -19,8 +32,7 @@ module Unitsdb
       option :database, type: :string, required: true, aliases: "-d",
                         desc: "Path to UnitsDB database (required)"
       def check
-        require_relative "ucum/check"
-        Ucum::Check.new(options).run
+        run_command(Ucum::Check, options)
       end
 
       desc "update", "Update UnitsDB with UCUM references"
@@ -35,8 +47,36 @@ module Unitsdb
       option :database, type: :string, required: true, aliases: "-d",
                         desc: "Path to UnitsDB database (required)"
       def update
-        require_relative "ucum/update"
-        Ucum::Update.new(options).run
+        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

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../base"
-
 module Unitsdb
   module Commands
     module Validate
@@ -12,8 +10,8 @@ module Unitsdb
 
           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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../base"
-
 module Unitsdb
   module Commands
     module Validate
@@ -19,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
@@ -99,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
 
@@ -143,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
 
@@ -155,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
@@ -168,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
@@ -185,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
@@ -194,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
@@ -218,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
@@ -229,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")
@@ -249,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
@@ -260,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)
@@ -292,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
@@ -304,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

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