unitsdb 2.1.1 → 2.2.2

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

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "fileutils"
+
+module Unitsdb
+  module Commands
+    module Qudt
+      # Updater for adding QUDT references to UnitsDB entities
+      module Updater
+        QUDT_AUTHORITY = "qudt"
+
+        module_function
+
+        # Update references in UnitsDB entities with QUDT references
+        def update_references(entity_type, matches, db_entities, output_file,
+include_potential = false)
+          puts "Updating QUDT references for #{entity_type}..."
+
+          # Get the original YAML file path from the database entities
+          original_yaml_file = get_original_yaml_file(db_entities, output_file)
+
+          # Load the original YAML file as plain data structures
+          yaml_content = File.read(original_yaml_file)
+          output_data = YAML.safe_load(yaml_content)
+
+          # Create a map of entity IDs to their QUDT references
+          entity_references = {}
+
+          # Process each match
+          matches.each do |match|
+            db_entity = match[:db_entity]
+            qudt_entity = match[:qudt_entity]
+
+            # Skip potential matches unless specified
+            next if match[:potential] && !include_potential
+
+            # Skip if entity has been manually verified
+            if manually_verified?(db_entity)
+              puts "Skipping manually verified entity: #{get_entity_id(db_entity)}"
+              next
+            end
+
+            # Get entity ID
+            entity_id = get_entity_id(db_entity)
+            next unless entity_id
+
+            # Store reference data as plain hash
+            entity_references[entity_id] = {
+              "uri" => qudt_entity.uri,
+              "type" => "informative",
+              "authority" => QUDT_AUTHORITY,
+            }
+          end
+
+          # Update the YAML content
+          output_data[entity_type].each do |entity_yaml|
+            # Find entity by ID
+            entity_id = if entity_yaml["identifiers"]
+                          begin
+                            entity_yaml["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_yaml["references"] ||= []
+
+            # Add new references
+            if (ext_ref = entity_references[entity_id])
+              if entity_yaml["references"].any? 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_yaml["references"] << ext_ref
+              end
+            end
+          end
+
+          # Write to YAML file
+          write_yaml_file(output_file, output_data)
+
+          puts "Added #{entity_references.values.size} QUDT 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 the original YAML file path
+        def get_original_yaml_file(_db_entities, output_file)
+          # The database path should be available from the update command
+          # We need to construct the path to the original YAML file
+          entity_type = File.basename(output_file, ".yaml")
+
+          # Try to find the original file in the database directory
+          # Look for it relative to where we expect it to be
+          # nil
+
+          # Try to get database directory from environment or assume it's the fixtures
+          database_dir = ENV["UNITSDB_DATABASE_PATH"] ||
+            File.join(File.dirname(__FILE__),
+                      "../../../data")
+
+          original_yaml_file = File.join(database_dir, "#{entity_type}.yaml")
+
+          # If that doesn't exist, try to find it relative to the current working directory
+          unless File.exist?(original_yaml_file)
+            original_yaml_file = File.join("data",
+                                           "#{entity_type}.yaml")
+          end
+
+          # If still not found, create a fallback
+          unless File.exist?(original_yaml_file)
+            puts "Warning: Could not find original YAML file. Creating empty template."
+            original_yaml_file = output_file
+            FileUtils.mkdir_p(File.dirname(original_yaml_file))
+            File.write(original_yaml_file, { entity_type => [] }.to_yaml)
+          end
+
+          puts "Using original YAML file: #{original_yaml_file}"
+          original_yaml_file
+        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
+
+        # Check if an entity has been manually verified (has a special flag)
+        def manually_verified?(entity)
+          return false unless entity.respond_to?(:references) && entity.references
+
+          entity.references.any? do |ref|
+            ref.authority == QUDT_AUTHORITY && ref.respond_to?(:verified) && ref.verified
+          end
+        end
+      end
+    end
+  end
+end

data/lib/unitsdb/commands/qudt.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Unitsdb
+  module Commands
+    module Qudt
+      autoload :Check, "unitsdb/commands/qudt/check"
+      autoload :Formatter, "unitsdb/commands/qudt/formatter"
+      autoload :TtlParser, "unitsdb/commands/qudt/ttl_parser"
+      autoload :Update, "unitsdb/commands/qudt/update"
+      autoload :Updater, "unitsdb/commands/qudt/updater"
+    end
+
+    class QudtCommand < Thor
+      # Inherit trace option from parent CLI
+      class_option :trace, type: :boolean, default: false,
+                           desc: "Show full backtrace on error"
+
+      desc "check", "Check QUDT references in UnitsDB"
+      option :entity_type, type: :string, aliases: "-e",
+                           desc: "Entity type to check (units, quantities, dimensions, unit_systems). If not specified, all types are checked"
+      option :ttl_dir, type: :string, aliases: "-t",
+                       desc: "Path to directory containing QUDT TTL files. If not specified, vocabularies will be downloaded from online sources"
+      option :output_updated_database, type: :string, aliases: "-o",
+                                       desc: "Directory path to write updated YAML files with added QUDT references"
+      option :direction, type: :string, default: "both", aliases: "-r",
+                         desc: "Direction to check: 'to_qudt' (UnitsDB→QUDT), 'from_qudt' (QUDT→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
+        run_command(Qudt::Check, options)
+      end
+
+      desc "update", "Update UnitsDB with QUDT references"
+      option :entity_type, type: :string, aliases: "-e",
+                           desc: "Entity type to update (units, quantities, dimensions, unit_systems). If not specified, all types are updated"
+      option :ttl_dir, type: :string, aliases: "-t",
+                       desc: "Path to directory containing QUDT TTL files. If not specified, vocabularies will be downloaded from online sources"
+      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
+        run_command(Qudt::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
+end

data/lib/unitsdb/commands/release.rb

@@ -26,29 +26,30 @@ module Unitsdb
           create_unified_yaml(db)
           create_zip_archive(db)
         else
-          puts "Invalid format option: #{@options[:format]}"
-          puts "Valid options are: 'yaml', 'zip', or 'all'"
-          exit(1)
+          raise Unitsdb::Errors::InvalidFormatError,
+                "Invalid format '#{@options[:format]}': must be 'yaml', 'zip', or 'all'"
         end
 
         puts "Release files created successfully in #{@options[:output_dir]}"
       rescue Unitsdb::Errors::DatabaseError => e
-        puts "Error: #{e.message}"
-        exit(1)
+        raise Unitsdb::Errors::DatabaseLoadError,
+              "Failed to create release: #{e.message}"
       end
 
       private
 
       def create_unified_yaml(db)
         # Create a unified YAML file with all database components
-        output_path = File.join(@options[:output_dir], "unitsdb-#{@options[:version]}.yaml")
+        output_path = File.join(@options[:output_dir],
+                                "unitsdb-#{@options[:version]}.yaml")
         File.write(output_path, db.to_yaml)
         puts "Created unified YAML file: #{output_path}"
       end
 
       def create_zip_archive(db)
         # Create a ZIP archive with individual YAML files
-        output_path = File.join(@options[:output_dir], "unitsdb-#{@options[:version]}.zip")
+        output_path = File.join(@options[:output_dir],
+                                "unitsdb-#{@options[:version]}.zip")
 
         Zip::File.open(output_path, Zip::File::CREATE) do |zipfile|
           {
@@ -56,12 +57,14 @@ module Unitsdb
             unit_systems: Unitsdb::UnitSystems,
             units: Unitsdb::Units,
             prefixes: Unitsdb::Prefixes,
-            quantities: Unitsdb::Quantities
+            quantities: Unitsdb::Quantities,
           }.each_pair do |access_method, collection_klass|
             db.send(access_method).tap do |data|
               collection = collection_klass.new(access_method => data)
               collection.version = @options[:version]
-              zipfile.get_output_stream("#{access_method}.yaml") { |f| f.write(collection.to_yaml) }
+              zipfile.get_output_stream("#{access_method}.yaml") do |f|
+                f.write(collection.to_yaml)
+              end
             end
           end
         end

data/lib/unitsdb/commands/search.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "base"
 require "json"
-require_relative "../errors"
 
 module Unitsdb
   module Commands
@@ -33,8 +31,8 @@ module Unitsdb
                 puts entity.send("to_#{format.downcase}")
                 return
               rescue NoMethodError
-                puts "Error: Unable to convert entity to #{format} format"
-                exit(1)
+                raise Unitsdb::Errors::InvalidFormatError,
+                      "Unable to convert entity to #{format.upcase} format: output format not supported for this entity type"
               end
             end
 
@@ -64,11 +62,10 @@ module Unitsdb
             print_entity_with_ids(entity)
           end
         rescue Unitsdb::Errors::DatabaseError => e
-          puts "Error: #{e.message}"
-          exit(1)
+          raise Unitsdb::Errors::DatabaseLoadError,
+                "Failed to load database: #{e.message}"
         rescue StandardError => e
-          puts "Error searching database: #{e.message}"
-          exit(1)
+          raise Unitsdb::Errors::CLIRuntimeError, "Search failed: #{e.message}"
         end
       end
 
@@ -93,7 +90,7 @@ module Unitsdb
         else
           puts "    IDs:"
           identifiers.each do |id|
-            puts "      - #{id.id} (Type: #{id.type || "N/A"})"
+            puts "      - #{id.id} (Type: #{id.type || 'N/A'})"
           end
         end
 
@@ -122,7 +119,7 @@ module Unitsdb
         if entity.identifiers&.any?
           puts "  - Identifiers:"
           entity.identifiers.each do |id|
-            puts "      - #{id.id} (Type: #{id.type || "N/A"})"
+            puts "      - #{id.id} (Type: #{id.type || 'N/A'})"
           end
         else
           puts "  - Identifiers: None"
@@ -132,7 +129,11 @@ module Unitsdb
         case entity
         when Unitsdb::Unit
           puts "  - Symbols:" if entity.respond_to?(:symbols) && entity.symbols&.any?
-          entity.symbols.each { |s| puts "      - #{s}" } if entity.respond_to?(:symbols) && entity.symbols&.any?
+          if entity.respond_to?(:symbols) && entity.symbols&.any?
+            entity.symbols.each do |s|
+              puts "      - #{s}"
+            end
+          end
 
           puts "  - Definition: #{entity.definition}" if entity.respond_to?(:definition) && entity.definition
 

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

@@ -1,12 +1,5 @@
 # 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
@@ -34,90 +27,110 @@ module Unitsdb
           @db = Unitsdb::Database.from_db(database_path)
 
           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
-          process_entities(entity_type, ucum_data, direction, output_dir, include_potential)
+          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)
+        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)
+            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)
+              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)
+        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)
+          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)
+          if %w[from_ucum
+                both].include?(direction)
+            check_from_ucum(entity_type, ucum_entities, db_entities, output_dir,
+                            include_potential)
+          end
 
           return unless %w[to_ucum both].include?(direction)
 
