unitsdb 2.2.2 → 2.2.4

data/lib/unitsdb/commands/search.rb

@@ -1,219 +1,64 @@
 # frozen_string_literal: true
 
-require "json"
-
 module Unitsdb
   module Commands
     class Search < Base
       def run(query)
-        # Database path is guaranteed by Thor's global option
-
         type = @options[:type]
         id = @options[:id]
         id_type = @options[:id_type]
         format = @options[:format] || "text"
 
-        begin
-          database = load_database(@options[:database])
-
-          # Search by ID (early return)
-          if id
-            entity = database.get_by_id(id: id, type: id_type)
-
-            unless entity
-              puts "No entity found with ID: '#{id}'"
-              return
-            end
-
-            # Use the same output logic as the Get command
-            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
-
-            print_entity_details(entity)
-            return
-          end
-
-          # Regular text search
-          results = database.search(text: query, type: type)
-
-          # Early return for empty results
-          if results.empty?
-            puts "No results found for '#{query}'"
-            return
-          end
-
-          # Format-specific output
-          if %w[json yaml].include?(format.downcase)
-            temp_db = create_temporary_database(results)
-            puts temp_db.send("to_#{format.downcase}")
-            return
-          end
+        database = load_database(@options[:database])
 
-          # Default text output
-          puts "Found #{results.size} result(s) for '#{query}':"
-          results.each do |entity|
-            print_entity_with_ids(entity)
-          end
-        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 id
+          lookup_by_id(database, id, id_type, format)
+          return
         end
-      end
-
-      private
-
-      def print_entity_with_ids(entity)
-        # Determine entity type
-        entity_type = get_entity_type(entity)
-
-        # Get name
-        name = get_entity_name(entity)
 
-        # Get all identifiers
-        identifiers = entity.identifiers || []
-
-        # Print entity information
-        puts "  - #{entity_type}: #{name}"
-
-        # Print each identifier on its own line for better readability
-        if identifiers.empty?
-          puts "    ID: None"
-        else
-          puts "    IDs:"
-          identifiers.each do |id|
-            puts "      - #{id.id} (Type: #{id.type || 'N/A'})"
-          end
+        results = database.search(text: query, type: type)
+        if results.empty?
+          puts "No results found for '#{query}'"
+          return
         end
 
-        # If entity has a short description, print it
-        puts "    Description: #{entity.short}" if entity.respond_to?(:short) && entity.short && entity.short != name
-
-        # Add a blank line for readability
-        puts ""
+        print_results(results, query, format)
+      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}"
       end
 
-      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
-        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?
+      private
 
-        puts "  - References:"
-        entity.references.each do |ref|
-          puts "      - #{ref.type}: #{ref.id}"
+      def lookup_by_id(database, id, id_type, format)
+        entity = database.get_by_id(id: id, type: id_type)
+        if entity.nil?
+          puts "No entity found with ID: '#{id}'"
+          return
         end
-      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"
+        if %w[json yaml].include?(format.downcase)
+          print_serialized(entity, format.downcase)
         else
-          "Unknown"
+          EntityPresenter.new(entity).print_details
         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
+      def print_results(results, query, format)
+        if %w[json yaml].include?(format.downcase)
+          temp_db = Database.empty_for_results(results)
+          print_serialized(temp_db, format.downcase)
+          return
+        end
 
-        "N/A" # Default if no name found
+        puts "Found #{results.size} result(s) for '#{query}':"
+        results.each { |entity| EntityPresenter.new(entity).print_summary }
       end
 
-      def create_temporary_database(results)
-        temp_db = Unitsdb::Database.new
-
-        # Initialize collections
-        temp_db.units = []
-        temp_db.prefixes = []
-        temp_db.quantities = []
-        temp_db.dimensions = []
-        temp_db.unit_systems = []
-
-        # Add results to appropriate collection based on type using case statement
-        results.each do |entity|
-          case entity
-          when Unitsdb::Unit
-            temp_db.units << entity
-          when Unitsdb::Prefix
-            temp_db.prefixes << entity
-          when Unitsdb::Quantity
-            temp_db.quantities << entity
-          when Unitsdb::Dimension
-            temp_db.dimensions << entity
-          when Unitsdb::UnitSystem
-            temp_db.unit_systems << entity
-          end
-        end
-
-        temp_db
+      def print_serialized(entity, format)
+        puts entity.public_send("to_#{format}")
       end
     end
   end

