unitsdb 2.2.1 → 2.2.4

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

@@ -13,24 +13,9 @@ module Unitsdb
         module_function
 
         # Update references in YAML file (TTL → DB direction)
-        def update_references(entity_type, missing_matches, db_entities,
+        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
+          original_yaml_file = resolve_yaml_file(output_file, entity_type)
 
           # Load the original YAML file
           yaml_content = File.read(original_yaml_file)
@@ -111,23 +96,7 @@ module Unitsdb
         # 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
+          original_yaml_file = resolve_yaml_file(output_file, entity_type)
 
           # Load the original YAML file
           yaml_content = File.read(original_yaml_file)
@@ -146,7 +115,7 @@ module Unitsdb
               # 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::CheckSi::SiMatcher.instance_variable_get(:@match_details)&.dig(match_pair_key)
+              match_details = Unitsdb::Commands::CheckSi::SiMatcher.match_details&.dig(match_pair_key)
 
               if match_details && %w[symbol_match
                                      partial_match].include?(match_details[:match_desc])
@@ -208,9 +177,20 @@ module Unitsdb
           write_yaml_file(output_file, output_data)
         end
 
+        # Resolve which YAML file to read from. Caller supplies
+        # `output_file` as the canonical path; if it doesn't exist
+        # yet we seed it with an empty `{entity_type => []}` template.
+        def resolve_yaml_file(output_file, entity_type)
+          unless File.exist?(output_file)
+            FileUtils.mkdir_p(File.dirname(output_file))
+            File.write(output_file, { entity_type => [] }.to_yaml)
+          end
+          output_file
+        end
+
         # Helper to write YAML file
+        # Ensure the output directory exists
         def write_yaml_file(output_file, output_data)
-          # Ensure the output directory exists
           output_dir = File.dirname(output_file)
           FileUtils.mkdir_p(output_dir)
 

data/lib/unitsdb/commands/entity_presenter.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Unitsdb
+  module Commands
+    # Present a single entity as text for the Get/Search CLI commands.
+    # Pulls every displayable field off the typed model — no
+    # `respond_to?` feature detection. New entity types extend
+    # `TYPE_NAME` and `extras`; nothing else changes.
+    class EntityPresenter
+      TYPE_NAME = {
+        Unitsdb::Unit => "Unit",
+        Unitsdb::Prefix => "Prefix",
+        Unitsdb::Quantity => "Quantity",
+        Unitsdb::Dimension => "Dimension",
+        Unitsdb::UnitSystem => "UnitSystem",
+      }.freeze
+
+      def initialize(entity)
+        @entity = entity
+      end
+
+      # Human-readable type label, e.g. "Unit", "Prefix".
+      def type_name
+        TYPE_NAME[@entity.class] || @entity.class.name.split("::").last
+      end
+
+      # Best-effort display name: first localized name value → short → "N/A".
+      def display_name
+        name = @entity.names.first
+        return name.value.to_s if name&.value
+        return @entity.short.to_s if @entity.short
+
+        "N/A"
+      end
+
+      # Multi-line "details" output for `unitsdb get ID`.
+      def print_details
+        puts "Entity details:"
+        puts "  - Type: #{type_name}"
+        puts "  - Name: #{display_name}"
+        puts "  - Description: #{@entity.short}" if show_short?
+        print_identifiers(header: "  - Identifiers:", item_indent: "      ")
+        print_extras
+        print_references
+      end
+
+      # Single-block summary used by `unitsdb search` per result.
+      def print_summary
+        puts "  - #{type_name}: #{display_name}"
+        print_identifiers(header: "    IDs:", item_indent: "      ")
+        puts "    Description: #{@entity.short}" if show_short?
+        puts ""
+      end
+
+      private
+
+      def show_short?
+        @entity.short && @entity.short != display_name
+      end
+
+      def print_identifiers(header:, item_indent:)
+        identifiers = @entity.identifiers
+        if identifiers.empty?
+          puts "#{header} None"
+          return
+        end
+
+        puts header
+        identifiers.each do |id|
+          puts "#{item_indent}- #{id.id} (Type: #{id.type || 'N/A'})"
+        end
+      end
+
+      def print_extras
+        case @entity
+        when Unitsdb::Unit
+          print_unit_symbols
+        end
+      end
+
+      def print_unit_symbols
+        return unless @entity.symbols.any?
+
+        puts "  - Symbols:"
+        @entity.symbols.each { |s| puts "      - #{s}" }
+      end
+
+      def print_references
+        return unless @entity.references.any?
+
+        puts "  - References:"
+        @entity.references.each do |ref|
+          puts "      - #{ref.type}: #{ref.uri}"
+        end
+      end
+    end
+  end
+end

data/lib/unitsdb/commands/get.rb

@@ -1,133 +1,36 @@
 # frozen_string_literal: true
 
-require "json"
-
 module Unitsdb
   module Commands
     class Get < Base
       def get(id)
-        # Database path is guaranteed by Thor's global option
         id_type = @options[:id_type]
         format = @options[:format] || "text"
 
-        begin
-          database = load_database(@options[:database])
-
-          # Search by ID
-          entity = database.get_by_id(id: id, type: id_type)
-
-          unless entity
-            puts "No entity found with ID: '#{id}'"
-            return
-          end
+        database = load_database(@options[:database])
+        entity = database.get_by_id(id: id, type: id_type)
 
-          # Output based on format
-          if %w[json yaml].include?(format.downcase)
-            begin
-              puts entity.send("to_#{format.downcase}")
-              return
-            rescue NoMethodError
-              raise Unitsdb::Errors::InvalidFormatError,
-                    "Unable to convert entity to #{format.upcase} format: output format not supported for this entity type"
-            end
-          end
-
-          # Default text output
-          print_entity_details(entity)
-        rescue Unitsdb::Errors::DatabaseError => e
-          raise Unitsdb::Errors::DatabaseLoadError,
-                "Failed to load database: #{e.message}"
-        rescue StandardError => e
-          raise Unitsdb::Errors::CLIRuntimeError, "Search failed: #{e.message}"
+        if entity.nil?
+          puts "No entity found with ID: '#{id}'"
+          return
         end
-      end
-
-      private
-
-      def print_entity_details(entity)
-        # Determine entity type
-        entity_type = get_entity_type(entity)
-
-        # Get name
-        name = get_entity_name(entity)
 
-        puts "Entity details:"
-        puts "  - Type: #{entity_type}"
-        puts "  - Name: #{name}"
-
-        # Print description if available
-        puts "  - Description: #{entity.short}" if entity.respond_to?(:short) && entity.short && entity.short != name
-
-        # Print all identifiers
-        if entity.identifiers&.any?
-          puts "  - Identifiers:"
-          entity.identifiers.each do |id|
-            puts "      - #{id.id} (Type: #{id.type || 'N/A'})"
-          end
+        if %w[json yaml].include?(format.downcase)
+          print_serialized(entity, format.downcase)
         else
-          puts "  - Identifiers: None"
-        end
-
-        # Print additional properties based on entity type
-        case entity
-        when Unitsdb::Unit
-          puts "  - Symbols:" 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
-
-          if entity.respond_to?(:dimensions) && entity.dimensions&.any?
-            puts "  - Dimensions:"
-            entity.dimensions.each { |d| puts "      - #{d}" }
-          end
-        when Unitsdb::Quantity
-          puts "  - Dimensions: #{entity.dimension}" if entity.respond_to?(:dimension) && entity.dimension
-        when Unitsdb::Prefix
-          puts "  - Value: #{entity.value}" if entity.respond_to?(:value) && entity.value
-          puts "  - Symbol: #{entity.symbol}" if entity.respond_to?(:symbol) && entity.symbol
-        when Unitsdb::Dimension
-          # Any dimension-specific properties
-        when Unitsdb::UnitSystem
-          puts "  - Organization: #{entity.organization}" if entity.respond_to?(:organization) && entity.organization
-        end
-
-        # Print references if available
-        return unless entity.respond_to?(:references) && entity.references&.any?
-
-        puts "  - References:"
-        entity.references.each do |ref|
-          puts "      - #{ref.type}: #{ref.uri}"
+          EntityPresenter.new(entity).print_details
         end
+      rescue Unitsdb::Errors::DatabaseError => e
+        raise Unitsdb::Errors::DatabaseLoadError,
+              "Failed to load database: #{e.message}"
+      rescue StandardError => e
+        raise Unitsdb::Errors::CLIRuntimeError, "Get failed: #{e.message}"
       end
 
-      def get_entity_type(entity)
-        case entity
-        when Unitsdb::Unit
-          "Unit"
-        when Unitsdb::Prefix
-          "Prefix"
-        when Unitsdb::Quantity
-          "Quantity"
-        when Unitsdb::Dimension
-          "Dimension"
-        when Unitsdb::UnitSystem
-          "UnitSystem"
-        else
-          "Unknown"
-        end
-      end
-
-      def get_entity_name(entity)
-        # Using early returns is still preferable for simple conditions
-        return entity.names.first if entity.respond_to?(:names) && entity.names&.any?
-        return entity.name if entity.respond_to?(:name) && entity.name
-        return entity.short if entity.respond_to?(:short) && entity.short
+      private
 
-        "N/A" # Default if no name found
+      def print_serialized(entity, format)
+        puts entity.public_send("to_#{format}")
       end
     end
   end

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

@@ -90,17 +90,15 @@ unmatched_qudt)
             details = "DIMENSION VECTOR: #{entity.label || 'No label'}"
             details += "\n   URI: #{entity.uri}"
             details += "\n   Description: #{entity.description}" if entity.description
