unitsdb 0.1.1 → 2.0.1

data/lib/unitsdb/commands/si_updater.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Unitsdb
+  module Commands
+    # Updater for SI references in YAML
+    module SiUpdater
+      SI_AUTHORITY = "si-digital-framework"
+
+      module_function
+
+      # Update references in YAML file (TTL → DB direction)
+      def update_references(entity_type, missing_matches, db_entities, output_file, include_potential = false)
+        # Use the database objects to access the data directly
+        original_yaml_file = db_entities.first.send(:yaml_file) if db_entities&.first.respond_to?(:yaml_file, true)
+
+        # If we can't get the path from the database object, use the output file path as a fallback
+        if original_yaml_file.nil? || !File.exist?(original_yaml_file)
+          puts "Warning: Could not determine original YAML file path. Using output file as template."
+          original_yaml_file = output_file
+
+          # Create an empty template if output file doesn't exist
+          unless File.exist?(original_yaml_file)
+            FileUtils.mkdir_p(File.dirname(original_yaml_file))
+            File.write(original_yaml_file, { entity_type => [] }.to_yaml)
+          end
+        end
+
+        # Load the original YAML file
+        yaml_content = File.read(original_yaml_file)
+        output_data = YAML.safe_load(yaml_content)
+
+        # Group by entity ID to avoid duplicates
+        grouped_matches = missing_matches.group_by { |match| match[:entity_id] }
+
+        # Process each entity that needs updating
+        grouped_matches.each do |entity_id, matches|
+          # Filter matches based on include_potential parameter
+          filtered_matches = matches.select do |match|
+            # Check if it's an exact match or if we're including potential matches
+            match_details = match[:match_details]
+            if match_details&.dig(:exact) == false || %w[symbol_match
+                                                         partial_match].include?(match_details&.dig(:match_desc) || "")
+              include_potential
+            else
+              true
+            end
+          end
+
+          # Skip if no matches after filtering
+          next if filtered_matches.empty?
+
+          # Find the entity in the array under the entity_type key
+          entity_index = output_data[entity_type].find_index do |e|
+            # Find entity with matching identifier
+            e["identifiers"]&.any? { |id| id["id"] == entity_id }
+          end
+
+          next unless entity_index
+
+          # Get the entity
+          entity = output_data[entity_type][entity_index]
+
+          # Initialize references array if it doesn't exist
+          entity["references"] ||= []
+
+          # Add new references
+          filtered_matches.each do |match|
+            # If this match has multiple SI references, add them all
+            if match[:multiple_si]
+              match[:multiple_si].each do |si_data|
+                # Check if reference already exists
+                next if entity["references"].any? do |ref|
+                  ref["uri"] == si_data[:uri] && ref["authority"] == SI_AUTHORITY
+                end
+
+                # Add new reference
+                entity["references"] << {
+                  "uri" => si_data[:uri],
+                  "type" => "normative",
+                  "authority" => SI_AUTHORITY
+                }
+              end
+            else
+              # Check if reference already exists
+              next if entity["references"].any? do |ref|
+                ref["uri"] == match[:si_uri] && ref["authority"] == SI_AUTHORITY
+              end
+
+              # Add new reference
+              entity["references"] << {
+                "uri" => match[:si_uri],
+                "type" => "normative",
+                "authority" => SI_AUTHORITY
+              }
+            end
+          end
+        end
+
+        write_yaml_file(output_file, output_data)
+      end
+
+      # Update references in YAML file (DB → TTL direction)
+      def update_db_references(entity_type, missing_refs, output_file, include_potential = false)
+        # Try to get the original YAML file from the first entity
+        first_entity = missing_refs.first&.dig(:db_entity)
+        original_yaml_file = first_entity.send(:yaml_file) if first_entity.respond_to?(:yaml_file, true)
+
+        # If we can't get the path from the database object, use the output file path as a fallback
+        if original_yaml_file.nil? || !File.exist?(original_yaml_file)
+          puts "Warning: Could not determine original YAML file path. Using output file as template."
+          original_yaml_file = output_file
+
+          # Create an empty template if output file doesn't exist
+          unless File.exist?(original_yaml_file)
+            FileUtils.mkdir_p(File.dirname(original_yaml_file))
+            File.write(original_yaml_file, { entity_type => [] }.to_yaml)
+          end
+        end
+
+        # Load the original YAML file
+        yaml_content = File.read(original_yaml_file)
+        output_data = YAML.safe_load(yaml_content)
+
+        # Group by entity ID to avoid duplicates
+        missing_refs_by_id = {}
+
+        missing_refs.each do |match|
+          entity_id = match[:entity_id] || match[:db_entity].short
+          ttl_entities = match[:ttl_entities]
+          match_types = match[:match_types] || {}
+
+          # Filter TTL entities based on include_potential parameter
+          filtered_ttl_entities = ttl_entities.select do |ttl_entity|
+            # Check if it's an exact match or if we're including potential matches
+            match_type = match_types[ttl_entity[:uri]] || "Exact match" # Default to exact match
+            match_pair_key = "#{entity_id}:#{ttl_entity[:uri]}"
+            match_details = Unitsdb::Commands::SiMatcher.instance_variable_get(:@match_details)&.dig(match_pair_key)
+
+            if match_details && %w[symbol_match partial_match].include?(match_details[:match_desc])
+              include_potential
+            else
+              match_type == "Exact match" || include_potential
+            end
+          end
+
+          # Skip if no entities after filtering
+          next if filtered_ttl_entities.empty?
+
+          missing_refs_by_id[entity_id] ||= []
+
+          # Add filtered matching TTL entities for this DB entity
+          filtered_ttl_entities.each do |ttl_entity|
+            missing_refs_by_id[entity_id] << {
+              uri: ttl_entity[:uri],
+              type: "normative",
+              authority: SI_AUTHORITY
+            }
+          end
+        end
+
+        # Update the YAML content
+        output_data[entity_type].each do |entity_yaml|
+          # Find entity by ID or short
+          entity_id = if entity_yaml["identifiers"]
+                        begin
+                          entity_yaml["identifiers"].first["id"]
+                        rescue StandardError
+                          nil
+                        end
+                      elsif entity_yaml["id"]
+                        entity_yaml["id"]
+                      end
+
+          next unless entity_id && missing_refs_by_id.key?(entity_id)
+
+          # Add references
+          entity_yaml["references"] ||= []
+
+          missing_refs_by_id[entity_id].each do |ref|
+            # Check if this reference already exists
+            next if entity_yaml["references"].any? do |existing_ref|
+              existing_ref["uri"] == ref[:uri] &&
+              existing_ref["authority"] == ref[:authority]
+            end
+
+            # Add the reference
+            entity_yaml["references"] << {
+              "uri" => ref[:uri],
+              "type" => ref[:type],
+              "authority" => ref[:authority]
+            }
+          end
+        end
+
+        write_yaml_file(output_file, output_data)
+      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
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+require_relative "../../database"
+require_relative "../../errors"
+require_relative "xml_parser"
+require_relative "formatter"
+require_relative "matcher"
+require_relative "updater"
+require "fileutils"
+
+module Unitsdb
+  module Commands
+    module Ucum
+      class Check < Base
+        # Constants
+        ENTITY_TYPES = %w[units prefixes].freeze
+
+        def run
+          # Get options
+          entity_type = @options[:entity_type]&.downcase
+          direction = @options[:direction]&.downcase || "both"
+          output_dir = @options[:output_updated_database]
+          include_potential = @options[:include_potential_matches] || false
+          database_path = @options[:database]
+          ucum_file = @options[:ucum_file]
+
+          # Validate parameters
+          validate_parameters(direction, ucum_file)
+
+          # Use the path as-is without expansion
+          puts "Using database directory: #{database_path}"
+
+          @db = Unitsdb::Database.from_db(database_path)
+
+          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
+          process_entities(entity_type, ucum_data, direction, output_dir, include_potential)
+        end
+
+        private
+
+        # Process all entity types or a specific one
+        def process_entities(entity_type, ucum_data, direction, output_dir, include_potential)
+          if entity_type && ENTITY_TYPES.include?(entity_type)
+            process_entity_type(entity_type, ucum_data, direction, output_dir, include_potential)
+          else
+            ENTITY_TYPES.each do |type|
+              process_entity_type(type, ucum_data, direction, output_dir, include_potential)
+            end
+          end
+        end
+
+        # Process a specific entity type
+        def process_entity_type(entity_type, ucum_data, direction, output_dir, include_potential = false)
+          puts "\n========== Processing #{entity_type.upcase} References ==========\n"
+
+          db_entities = @db.send(entity_type)
+          ucum_entities = XmlParser.get_entities_from_ucum(entity_type, ucum_data)
+
+          puts "Found #{ucum_entities.size} #{entity_type} in UCUM"
+          puts "Found #{db_entities.size} #{entity_type} in database"
+
+          check_from_ucum(entity_type, ucum_entities, db_entities, output_dir, include_potential) if %w[from_ucum
+                                                                                                        both].include?(direction)
+
+          return unless %w[to_ucum both].include?(direction)
+
+          check_to_ucum(entity_type, ucum_entities, db_entities, output_dir, include_potential)
+        end
+
+        # Validation helpers
+        def validate_parameters(direction, ucum_file)
+          unless %w[to_ucum from_ucum both].include?(direction)
+            puts "Invalid direction: #{direction}. Must be one of: to_ucum, from_ucum, both"
+            exit(1)
+          end
+
+          return if File.exist?(ucum_file)
+
+          puts "UCUM file not found: #{ucum_file}"
+          exit(1)
+        end
+
+        # Direction handler: UCUM → UnitsDB
+        def check_from_ucum(entity_type, ucum_entities, db_entities, output_dir, include_potential = false)
+          Formatter.print_direction_header("UCUM → UnitsDB")
+
+          matches, missing_matches, unmatched_ucum = Matcher.match_ucum_to_db(entity_type, ucum_entities, db_entities)
+
+          # Print results
+          Formatter.display_ucum_results(entity_type, matches, missing_matches, unmatched_ucum)
+
+          # Update references if needed
+          return unless output_dir && !missing_matches.empty?
+
+          output_file = File.join(output_dir, "#{entity_type}.yaml")
+          Updater.update_references(entity_type, missing_matches, db_entities, output_file, include_potential)
+          puts "\nUpdated references written to #{output_file}"
+        end
+
+        # Direction handler: UnitsDB → UCUM
+        def check_to_ucum(entity_type, ucum_entities, db_entities, output_dir, include_potential = false)
+          Formatter.print_direction_header("UnitsDB → UCUM")
+
+          matches, missing_refs, unmatched_db = Matcher.match_db_to_ucum(entity_type, ucum_entities, db_entities)
+
+          # Print results
+          Formatter.display_db_results(entity_type, matches, missing_refs, unmatched_db)
+
+          # Update references if needed
+          return unless output_dir && !missing_refs.empty?
+
+          output_file = File.join(output_dir, "#{entity_type}.yaml")
+          Updater.update_references(entity_type, missing_refs, db_entities, output_file, include_potential)
+          puts "\nUpdated references written to #{output_file}"
+        end
+      end
+    end
+  end
+end

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

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