unitsdb 2.0.1 → 2.1.0

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

@@ -1,301 +0,0 @@
-# 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

@@ -1,84 +0,0 @@
-# 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

@@ -1,98 +0,0 @@
-# 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

@@ -1,34 +0,0 @@
-# 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

@@ -1,43 +0,0 @@
-# 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