-          check_to_ucum(entity_type, ucum_entities, db_entities, output_dir, include_potential)
+          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)
+            raise Unitsdb::Errors::InvalidParameterError,
+                  "Invalid direction '#{direction}': must be 'to_ucum', 'from_ucum', or 'both'"
           end
 
           return if File.exist?(ucum_file)
 
-          puts "UCUM file not found: #{ucum_file}"
-          exit(1)
+          raise Unitsdb::Errors::FileNotFoundError,
+                "UCUM file not found: #{ucum_file}"
         end
 
         # Direction handler: UCUM → UnitsDB
-        def check_from_ucum(entity_type, ucum_entities, db_entities, output_dir, include_potential = false)
+        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)
+          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)
+          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)
+          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)
+        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)
+          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)
+          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)
+          Updater.update_references(entity_type, missing_refs, db_entities,
+                                    output_file, include_potential)
           puts "\nUpdated references written to #{output_file}"
         end
       end

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

@@ -13,7 +13,8 @@ module Unitsdb
         end
 
         # Display results for UCUM → UnitsDB matching
-        def display_ucum_results(entity_type, matches, missing_matches, unmatched_ucum)
+        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}"

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

@@ -18,12 +18,15 @@ module Unitsdb
 
           # Process each UCUM entity
           ucum_entities.each do |ucum_entity|
-            match_data = find_db_match_for_ucum(ucum_entity, db_entities, entity_type)
+            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] }
+              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] }
+              missing_matches << { ucum_entity: ucum_entity,
+                                   db_entity: match_data[:potential_match] }
             else
               unmatched_ucum << ucum_entity
             end
@@ -45,14 +48,18 @@ module Unitsdb
           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) }
+              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)
+            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] }
+              missing_refs << { db_entity: db_entity,
+                                ucum_entity: match_data[:match] }
             else
               unmatched_db << db_entity
             end
@@ -166,7 +173,9 @@ module Unitsdb
 
           # 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 }
+            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)
@@ -249,7 +258,10 @@ module Unitsdb
               end
             end
 
-            result[:potential_match] = property_matches.first if property_matches.any?
+            if property_matches.any?
+              result[:potential_match] =
+                property_matches.first
+            end
           end
 
           result
@@ -261,7 +273,9 @@ module Unitsdb
 
           # 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 }
+            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