unitsdb 2.1.0 → 2.2.1

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Unitsdb
+  module Commands
+    module Ucum
+      # Formats output for UCUM matching results
+      module Formatter
+        module_function
+
+        # Print a direction header (UnitsDB → UCUM or UCUM → UnitsDB)
+        def print_direction_header(direction)
+          puts "\n=== #{direction} ===\n"
+        end
+
+        # Display results for UCUM → UnitsDB matching
+        def display_ucum_results(entity_type, matches, missing_matches,
+unmatched_ucum)
+          puts "\nResults for #{entity_type.capitalize} (UCUM → UnitsDB):"
+          puts "  Matched: #{matches.size}"
+          puts "  Missing matches (could be added): #{missing_matches.size}"
+          puts "  Unmatched UCUM entities: #{unmatched_ucum.size}"
+
+          unless unmatched_ucum.empty?
+            puts "\nUnmatched UCUM #{entity_type}:"
+            unmatched_ucum.each do |entity|
+              case entity
+              when Unitsdb::UcumPrefix
+                puts "  - #{entity.name} (#{entity.code_sensitive})"
+              when Unitsdb::UcumBaseUnit
+                puts "  - #{entity.name} (#{entity.code_sensitive}, dimension: #{entity.dimension})"
+              when Unitsdb::UcumUnit
+                name = entity.name.is_a?(Array) ? entity.name.first : entity.name
+                puts "  - #{name} (#{entity.code_sensitive}, class: #{entity.klass})"
+              else
+                puts "  - Unknown entity type"
+              end
+            end
+          end
+
+          return if missing_matches.empty?
+
+          puts "\nPotential additions (UCUM #{entity_type} that could be added to UnitsDB):"
+          missing_matches.each do |match|
+            ucum_entity = match[:ucum_entity]
+            db_entity = match[:db_entity]
+
+            # Get entity IDs and names
+            db_id = get_db_entity_id(db_entity)
+            db_name = get_db_entity_name(db_entity)
+            ucum_name = get_ucum_entity_name(ucum_entity)
+            ucum_code = ucum_entity.respond_to?(:code_sensitive) ? ucum_entity.code_sensitive : "unknown"
+
+            case ucum_entity
+            when Unitsdb::UcumPrefix
+              puts "  - UnitsDB prefix '#{db_name}' (#{db_id}) → UCUM prefix '#{ucum_name}' (#{ucum_code})"
+            when Unitsdb::UcumBaseUnit
+              puts "  - UnitsDB unit '#{db_name}' (#{db_id}) → UCUM base unit '#{ucum_name}' (#{ucum_code})"
+            when Unitsdb::UcumUnit
+              puts "  - UnitsDB unit '#{db_name}' (#{db_id}) → UCUM unit '#{ucum_name}' (#{ucum_code})"
+            end
+          end
+        end
+
+        # Display results for UnitsDB → UCUM matching
+        def display_db_results(entity_type, matches, missing_refs, unmatched_db)
+          puts "\nResults for #{entity_type.capitalize} (UnitsDB → UCUM):"
+          puts "  Matched: #{matches.size}"
+          puts "  Missing references (could be added): #{missing_refs.size}"
+          puts "  Unmatched UnitsDB entities: #{unmatched_db.size}"
+
+          unless unmatched_db.empty?
+            puts "\nUnmatched UnitsDB #{entity_type}:"
+            unmatched_db.each do |entity|
+              id = get_db_entity_id(entity)
+              name = get_db_entity_name(entity)
+              puts "  - #{name} (#{id})"
+            end
+          end
+
+          return if missing_refs.empty?
+
+          puts "\nPotential references (UCUM references that could be added to UnitsDB):"
+          missing_refs.each do |match|
+            ucum_entity = match[:ucum_entity]
+            db_entity = match[:db_entity]
+
+            # Get entity IDs and names
+            db_id = get_db_entity_id(db_entity)
+            db_name = get_db_entity_name(db_entity)
+            ucum_name = get_ucum_entity_name(ucum_entity)
+            ucum_code = ucum_entity.respond_to?(:code_sensitive) ? ucum_entity.code_sensitive : "unknown"
+
+            case ucum_entity
+            when Unitsdb::UcumPrefix
+              puts "  - UnitsDB prefix '#{db_name}' (#{db_id}) → UCUM prefix '#{ucum_name}' (#{ucum_code})"
+            when Unitsdb::UcumBaseUnit
+              puts "  - UnitsDB unit '#{db_name}' (#{db_id}) → UCUM base unit '#{ucum_name}' (#{ucum_code})"
+            when Unitsdb::UcumUnit
+              puts "  - UnitsDB unit '#{db_name}' (#{db_id}) → UCUM unit '#{ucum_name}' (#{ucum_code})"
+            end
+          end
+        end
+
+        # Helper to get db entity id
+        def get_db_entity_id(entity)
+          if entity.respond_to?(:identifiers) && entity.identifiers && !entity.identifiers.empty?
+            entity.identifiers.first.id
+          elsif entity.respond_to?(:id)
+            entity.id
+          else
+            "unknown-id"
+          end
+        end
+
+        # Helper to get db entity name
+        def get_db_entity_name(entity)
+          if entity.respond_to?(:names) && entity.names && !entity.names.empty?
+            entity.names.first.value
+          elsif entity.respond_to?(:short) && entity.short
+            entity.short
+          elsif entity.respond_to?(:name)
+            entity.name
+          else
+            "unknown-name"
+          end
+        end
+
+        # Helper to get ucum entity name
+        def get_ucum_entity_name(entity)
+          case entity
+          when Unitsdb::UcumPrefix, Unitsdb::UcumBaseUnit
+            entity.name
+          when Unitsdb::UcumUnit
+            entity.name.is_a?(Array) ? entity.name.first : entity.name
+          else
+            "unknown-name"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+module Unitsdb
+  module Commands
+    module Ucum
+      # Matcher for UCUM and UnitsDB entities
+      module Matcher
+        module_function
+
+        # Match UCUM entities to UnitsDB entities (UCUM → UnitsDB)
+        def match_ucum_to_db(entity_type, ucum_entities, db_entities)
+          puts "Matching UCUM #{entity_type} to UnitsDB #{entity_type}..."
+
+          # Initialize result arrays
+          matches = []
+          missing_matches = []
+          unmatched_ucum = []
+
+          # Process each UCUM entity
+          ucum_entities.each do |ucum_entity|
+            match_data = find_db_match_for_ucum(ucum_entity, db_entities,
+                                                entity_type)
+
+            if match_data[:match]
+              matches << { ucum_entity: ucum_entity,
+                           db_entity: match_data[:match] }
+            elsif match_data[:potential_match]
+              missing_matches << { ucum_entity: ucum_entity,
+                                   db_entity: match_data[:potential_match] }
+            else
+              unmatched_ucum << ucum_entity
+            end
+          end
+
+          [matches, missing_matches, unmatched_ucum]
+        end
+
+        # Match UnitsDB entities to UCUM entities (UnitsDB → UCUM)
+        def match_db_to_ucum(entity_type, ucum_entities, db_entities)
+          puts "Matching UnitsDB #{entity_type} to UCUM #{entity_type}..."
+
+          # Initialize result arrays
+          matches = []
+          missing_refs = []
+          unmatched_db = []
+
+          # Process each UnitsDB entity
+          db_entities.send(entity_type).each do |db_entity|
+            # Skip entities that already have UCUM references
+            if has_ucum_reference?(db_entity)
+              matches << { db_entity: db_entity,
+                           ucum_entity: find_referenced_ucum_entity(db_entity,
+                                                                    ucum_entities) }
+              next
+            end
+
+            match_data = find_ucum_match_for_db(db_entity, ucum_entities,
+                                                entity_type)
+
+            if match_data[:match]
+              missing_refs << { db_entity: db_entity,
+                                ucum_entity: match_data[:match] }
+            else
+              unmatched_db << db_entity
+            end
+          end
+
+          [matches, missing_refs, unmatched_db]
+        end
+
+        # Check if a UnitsDB entity already has a UCUM reference
+        def has_ucum_reference?(entity)
+          return false unless entity.respond_to?(:references) && entity.references
+
+          entity.references.any? { |ref| ref.authority == "ucum" }
+        end
+
+        # Find the referenced UCUM entity based on the reference URI
+        def find_referenced_ucum_entity(db_entity, ucum_entities)
+          return nil unless db_entity.respond_to?(:references) && db_entity.references
+
+          ucum_ref = db_entity.references.find { |ref| ref.authority == "ucum" }
+          return nil unless ucum_ref
+
+          ref_uri = ucum_ref.uri
+          ucum_entities.find { |ucum_entity| ucum_entity.identifier == ref_uri }
+        end
+
+        # Get the ID of a UnitsDB entity
+        def get_entity_id(entity)
+          entity.respond_to?(:id) ? entity.id : nil
+        end
+
+        # Find a matching UnitsDB entity for a UCUM entity
+        def find_db_match_for_ucum(ucum_entity, db_entities, entity_type)
+          result = { match: nil, potential_match: nil }
+
+          # Different matching logic based on entity type
+          case entity_type
+          when "prefixes"
+            result = match_prefix_ucum_to_db(ucum_entity, db_entities)
+          when "units"
+            result = match_unit_ucum_to_db(ucum_entity, db_entities)
+          end
+
+          result
+        end
+
+        # Find a matching UCUM entity for a UnitsDB entity
+        def find_ucum_match_for_db(db_entity, ucum_entities, entity_type)
+          result = { match: nil }
+
+          # Different matching logic based on entity type
+          case entity_type
+          when "prefixes"
+            result = match_prefix_db_to_ucum(db_entity, ucum_entities)
+          when "units"
+            result = match_unit_db_to_ucum(db_entity, ucum_entities)
+          end
+
+          result
+        end
+
+        # Match UCUM prefix to UnitsDB prefix
+        def match_prefix_ucum_to_db(ucum_prefix, db_prefixes)
+          result = { match: nil, potential_match: nil }
+
+          # Try exact name match first
+          name_match = db_prefixes.find do |db_prefix|
+            db_prefix.names&.any? do |name_obj|
+              name_obj.value.downcase == ucum_prefix.name.downcase
+            end
+          end
+
+          if name_match
+            result[:match] = name_match
+            return result
+          end
+
+          # Try symbol match
+          symbol_match = db_prefixes.find do |db_prefix|
+            db_prefix.symbols&.any? do |symbol|
+              symbol.ascii == ucum_prefix.print_symbol ||
+                symbol.unicode == ucum_prefix.print_symbol
+            end
+          end
+
+          if symbol_match
+            result[:match] = symbol_match
+            return result
+          end
+
+          # Try value match if available (using base^power)
+          if ucum_prefix.value&.value
+            value_match = db_prefixes.find do |db_prefix|
+              if db_prefix.base && db_prefix.power
+                calculated_value = db_prefix.base**db_prefix.power
+                calculated_value.to_s == ucum_prefix.value.value
+              else
+                false
+              end
+            end
+
+            result[:potential_match] = value_match if value_match
+          end
+
+          result
+        end
+
+        # Match UnitsDB prefix to UCUM prefix
+        def match_prefix_db_to_ucum(db_prefix, ucum_prefixes)
+          result = { match: nil }
+
+          # Try exact name match first
+          if db_prefix.names && !db_prefix.names.empty?
+            db_prefix_names = db_prefix.names.map do |name_obj|
+              name_obj.value.downcase
+            end
+
+            name_match = ucum_prefixes.find do |ucum_prefix|
+              db_prefix_names.include?(ucum_prefix.name.downcase)
+            end
+
+            if name_match
+              result[:match] = name_match
+              return result
+            end
+          end
+
+          # Try symbol match
+          if db_prefix.symbols && !db_prefix.symbols.empty?
+            symbol_match = ucum_prefixes.find do |ucum_prefix|
+              db_prefix.symbols.any? do |symbol|
+                ucum_prefix.print_symbol == symbol.ascii ||
+                  ucum_prefix.print_symbol == symbol.unicode
+              end
+            end
+
+            result[:match] = symbol_match if symbol_match
+          end
+
+          result
+        end
+
+        # Match UCUM unit to UnitsDB unit
+        def match_unit_ucum_to_db(ucum_unit, db_units)
+          result = { match: nil, potential_match: nil }
+
+          # Get UCUM unit name(s)
+          ucum_names = case ucum_unit
+                       when Unitsdb::UcumBaseUnit
+                         [ucum_unit.name]
+                       when Unitsdb::UcumUnit
+                         ucum_unit.name.is_a?(Array) ? ucum_unit.name : [ucum_unit.name]
+                       else
+                         []
+                       end
+
+          # Try name match
+          ucum_names.each do |ucum_name|
+            name_match = db_units.find do |db_unit|
+              db_unit.names&.any? do |name_obj|
+                name_obj.value.downcase == ucum_name.downcase
+              end
+            end
+
+            if name_match
+              result[:match] = name_match
+              return result
+            end
+          end
+
+          # Try symbol match
+          symbol_match = db_units.find do |db_unit|
+            db_unit.symbols&.any? do |symbol|
+              symbol.ascii == ucum_unit.print_symbol ||
+                symbol.unicode == ucum_unit.print_symbol
+            end
+          end
+
+          if symbol_match
+            result[:match] = symbol_match
+            return result
+          end
+
+          # Try property/dimension match for potential matches
+          property = case ucum_unit
+                     when Unitsdb::UcumBaseUnit
+                       ucum_unit.property
+                     when Unitsdb::UcumUnit
+                       ucum_unit.property
+                     end
+
+          if property
+            property_matches = db_units.select do |db_unit|
+              db_unit.quantity_references&.any? do |qref|
+                qref.id&.downcase&.include?(property.downcase)
+              end
+            end
+
+            if property_matches.any?
+              result[:potential_match] =
+                property_matches.first
+            end
+          end
+
+          result
+        end
+
+        # Match UnitsDB unit to UCUM unit
+        def match_unit_db_to_ucum(db_unit, ucum_units)
+          result = { match: nil }
+
+          # Try name match first
+          if db_unit.names && !db_unit.names.empty?
+            db_unit_names = db_unit.names.map do |name_obj|
+              name_obj.value.downcase
+            end
+
+            name_match = ucum_units.find do |ucum_unit|
+              case ucum_unit
+              when Unitsdb::UcumBaseUnit
+                db_unit_names.include?(ucum_unit.name.downcase)
+              when Unitsdb::UcumUnit
+                ucum_names = ucum_unit.name.is_a?(Array) ? ucum_unit.name : [ucum_unit.name]
+                ucum_names.any? { |name| db_unit_names.include?(name.downcase) }
+              else
+                false
+              end
+            end
+
+            if name_match
+              result[:match] = name_match
+              return result
+            end
+          end
+
+          # Try symbol match
+          if db_unit.symbols && !db_unit.symbols.empty?
+            symbol_match = ucum_units.find do |ucum_unit|
+              db_unit.symbols.any? do |symbol|
+                ucum_unit.print_symbol == symbol.ascii ||
+                  ucum_unit.print_symbol == symbol.unicode
+              end
+            end
+
+            result[:match] = symbol_match if symbol_match
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Unitsdb
+  module Commands
+    module Ucum
+      # Command to update UnitsDB with UCUM references
+      class Update < Base
+        # Constants
+        ENTITY_TYPES = %w[units prefixes].freeze
+
+        def run
+          # Get options
+          entity_type = @options[:entity_type]&.downcase
+          database_path = @options[:database]
+          ucum_file = @options[:ucum_file]
+          output_dir = @options[:output_dir] || database_path
+          include_potential = @options[:include_potential_matches] || false
+
+          # Validate database path
+          unless File.exist?(database_path) && Dir.exist?(database_path)
+            puts "Database directory path: #{database_path}"
+            puts "ERROR: Database directory not found: #{database_path}"
+            return 1
+          end
+          puts "Using database directory: #{database_path}"
+
+          # Validate UCUM file
+          unless File.exist?(ucum_file)
+            puts "ERROR: UCUM file not found: #{ucum_file}"
+            return 1
+          end
+          puts "Using UCUM file: #{ucum_file}"
+          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)
+          else
+            ENTITY_TYPES.each do |type|
+              process_entity_type(type, ucum_data, output_dir,
+                                  include_potential)
+            end
+          end
+
+          0
+        end
+
+        private
+
+        def process_entity_type(entity_type, ucum_data, output_dir,
+include_potential)
+          puts "\n========== Processing #{entity_type.upcase} References =========="
+
+          # Get entities
+          klass = Unitsdb.const_get(entity_type.capitalize)
+          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)
+
+          return if ucum_entities.nil? || ucum_entities.empty?
+
+          # Match entities
+          _, 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)
+
+          # 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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Unitsdb
+  module Commands
+    module Ucum
+      # Updater for adding UCUM references to UnitsDB entities
+      module Updater
+        UCUM_AUTHORITY = "ucum"
+
+        module_function
+
+        # Update references in UnitsDB entities with UCUM references
+        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
+          entity_references = {}
+
+          # Process each match
+          matches.each do |match|
+            db_entity = match[:db_entity]
+            ucum_entity = match[:ucum_entity]
+
+            # Skip potential matches unless specified
+            next if match[:potential] && !include_potential
+
+            # Get entity ID
+            entity_id = get_entity_id(db_entity)
+            next unless entity_id
+
+            # Initialize references for this entity
+            entity_references[entity_id] = ExternalReference.new(
+              uri: ucum_entity.identifier,
+              type: "informative",
+              authority: UCUM_AUTHORITY,
+            )
+          end
+
+          # Update the YAML content
+          db_entities.send(entity_type).each do |entity|
+            # Find entity by ID
+            entity_id = if entity.identifiers
+                          begin
+                            entity.identifiers.first.id
+                          rescue StandardError
+                            nil
+                          end
+                        end
+
+            next unless entity_id && entity_references.key?(entity_id)
+
+            # Initialize references array if it doesn't exist
+            entity.references ||= []
+
+            # Add new references
+            if (ext_ref = entity_references[entity_id])
+              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
+                # Add the reference
+                puts "Adding reference for entity ID: #{entity_id}, URI: #{ext_ref.uri}, Authority: #{ext_ref.authority}"
+                entity.references << ext_ref
+              end
+            end
+          end
+
+          # Write to YAML file
+          write_yaml_file(output_file, db_entities)
+
+          puts "Added #{entity_references.values.flatten.size} UCUM references to #{entity_type}"
+        end
+
+        # Helper to write YAML file
+        def write_yaml_file(output_file, output_data)
+          # Ensure the output directory exists
+          output_dir = File.dirname(output_file)
+          FileUtils.mkdir_p(output_dir)
+
+          # 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)
+        def get_entity_id(entity)
+          if entity.respond_to?(:identifiers) && entity.identifiers && !entity.identifiers.empty?
+            entity.identifiers.first.id
+          elsif entity.respond_to?(:id)
+            entity.id
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Unitsdb
+  module Commands
+    module Ucum
+      # Parser for UCUM XML files
+      module XmlParser
+        module_function
+
+        # Parse UCUM XML file and return parsed data
+        def parse_ucum_file(file_path)
+          puts "Parsing UCUM XML file: #{file_path}..."
+          content = File.read(file_path)
+          Unitsdb::UcumFile.from_xml(content)
+        end
+
+        # Get entities from parsed UCUM data based on entity type
+        def get_entities_from_ucum(entity_type, ucum_data)
+          case entity_type
+          when "prefixes"
+            ucum_data.prefixes
+          when "units"
+            # Combine base-units and units into a single array
+            ucum_data.base_units + ucum_data.units
+          else
+            []
+          end
+        end
+      end
+    end
+  end
+end