data/lib/unitsdb/commands/thor.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Unitsdb
+  module Commands
+    # Base class for every Thor-based CLI surface in the gem. Owns the
+    # shared `--trace` option, the `exit_on_failure?` policy, the
+    # `run_command` dispatch helper, and the single error handler
+    # (`handle_error`). Subclasses inherit these and provide only their
+    # own `desc`/`option`/subcommand declarations.
+    class Thor < ::Thor
+      class_option :trace, type: :boolean, default: false,
+                           desc: "Show full backtrace on error"
+
+      def self.exit_on_failure?
+        true
+      end
+
+      private
+
+      # Instantiate `command_class` with `options` plus any extra
+      # positional args, then call its `run` (or other public method).
+      # All exceptions route through `handle_error`.
+      def run_command(command_class, options, *args, method: :run)
+        command_class.new(options).public_send(method, *args)
+      rescue StandardError => e
+        handle_error(e)
+      end
+
+      # Re-raise when `--trace` is set so the user sees the full
+      # backtrace. Otherwise warn-and-exit-1 for a clean CLI UX.
+      def handle_error(error)
+        raise error if options[:trace]
+
+        warn "Error: #{error.message}"
+        exit 1
+      end
+    end
+  end
+end

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

@@ -48,7 +48,7 @@ unmatched_ucum)
             db_id = get_db_entity_id(db_entity)
             db_name = get_db_entity_name(db_entity)
             ucum_name = get_ucum_entity_name(ucum_entity)
-            ucum_code = ucum_entity.respond_to?(:code_sensitive) ? ucum_entity.code_sensitive : "unknown"
+            ucum_code = ucum_entity.code_sensitive || "unknown"
 
             case ucum_entity
             when Unitsdb::UcumPrefix
@@ -88,7 +88,7 @@ unmatched_ucum)
             db_id = get_db_entity_id(db_entity)
             db_name = get_db_entity_name(db_entity)
             ucum_name = get_ucum_entity_name(ucum_entity)
-            ucum_code = ucum_entity.respond_to?(:code_sensitive) ? ucum_entity.code_sensitive : "unknown"
+            ucum_code = ucum_entity.code_sensitive || "unknown"
 
             case ucum_entity
             when Unitsdb::UcumPrefix
@@ -103,26 +103,17 @@ unmatched_ucum)
 
         # 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 ucum entity name

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

@@ -70,14 +70,14 @@ module Unitsdb
 
         # Check if a UnitsDB entity already has a UCUM reference
         def has_ucum_reference?(entity)
-          return false unless entity.respond_to?(:references) && entity.references
+          return false unless entity.references
 
           entity.references.any? { |ref| ref.authority == "ucum" }
         end
 
         # Find the referenced UCUM entity based on the reference URI
         def find_referenced_ucum_entity(db_entity, ucum_entities)
-          return nil unless db_entity.respond_to?(:references) && db_entity.references
+          return nil unless db_entity.references
 
           ucum_ref = db_entity.references.find { |ref| ref.authority == "ucum" }
           return nil unless ucum_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 UCUM entity

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

@@ -120,11 +120,9 @@ 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
       end
     end

data/lib/unitsdb/commands/ucum.rb

@@ -13,11 +13,7 @@ module Unitsdb
       autoload :XmlParser, "unitsdb/commands/ucum/xml_parser"
     end
 
-    class UcumCommand < Thor
-      # Inherit trace option from parent CLI
-      class_option :trace, type: :boolean, default: false,
-                           desc: "Show full backtrace on error"
-
+    class UcumCommand < Unitsdb::Commands::Thor
       desc "check", "Check UCUM references in UnitsDB"
       option :entity_type, type: :string, aliases: "-e",
                            desc: "Entity type to check (units, prefixes). If not specified, all types are checked"