-            if entity.respond_to?(:dimension_exponent_for_length)
-              exponents = []
-              exponents << "L:#{entity.dimension_exponent_for_length}" if entity.dimension_exponent_for_length != 0
-              exponents << "M:#{entity.dimension_exponent_for_mass}" if entity.dimension_exponent_for_mass != 0
-              exponents << "T:#{entity.dimension_exponent_for_time}" if entity.dimension_exponent_for_time != 0
-              exponents << "I:#{entity.dimension_exponent_for_electric_current}" if entity.dimension_exponent_for_electric_current != 0
-              exponents << "Θ:#{entity.dimension_exponent_for_thermodynamic_temperature}" if entity.dimension_exponent_for_thermodynamic_temperature != 0
-              exponents << "N:#{entity.dimension_exponent_for_amount_of_substance}" if entity.dimension_exponent_for_amount_of_substance != 0
-              exponents << "J:#{entity.dimension_exponent_for_luminous_intensity}" if entity.dimension_exponent_for_luminous_intensity != 0
-              details += "\n   Exponents: #{exponents.join(', ')}" unless exponents.empty?
-            end
+            exponents = []
+            exponents << "L:#{entity.dimension_exponent_for_length}" if entity.dimension_exponent_for_length != 0
+            exponents << "M:#{entity.dimension_exponent_for_mass}" if entity.dimension_exponent_for_mass != 0
+            exponents << "T:#{entity.dimension_exponent_for_time}" if entity.dimension_exponent_for_time != 0
+            exponents << "I:#{entity.dimension_exponent_for_electric_current}" if entity.dimension_exponent_for_electric_current != 0
+            exponents << "Θ:#{entity.dimension_exponent_for_thermodynamic_temperature}" if entity.dimension_exponent_for_thermodynamic_temperature != 0
+            exponents << "N:#{entity.dimension_exponent_for_amount_of_substance}" if entity.dimension_exponent_for_amount_of_substance != 0
+            exponents << "J:#{entity.dimension_exponent_for_luminous_intensity}" if entity.dimension_exponent_for_luminous_intensity != 0
+            details += "\n   Exponents: #{exponents.join(', ')}" unless exponents.empty?
             details
           when Unitsdb::QudtSystemOfUnits
             details = "SYSTEM OF UNITS: #{entity.label || 'No label'}"
