unitsdb 2.1.1 → 2.2.1

data/exe/unitsdb

@@ -4,4 +4,10 @@
 require "unitsdb"
 require "unitsdb/cli"
 
-Unitsdb::CLI.start(ARGV)
+begin
+  Unitsdb::Cli.start(ARGV)
+rescue SystemExit => e
+  # Only print if not already handled (exit code 0 = normal exit)
+  # Exit code 1 from our commands is already handled, don't duplicate
+  raise if e.status.zero?
+end

data/lib/unitsdb/cli.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
 
 require "thor"
-require_relative "commands/base"
-require_relative "commands/validate"
-require_relative "commands/_modify"
-require_relative "commands/ucum"
 require "fileutils"
 
 module Unitsdb
-  class CLI < Thor
+  class Cli < Thor
+    # Enable --trace globally for all subcommands
+    # When enabled, Thor shows full backtraces on error
+    class_option :trace, type: :boolean, default: false,
+                         desc: "Show full backtrace on error"
+
     # Fix Thor deprecation warning
     def self.exit_on_failure?
       true
@@ -17,10 +18,14 @@ module Unitsdb
     desc "ucum SUBCOMMAND", "UCUM-related commands"
     subcommand "ucum", Commands::UcumCommand
 
+    desc "qudt SUBCOMMAND", "QUDT-related commands"
+    subcommand "qudt", Commands::QudtCommand
+
     desc "_modify SUBCOMMAND", "Commands that modify the database"
     subcommand "_modify", Commands::ModifyCommand
 
-    desc "validate SUBCOMMAND", "Validate database files for different conditions"
+    desc "validate SUBCOMMAND",
+         "Validate database files for different conditions"
     subcommand "validate", Commands::ValidateCommand
 
     desc "search QUERY", "Search for entities containing the given text"
@@ -36,8 +41,7 @@ module Unitsdb
                       desc: "Path to UnitsDB database (required)"
 
     def search(query)
-      require_relative "commands/search"
-      Commands::Search.new(options).run(query)
+      run_command(Commands::Search, :run, query)
     end
 
     desc "get ID", "Get detailed information about an entity by ID"
@@ -48,11 +52,11 @@ module Unitsdb
     option :database, type: :string, required: true, aliases: "-d",
                       desc: "Path to UnitsDB database (required)"
     def get(id)
-      require_relative "commands/get"
-      Commands::Get.new(options).get(id)
+      run_command(Commands::Get, :get, id)
     end
 
-    desc "check_si", "Check and update SI digital framework references in UnitsDB"
+    desc "check_si",
+         "Check and update SI digital framework references in UnitsDB"
     option :entity_type, type: :string, aliases: "-e",
                          desc: "Entity type to check (units, quantities, or prefixes). If not specified, all types are checked"
     option :ttl_dir, type: :string, required: true, aliases: "-t",
@@ -67,8 +71,7 @@ module Unitsdb
                       desc: "Path to UnitsDB database (required)"
 
     def check_si
-      require_relative "commands/check_si"
-      Commands::CheckSi.new(options).run
+      run_command(Commands::CheckSiCommand, :run)
     end
 
     desc "release", "Create release files (unified YAML and/or ZIP archive)"
@@ -81,8 +84,32 @@ module Unitsdb
     option :database, type: :string, required: true, aliases: "-d",
                       desc: "Path to UnitsDB database (required)"
     def release
-      require_relative "commands/release"
-      Commands::Release.new(options).run
+      run_command(Commands::Release, :run)
+    end
+
+    private
+
+    def run_command(command_class, method, *args)
+      command = command_class.new(options)
+      command.send(method, *args)
+    rescue Unitsdb::Errors::CLIRuntimeError => e
+      handle_cli_error(e)
+    rescue StandardError => e
+      handle_error(e)
+    end
+
+    def handle_cli_error(error)
+      raise error if debugging?
+
+      warn "Error: #{error.message}"
+      exit 1
+    end
+
+    def handle_error(error)
+      raise error if debugging?
+
+      warn "Error: #{error.message}"
+      exit 1
     end
   end
 end

data/lib/unitsdb/commands/_modify.rb

@@ -5,8 +5,16 @@ require "thor"
 module Unitsdb
   module Commands
     class ModifyCommand < Thor