@@ -49,35 +45,6 @@ module Unitsdb
       def update
         run_command(Ucum::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/validate/qudt_references.rb

@@ -3,16 +3,15 @@
 module Unitsdb
   module Commands
     module Validate
+      # `unitsdb validate qudt_references`. Checks that no QUDT
+      # reference URI is used by more than one entity of a given type.
       class QudtReferences < Unitsdb::Commands::Base
+        AUTHORITY = "qudt"
+
         def run
-          # Load the database
           db = load_database(@options[:database])
-
-          # Check for duplicate QUDT references
-          duplicates = check_qudt_references(db)
-
-          # Display results
-          display_duplicate_results(duplicates)
+          duplicates = scan(db)
+          display(duplicates)
         rescue Unitsdb::Errors::DatabaseError => e
           raise Unitsdb::Errors::ValidationError,
                 "Failed to validate QUDT references: #{e.message}"
@@ -20,90 +19,50 @@ module Unitsdb
 
         private
 
-        def check_qudt_references(db)
-          duplicates = {}
-
-          # Check units
-          check_entity_qudt_references(db.units, "units", duplicates)
-
-          # Check quantities
-          check_entity_qudt_references(db.quantities, "quantities", duplicates)
-
-          # Check dimensions
-          check_entity_qudt_references(db.dimensions, "dimensions", duplicates)
-
-          # Check unit_systems
-          check_entity_qudt_references(db.unit_systems, "unit_systems",
-                                       duplicates)
-
-          duplicates
+        def scan(db)
+          {}.tap do |duplicates|
+            Unitsdb::Database::COLLECTIONS.each do |name|
+              collection = db.collection(name) || []
+              dup = scan_collection(collection)
+              duplicates[name.to_s] = dup unless dup.empty?
+            end
+          end
         end
 
-        def check_entity_qudt_references(entities, entity_type, duplicates)
-          # Track QUDT references by URI
-          qudt_refs = {}
-
+        def scan_collection(entities)
+          by_uri = {}
           entities.each_with_index do |entity, index|
-            # Skip if no references
-            next unless entity.respond_to?(:references) && entity.references
-
-            # Check each reference
-            entity.references.each do |ref|
-              # Only interested in qudt references
-              next unless ref.authority == "qudt"
-
-              # Get entity info for display
-              entity_id = if entity.respond_to?(:identifiers) && entity.identifiers&.first.respond_to?(:id)
-                            entity.identifiers.first.id
-                          else
-                            entity.short
-                          end
+            refs = entity.references || []
+            refs.each do |ref|
+              next unless ref.authority == AUTHORITY
 
-              # Track this reference
-              qudt_refs[ref.uri] ||= []
-              qudt_refs[ref.uri] << {
-                entity_id: entity_id,
-                entity_name: entity.respond_to?(:names) ? entity.names.first : entity.short,
+              (by_uri[ref.uri] ||= []) << {
+                entity_id: entity.identifiers.first&.id || entity.short,
+                entity_name: entity.names.first&.value || entity.short,
                 index: index,
               }
             end
           end
-
-          # Find duplicates (URIs with more than one entity)
-          qudt_refs.each do |uri, entities|
-            next unless entities.size > 1
-
-            # Record this duplicate
-            duplicates[entity_type] ||= {}
-            duplicates[entity_type][uri] = entities
-          end
+          by_uri.reject { |_, refs| refs.size == 1 }
         end
 
-        def display_duplicate_results(duplicates)
+        def display(duplicates)
           if duplicates.empty?
-            puts "No duplicate QUDT references found! Each QUDT reference URI is used by at most one entity of each type."
+            puts "No duplicate QUDT references found! " \
+                 "Each QUDT reference URI is used by at most one entity of each type."
             return
           end
 
           puts "Found duplicate QUDT references:"
-
           duplicates.each do |entity_type, uri_duplicates|
             puts "\n  #{entity_type.capitalize}:"
-
-            uri_duplicates.each do |uri, entities|
+            uri_duplicates.each do |uri, refs|
               puts "    QUDT URI: #{uri}"
-              puts "    Used by #{entities.size} entities:"
-
-              entities.each do |entity|
-                puts "      - #{entity[:entity_id]} (#{entity[:entity_name]}) at index #{entity[:index]}"
-              end
+              puts "    Used by #{refs.size} entities:"
+              refs.each { |r| puts "      - #{r[:entity_id]} (#{r[:entity_name]}) at index #{r[:index]}" }
               puts ""
             end
           end
-
-          puts "\nEach QUDT reference should be used by at most one entity of each type."
-          puts "Please fix the duplicates by either removing the reference from all but one entity,"
-          puts "or by updating the references to use different URIs appropriate for each entity."
         end
       end
     end