@@ -157,26 +155,17 @@ unmatched_qudt)
 
         # 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
+          return entity.identifiers.first.id unless entity.identifiers.empty?
+
+          entity.short || "unknown-id"
         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
+          return entity.names.first.value unless entity.names.empty?
+          return entity.short if entity.short
+
+          "unknown-name"
         end
 
         # Helper to get qudt entity name

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

@@ -70,14 +70,14 @@ module Unitsdb
 
         # Check if a UnitsDB entity already has a QUDT reference
         def has_qudt_reference?(entity)
-          return false unless entity.respond_to?(:references) && entity.references
+          return false unless entity.references
 
           entity.references.any? { |ref| ref.authority == "qudt" }
         end
 
         # Find the referenced QUDT entity based on the reference URI
         def find_referenced_qudt_entity(db_entity, qudt_entities)
-          return nil unless db_entity.respond_to?(:references) && db_entity.references
+          return nil unless db_entity.references
 
           qudt_ref = db_entity.references.find { |ref| ref.authority == "qudt" }
           return nil unless qudt_ref
@@ -87,8 +87,8 @@ module Unitsdb
         end
 
         # Get the ID of a UnitsDB entity
-        def get_entity_id(entity)
-          entity.respond_to?(:id) ? entity.id : nil
+        def get_entity_id(_entity)
+          nil
         end
 
         # Find a matching UnitsDB entity for a QUDT entity
