unitsdb 0.1.1 → 2.1.0

data/lib/unitsdb/commands/search.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "json"
+require_relative "../errors"
+
+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
+                puts "Error: Unable to convert entity to #{format} format"
+                exit(1)
+              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
+
+          # 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
+          puts "Error: #{e.message}"
+          exit(1)
+        rescue StandardError => e
+          puts "Error searching database: #{e.message}"
+          exit(1)
+        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
+        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 ""
+      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?
+          entity.symbols.each { |s| puts "      - #{s}" } if entity.respond_to?(:symbols) && entity.symbols&.any?
+
+          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.id}"
+        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"
+        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
+
+        "N/A" # Default if no name found
+      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
+      end
+    end
+  end
+end

data/lib/unitsdb/commands/si_formatter.rb

@@ -0,0 +1,485 @@
+# frozen_string_literal: true
+
+require "terminal-table"
+require_relative "si_ttl_parser"
+
+module Unitsdb
+  module Commands
+    # 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::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::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::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