-      desc "normalize [INPUT] [OUTPUT]", "Normalize a YAML file or all YAML files with --all"
-      method_option :sort, type: :string, default: "nist",
+      # Inherit trace option from parent CLI
+      class_option :trace, type: :boolean, default: false,
+                           desc: "Show full backtrace on error"
+
+      desc "normalize INPUT OUTPUT",
+           "Normalize a YAML file or all YAML files with --all"
+      method_option :sort, type: :string,
+                           default: "nist",
+                           enum: ["short", "nist", "unitsml", "none"],
+                           aliases: "-s",
                            desc: "Sort units by: 'short' (name), 'nist' (ID, default), 'unitsml' (ID), or 'none'"
       method_option :database, type: :string, required: true, aliases: "-d",
                                desc: "Path to UnitsDB database (required)"
@@ -14,8 +22,36 @@ module Unitsdb
                           desc: "Process all YAML files in the repository"
 
       def normalize(input = nil, output = nil)
-        require_relative "normalize"
-        Normalize.new(options).run(input, output)
+        run_command(Normalize, options, input, output)
+      rescue Unitsdb::Errors::CLIRuntimeError => e
+        handle_cli_error(e)
+      rescue StandardError => e
+        handle_error(e)
+      end
+
+      private
+
+      def run_command(command_class, options, *args)
+        command = command_class.new(options)
+        command.run(*args)
+      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

data/lib/unitsdb/commands/base.rb

@@ -15,11 +15,15 @@ module Unitsdb
 
       def load_database(path = nil)
         path ||= @options[:database]
-        raise Unitsdb::Errors::DatabaseError, "Database path not specified" unless path
+        unless path
+          raise Unitsdb::Errors::DatabaseError,
+                "Database path not specified"
+        end
 
         Unitsdb::Database.from_db(path)
       rescue StandardError => e
-        raise Unitsdb::Errors::DatabaseError, "Failed to load database: #{e.message}"
+        raise Unitsdb::Errors::DatabaseError,
+              "Failed to load database: #{e.message}"
       end
     end
   end

data/lib/unitsdb/commands/check_si/si_formatter.rb