@@ -520,7 +520,7 @@ module Unitsdb
 
         # Check if QUDT dimension vector matches UnitsDB dimension
         def dimensions_match?(qudt_dimension, db_dimension)
-          return false unless qudt_dimension.respond_to?(:dimension_exponent_for_length)
+          return false unless qudt_dimension.is_a?(Unitsdb::QudtDimensionVector)
 
           # Map QUDT dimension exponents to UnitsDB dimension structure
           qudt_exponents = {
@@ -552,14 +552,14 @@ module Unitsdb
           qudt_exponents == db_exponents
         end
 
-        # Get dimension power from UnitsDB dimension entity
+        # Get dimension power from UnitsDB dimension entity.
+        # Dimension declares all seven dimension-type attrs as
+        # DimensionDetails; DimensionDetails always has `power`.
         def get_dimension_power(db_dimension, dimension_type)
-          return 0 unless db_dimension.respond_to?(dimension_type)
+          property = db_dimension.public_send(dimension_type)
+          return 0 unless property
 
-          dimension_property = db_dimension.send(dimension_type)
-          return 0 unless dimension_property.respond_to?(:power)
-
-          dimension_property.power || 0
+          property.power || 0
         end
 
         # Normalize names by removing common variations and punctuation
@@ -585,7 +585,7 @@ module Unitsdb
 
           # Look for a UnitsDB unit that has an SI reference with this identifier
           db_units.find do |db_unit|
-            next unless db_unit.respond_to?(:references) && db_unit.references
+            next unless db_unit.references
 
             db_unit.references.any? do |ref|
               ref.authority == "si" && (
@@ -603,7 +603,7 @@ module Unitsdb
           # PRIORITY 1: Try UCUM code match first (most reliable for prefixes)
           if qudt_prefix.ucum_code
             ucum_match = db_prefixes.find do |db_prefix|
-              db_prefix.respond_to?(:references) && db_prefix.references&.any? do |ref|
+              (db_prefix.references || [])&.any? do |ref|
                 ref.authority == "ucum" && ref.uri&.include?(qudt_prefix.ucum_code)
               end
             end
@@ -644,17 +644,7 @@ module Unitsdb
           end
 
           # PRIORITY 4: Try multiplier match (for prefixes with same scale factor)
-          if qudt_prefix.prefix_multiplier
-            multiplier_match = db_prefixes.find do |db_prefix|
-              db_prefix.respond_to?(:factor) &&
-                (db_prefix.factor - qudt_prefix.prefix_multiplier).abs < 1e-10
-            end
-
-            if multiplier_match
-              result[:match] = multiplier_match
-              return result
-            end
-          end
+          # Skipped: Unitsdb::Prefix has no `factor` attribute in 2.0.
 
           # PRIORITY 5: Try normalized name matching
           if qudt_prefix.label
@@ -720,7 +710,7 @@ module Unitsdb
           end
 
           # PRIORITY 4: Try multiplier match (for prefixes with same scale factor)
-          if db_prefix.respond_to?(:factor) && db_prefix.factor
+          if false
             multiplier_match = qudt_prefixes.find do |qudt_prefix|
               qudt_prefix.prefix_multiplier &&
                 (qudt_prefix.prefix_multiplier - db_prefix.factor).abs < 1e-10
@@ -734,10 +724,10 @@ module Unitsdb
 
         # 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
+          return false unless entity.references
 
-          entity.references.any? do |ref|
-            ref.authority == "qudt" && ref.respond_to?(:verified) && ref.verified
+          entity.references.any? do |_ref|
+            false
           end
         end
       end

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

@@ -168,20 +168,17 @@ include_potential = false)
 
         # 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
+          return entity.identifiers.first.id unless entity.identifiers.empty?
+
+          entity.short
         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
+        # Unitsdb::ExternalReference carries no `verified` flag in the
+        # 2.0 schema, so nothing is ever manually verified. Kept as a
+        # stub for callers; returns false unconditionally.
+        def manually_verified?(_entity)
+          false
         end
       end
     end

data/lib/unitsdb/commands/qudt.rb

@@ -12,11 +12,7 @@ module Unitsdb
       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"
-
+    class QudtCommand < Unitsdb::Commands::Thor
       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"
@@ -48,35 +44,6 @@ module Unitsdb
       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