unitsdb 2.1.0 → 2.2.1

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

@@ -1,111 +1,75 @@
 # frozen_string_literal: true
 
-require_relative "base"
 require "yaml"
 require "zip"
 require "fileutils"
 
 module Unitsdb
   module Commands
-    class Release < Base
+    class Release < ::Unitsdb::Commands::Base
       def run
-        # Verify all required files exist
-        yaml_files = Unitsdb::Utils::DEFAULT_YAML_FILES.map { |f| File.join(@options[:database], f) }
-        missing_files = yaml_files.reject { |f| File.exist?(f) }
-
-        if missing_files.any?
-          puts "Error: The following required files are missing:"
-          missing_files.each { |f| puts "  - #{f}" }
-          exit(1)
-        end
-
-        # Extract schema version from any file (they should all have the same version)
-        first_yaml = load_yaml(yaml_files.first)
-        schema_version = first_yaml["schema_version"]
-
-        unless schema_version
-          puts "Error: Could not determine schema version from #{yaml_files.first}"
-          exit(1)
-        end
-
-        # Verify all files have the same schema version
-        inconsistent_files = []
-        yaml_files.each do |file|
-          yaml = load_yaml(file)
-          next unless yaml["schema_version"] != schema_version
-
-          inconsistent_files << {
-            file: file,
-            version: yaml["schema_version"]
-          }
-        end
-
-        if inconsistent_files.any?
-          puts "Error: Inconsistent schema versions detected:"
-          puts "  Expected version: #{schema_version}"
-          inconsistent_files.each do |info|
-            puts "  - #{info[:file]}: #{info[:version]}"
-          end
-          exit(1)
-        end
+        # Load the database
+        db = load_database(@options[:database])
+        db.version = @options[:version]
 
         # Create output directory if it doesn't exist
-        output_dir = @options[:output_dir] || "."
-        FileUtils.mkdir_p(output_dir) unless Dir.exist?(output_dir)
-
-        # Generate outputs based on format option
-        format = @options[:format] || "all"
-
-        case format.downcase
-        when "yaml", "all"
-          create_unified_yaml(yaml_files, schema_version, output_dir)
-        end
-
-        case format.downcase
-        when "zip", "all"
-          create_zip_archive(yaml_files, schema_version, output_dir)
+        FileUtils.mkdir_p(@options[:output_dir])
+
+        # Generate release files based on format option
+        format = (@options[:format] || "all").downcase
+        case format
+        when "yaml"
+          create_unified_yaml(db)
+        when "zip"
+          create_zip_archive(db)
+        when "all"
+          create_unified_yaml(db)
+          create_zip_archive(db)
+        else
+          raise Unitsdb::Errors::InvalidFormatError,
+                "Invalid format '#{@options[:format]}': must be 'yaml', 'zip', or 'all'"
         end
 
-        puts "Release files created successfully in #{output_dir}"
+        puts "Release files created successfully in #{@options[:output_dir]}"
+      rescue Unitsdb::Errors::DatabaseError => e
+        raise Unitsdb::Errors::DatabaseLoadError,
+              "Failed to create release: #{e.message}"
       end
 
       private
 
-      def create_unified_yaml(yaml_files, schema_version, output_dir)
-        # Create a unified YAML structure
-        unified_yaml = { "schema_version" => schema_version }
-
-        # Load each YAML file and add its collection to the unified structure
-        yaml_files.each do |file|
-          yaml = load_yaml(file)
-          # Get the collection key (units, scales, etc.) - it's the key that's not schema_version
-          collection_key = (yaml.keys - ["schema_version"]).first
-          if collection_key
-            # Add the collection to the unified structure
-            unified_yaml[collection_key] = yaml[collection_key]
-          end
-        end
-
-        # Write the unified YAML to a file
-        output_file = File.join(output_dir, "unitsdb-#{schema_version}.yaml")
-        File.write(output_file, unified_yaml.to_yaml)
-        puts "Created unified YAML file: #{output_file}"
+      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")
+        File.write(output_path, db.to_yaml)
+        puts "Created unified YAML file: #{output_path}"
       end
 
-      def create_zip_archive(yaml_files, schema_version, output_dir)
-        # Create a ZIP archive containing all YAML files
-        output_file = File.join(output_dir, "unitsdb-#{schema_version}.zip")
-
-        Zip::File.open(output_file, Zip::File::CREATE) do |zipfile|
-          yaml_files.each do |file|
-            # Get the filename without the path
-            filename = File.basename(file)
-            # Add the file to the ZIP archive
-            zipfile.add(filename, file)
+      def create_zip_archive(db)
+        # Create a ZIP archive with individual YAML files
+        output_path = File.join(@options[:output_dir],
+                                "unitsdb-#{@options[:version]}.zip")
+
+        Zip::File.open(output_path, Zip::File::CREATE) do |zipfile|
+          {
+            dimensions: Unitsdb::Dimensions,
+            unit_systems: Unitsdb::UnitSystems,
+            units: Unitsdb::Units,
+            prefixes: Unitsdb::Prefixes,
+            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") do |f|
+                f.write(collection.to_yaml)
+              end
+            end
           end
         end
 
-        puts "Created ZIP archive: #{output_file}"
+        puts "Created ZIP archive: #{output_path}"
       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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+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"
+
+          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)
+        end
+
+        # Validation helpers
+        def validate_parameters(direction, ucum_file)
+          unless %w[to_ucum from_ucum both].include?(direction)
+            raise Unitsdb::Errors::InvalidParameterError,
+                  "Invalid direction '#{direction}': must be 'to_ucum', 'from_ucum', or 'both'"
+          end
+
+          return if File.exist?(ucum_file)
+
+          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)
+          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