@@ -0,0 +1,488 @@
+# frozen_string_literal: true
+
+require "terminal-table"
+
+module Unitsdb
+  module Commands
+    module CheckSi
+      # Formatter for SI check results
+      module SiFormatter
+        module_function
+
+        # Display TTL → DB results
+        def display_si_results(entity_type, matches, missing_matches,
+  unmatched_ttl)
+          puts "\n=== #{entity_type.capitalize} with matching SI references ==="
+          if matches.empty?
+            puts "None"
+          else
+            rows = []
+            matches.each do |match|
+              si_suffix = SiTtlParser.extract_identifying_suffix(match[:si_uri])
+              rows << [
+                "UnitsDB: #{match[:entity_id]}",
+                "(#{match[:entity_name] || 'unnamed'})",
+              ]
+              rows << [
+                "SI TTL:  #{si_suffix}",
+                "(#{match[:si_label] || match[:si_name] || 'unnamed'})",
+              ]
+              rows << :separator unless match == matches.last
+            end
+
+            table = Terminal::Table.new(
+              title: "Valid SI Reference Mappings",
+              rows: rows,
+            )
+            puts table
+          end
+
+          puts "\n=== #{entity_type.capitalize} without SI references ==="
+          if missing_matches.empty?
+            puts "None"
+          else
+            # Split matches into exact and potential
+            exact_matches = []
+            potential_matches = []
+
+            missing_matches.each do |match|
+              # Get match details
+              match_details = match[:match_details]
+              match_desc = match_details&.dig(:match_desc) || ""
+
+              # Symbol matches and partial matches should always be potential matches
+              if %w[symbol_match partial_match].include?(match_desc)
+                potential_matches << match
+              elsif match_details&.dig(:exact) == false
+                potential_matches << match
+              else
+                exact_matches << match
+              end
+            end
+
+            # Display exact matches
+            puts "\n=== Exact Matches (#{exact_matches.size}) ==="
+            if exact_matches.empty?
+              puts "None"
+            else
+              rows = []
+              exact_matches.each do |match|
+                # First row: UnitsDB entity
+                rows << [
+                  "UnitsDB: #{match[:entity_id]}",
+                  "(#{match[:entity_name] || 'unnamed'})",
+                ]
+
+                # Handle multiple SI matches in a single cell if present
+                if match[:multiple_si]
+                  # Ensure no duplicate URIs
+                  si_text_parts = []
+                  si_label_parts = []
+                  seen_uris = {}
+
+                  match[:multiple_si].each do |si_data|
+                    uri = si_data[:uri]
+                    next if seen_uris[uri] # Skip if we've already seen this URI
+
+                    seen_uris[uri] = true
+
+                    suffix = SiTtlParser.extract_identifying_suffix(uri)
+                    si_text_parts << suffix
+                    si_label_parts << (si_data[:label] || si_data[:name])
+                  end
+
+                  rows << [
+                    "SI TTL:  #{si_text_parts.join(', ')}",
+                    "(#{si_label_parts.join(', ')})",
+                  ]
+                else
+                  # Second row: SI TTL suffix and label/name
+                  si_suffix = SiTtlParser.extract_identifying_suffix(match[:si_uri])
+                  rows << [
+                    "SI TTL:  #{si_suffix}",
+                    "(#{match[:si_label] || match[:si_name] || 'unnamed'})",
+                  ]
+                end
+
+                # Status line with match type
+                match_details = match[:match_details]
+                match_desc = match_details&.dig(:match_desc) || ""
+                match_info = format_match_info(match_desc)
+                status_text = match_info.empty? ? "Missing reference" : "Missing reference (#{match_info})"
+
+                rows << [
+                  "Status: #{status_text}",
+                  "✗",
+                ]
+                rows << :separator unless match == exact_matches.last
+              end
+
+              table = Terminal::Table.new(
+                title: "Exact Match Missing SI References",
+                rows: rows,
+              )
+              puts table
+            end
+
+            # Display potential matches
+            puts "\n=== Potential Matches (#{potential_matches.size}) ==="
+            if potential_matches.empty?
+              puts "None"
+            else
+              rows = []
+              potential_matches.each do |match|
+                # First row: UnitsDB entity
+                rows << [
+                  "UnitsDB: #{match[:entity_id]}",
+                  "(#{match[:entity_name] || 'unnamed'})",
+                ]
+
+                # Handle multiple SI matches in a single cell if present
+                if match[:multiple_si]
+                  # Ensure no duplicate URIs
+                  si_text_parts = []
+                  seen_uris = {}
+
+                  match[:multiple_si].each do |si_data|
+                    uri = si_data[:uri]
+                    next if seen_uris[uri] # Skip if we've already seen this URI
+
+                    seen_uris[uri] = true
+
+                    suffix = SiTtlParser.extract_identifying_suffix(uri)
+                    si_text_parts << "#{suffix} (#{si_data[:label] || si_data[:name]})"
+                  end
+
+                  rows << [
+                    "SI TTL:  #{si_text_parts.join(', ')}",
+                    "",
+                  ]
+                else
+                  # Single TTL entity
+                  si_suffix = SiTtlParser.extract_identifying_suffix(match[:si_uri])
+                  rows << [
+                    "SI TTL:  #{si_suffix}",
+                    "(#{match[:si_label] || match[:si_name] || 'unnamed'})",
+                  ]
+                end
+
+                # Status line
+                match_details = match[:match_details]
+                match_desc = match_details&.dig(:match_desc) || ""
+                match_info = format_match_info(match_desc)
+                status_text = match_info.empty? ? "Missing reference" : "Missing reference"
+
+                rows << [
+                  "Status: #{status_text}",
+                  "✗",
+                ]
+                rows << :separator unless match == potential_matches.last
+              end
+
+              table = Terminal::Table.new(
+                title: "Potential Match Missing SI References",
+                rows: rows,
+              )
+              puts table
+            end
+          end
+
+          puts "\n=== SI #{entity_type.capitalize} not mapped to our database ==="
+          if unmatched_ttl.empty?
+            puts "None (All TTL entities are referenced - Good job!)"
+          else
+            # Group unmatched ttl entities by their URI to avoid duplicates
+            grouped_unmatched = {}
+
+            unmatched_ttl.each do |entity|
+              uri = entity[:uri]
+              grouped_unmatched[uri] = entity unless grouped_unmatched.key?(uri)
+            end
+
+            rows = []
+            unique_entities = grouped_unmatched.values
+
+            unique_entities.each do |entity|
+              # Create the SI TTL row
+              si_suffix = SiTtlParser.extract_identifying_suffix(entity[:uri])
+              ttl_row = ["SI TTL:  #{si_suffix}",
+                         "(#{entity[:label] || entity[:name] || 'unnamed'})"]
+
+              rows << ttl_row
+              rows << [
+                "Status: No matching UnitsDB entity",
+                "?",
+              ]
+              rows << :separator unless entity == unique_entities.last
+            end
+
+            table = Terminal::Table.new(
+              title: "Unmapped SI Entities",
+              rows: rows,
+            )
+            puts table
+          end
+        end
+
+        # Display DB → TTL results
+        def display_db_results(entity_type, matches, missing_refs, unmatched_db)
+          puts "\n=== Summary of database entities referencing SI ==="
+          puts "#{entity_type.capitalize} with SI references: #{matches.size}"
+          puts "#{entity_type.capitalize} missing SI references: #{missing_refs.size}"
+          puts "Database #{entity_type} not matching any SI entity: #{unmatched_db.size}"
+
+          # Show entities with valid references
+          unless matches.empty?
+            puts "\n=== #{entity_type.capitalize} with SI references ==="
+            rows = []
+            matches.each do |match|
+              db_entity = match[:db_entity]
+              entity_id = match[:entity_id] || db_entity.short
+              entity_name = db_entity.respond_to?(:names) ? db_entity.names&.first : "unnamed"
+              si_suffix = SiTtlParser.extract_identifying_suffix(match[:ttl_uri])
+
+              ttl_label = match[:ttl_entity] ? (match[:ttl_entity][:label] || match[:ttl_entity][:name]) : "Unknown"
+
+              rows << [
+                "UnitsDB: #{entity_id}",
+                "(#{entity_name})",
+              ]
+              rows << [
+                "SI TTL:  #{si_suffix}",
+                "(#{ttl_label})",
+              ]
+              rows << :separator unless match == matches.last
+            end
+
+            table = Terminal::Table.new(
+              title: "Valid SI References",
+              rows: rows,
+            )
+            puts table
+          end
+
+          puts "\n=== #{entity_type.capitalize} that should reference SI ==="
+          if missing_refs.empty?
+            puts "None"
+          else
+            # Split missing_refs into exact and potential matches
+            exact_matches = []
+            potential_matches = []
+
+            missing_refs.each do |match|
+              # Determine match type
+              ttl_entities = match[:ttl_entities]
+              uri = ttl_entities.first[:uri]
+              match_type = "Exact match" # Default
+              match_type = match[:match_types][uri] if match[:match_types] && match[:match_types][uri]
+
+              # Get match description if available
+              entity_id = match[:db_entity].short
+              match_pair_key = "#{entity_id}:#{ttl_entities.first[:uri]}"
+              match_details = Unitsdb::Commands::CheckSi::SiMatcher.instance_variable_get(:@match_details)&.dig(match_pair_key)
+              match_desc = match_details[:match_desc] if match_details && match_details[:match_desc]
+
+              # Symbol matches and partial matches should always be potential matches
+              if %w[symbol_match partial_match].include?(match_desc)
+                potential_matches << match
+              elsif match_type == "Exact match"
+                exact_matches << match
+              else
+                potential_matches << match
+              end
+            end
+
+            # Display exact matches
+            puts "\n=== Exact Matches (#{exact_matches.size}) ==="
+            if exact_matches.empty?
+              puts "None"
+            else
+              rows = []
+              exact_matches.each do |match|
+                db_entity = match[:db_entity]
+                entity_id = match[:entity_id] || db_entity.short
+                entity_name = db_entity.respond_to?(:names) ? db_entity.names&.first : "unnamed"
+
+                # Handle multiple TTL entities in a single row
+                ttl_entities = match[:ttl_entities]
+                if ttl_entities.size == 1
+                  # Single TTL entity
+                  ttl_entity = ttl_entities.first
+                  si_suffix = SiTtlParser.extract_identifying_suffix(ttl_entity[:uri])
+
+                  rows << [
+                    "UnitsDB: #{entity_id}",
+                    "(#{entity_name})",
+                  ]
+                  rows << [
+                    "SI TTL:  #{si_suffix}",
+                    "(#{ttl_entity[:label] || ttl_entity[:name] || 'unnamed'})",
+                  ]
+                else
+                  # Multiple TTL entities, combine them - ensure no duplicates
+                  si_text_parts = []
+                  seen_uris = {}
+
+                  ttl_entities.each do |ttl_entity|
+                    uri = ttl_entity[:uri]
+                    next if seen_uris[uri] # Skip if we've already seen this URI
+
+                    seen_uris[uri] = true
+
+                    suffix = SiTtlParser.extract_identifying_suffix(uri)
+                    si_text_parts << "#{suffix} (#{ttl_entity[:label] || ttl_entity[:name] || 'unnamed'})"
+                  end
+
+                  si_text = si_text_parts.join(", ")
+
+                  rows << [
+                    "UnitsDB: #{entity_id}",
+                    "(#{entity_name})",
+                  ]
+                  rows << [
+                    "SI TTL:  #{si_text}",
+                    "",
+                  ]
+                end
+
+                # Get match details for this match
+                match_pair_key = "#{db_entity.short}:#{ttl_entities.first[:uri]}"
+                match_details = Unitsdb::Commands::CheckSi::SiMatcher.instance_variable_get(:@match_details)&.dig(match_pair_key)
+
+                # Format match info
+                match_info = ""
+                match_info = format_match_info(match_details[:match_desc]) if match_details
+
+                status_text = match_info.empty? ? "Missing reference" : "Missing reference (#{match_info})"
+                rows << [
+                  "Status: #{status_text}",
+                  "✗",
+                ]
+                rows << :separator unless match == exact_matches.last
+              end
+
+              table = Terminal::Table.new(
+                title: "Exact Match Missing SI References",
+                rows: rows,
+              )
+              puts table
+            end
+
+            # Display potential matches
+            puts "\n=== Potential Matches (#{potential_matches.size}) ==="
+            if potential_matches.empty?
+              puts "None"
+            else
+              rows = []
+              potential_matches.each do |match|
+                db_entity = match[:db_entity]
+                entity_id = match[:entity_id] || db_entity.short
+                entity_name = db_entity.respond_to?(:names) ? db_entity.names&.first : "unnamed"
+
+                # Handle multiple TTL entities in a single row
+                ttl_entities = match[:ttl_entities]
+                if ttl_entities.size == 1
+                  # Single TTL entity
+                  ttl_entity = ttl_entities.first
+                  si_suffix = SiTtlParser.extract_identifying_suffix(ttl_entity[:uri])
+
+                  rows << [
+                    "UnitsDB: #{entity_id}",
+                    "(#{entity_name})",
+                  ]
+                  rows << [
+                    "SI TTL:  #{si_suffix}",
+                    "(#{ttl_entity[:label] || ttl_entity[:name] || 'unnamed'})",
+                  ]
+                else
+                  # Multiple TTL entities, combine them - ensure no duplicates
+                  si_text_parts = []
+                  seen_uris = {}
+
+                  ttl_entities.each do |ttl_entity|
+                    uri = ttl_entity[:uri]
+                    next if seen_uris[uri] # Skip if we've already seen this URI
+
+                    seen_uris[uri] = true
+
+                    suffix = SiTtlParser.extract_identifying_suffix(uri)
+                    si_text_parts << "#{suffix} (#{ttl_entity[:label] || ttl_entity[:name] || 'unnamed'})"
+                  end
+
+                  si_text = si_text_parts.join(", ")
+
+                  rows << [
+                    "UnitsDB: #{entity_id}",
+                    "(#{entity_name})",
+                  ]
+                  rows << [
+                    "SI TTL:  #{si_text}",
+                    "",
+                  ]
+                end
+
+                # Get match details
+                match_pair_key = "#{db_entity.short}:#{ttl_entities.first[:uri]}"
+                match_details = Unitsdb::Commands::CheckSi::SiMatcher.instance_variable_get(:@match_details)&.dig(match_pair_key)
+
+                # Format match info
+                match_info = ""
+                match_info = format_match_info(match_details[:match_desc]) if match_details
+
+                status_text = match_info.empty? ? "Missing reference" : "Missing reference (#{match_info})"
+                rows << [
+                  "Status: #{status_text}",
+                  "✗",
+                ]
+                rows << :separator unless match == potential_matches.last
+              end
+
+              table = Terminal::Table.new(
+                title: "Potential Match Missing SI References",
+                rows: rows,
+              )
+              puts table
+            end
+          end
+        end
+
+        # Print direction header
+        def print_direction_header(direction)
+          case direction
+          when "SI → UnitsDB"
+            puts "\n=== Checking SI → UnitsDB (TTL entities referenced by database) ==="
+          when "UnitsDB → SI"
+            puts "\n=== Checking UnitsDB → SI (database entities referencing TTL) ==="
+          end
+
+          puts "\n=== Instructions for #{direction} direction ==="
+          case direction
+          when "SI → UnitsDB"
+            puts "If you are the UnitsDB Register Manager, please ensure that all SI entities have proper references in the UnitsDB database."
+            puts "For each missing reference, add a reference with the appropriate URI and 'authority: \"si-digital-framework\"'."
+          when "UnitsDB → SI"
+            puts "If you are the UnitsDB Register Manager, please add SI references to UnitsDB entities that should have them."
+            puts "For each entity that should reference SI, add a reference with 'authority: \"si-digital-framework\"' and the SI TTL URI."
+          end
+        end
+
+        def set_match_details(details)
+          @match_details = details
+        end
+
+        # Format match info for display
+        def format_match_info(match_desc)
+          {
+            "short_to_name" => "short → name",
+            "short_to_label" => "short → label",
+            "name_to_name" => "name → name",
+            "name_to_label" => "name → label",
+            "name_to_alt_label" => "name → alt_label",
+            "symbol_match" => "symbol → symbol",
+            "partial_match" => "partial match",
+          }[match_desc] || ""
+        end
+      end
+    end
+  end
+end