unitsdb 0.1.1 → 2.0.1

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

@@ -0,0 +1,301 @@
+# 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 { |name_obj| name_obj.value.downcase }
+
+            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
+
+            result[:potential_match] = property_matches.first if property_matches.any?
+          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 { |name_obj| name_obj.value.downcase }
+
+            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,84 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+require_relative "../../database"
+require_relative "xml_parser"
+require_relative "matcher"
+require_relative "updater"
+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) unless Dir.exist?(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,98 @@
+# 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 { |ref| ref.uri == ext_ref.uri && ref.authority == ext_ref.authority }
+                # 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) unless Dir.exist?(output_dir)
+
+          # Write to YAML file
+          File.write(output_file, output_data.to_yaml)
+        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,34 @@
+# frozen_string_literal: true
+
+require_relative "../../ucum"
+
+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

data/lib/unitsdb/commands/ucum.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Unitsdb
+  module Commands
+    class UcumCommand < Thor
+      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
+        require_relative "ucum/check"
+        Ucum::Check.new(options).run
+      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
+        require_relative "ucum/update"
+        Ucum::Update.new(options).run
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Unitsdb
+  module Commands
+    module Validate
+      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)
+        end
+
+        private
+
+        def display_results(all_dups)
+          %i[short id].each do |type|
+            dups = all_dups[type]
+            if dups.empty?
+              puts "No duplicate '#{type}' fields found."
+              next
+            end
+
+            puts "\nFound duplicate '#{type}' fields:"
+            dups.each do |file, items|
+              puts "  #{file}:"
+              items.each do |val, paths|
+                puts "    '#{val}':"
+                paths.each { |p| puts "      - #{p}" }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end