unitsdb 0.1.1 → 2.1.0

data/lib/unitsdb/cli.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "commands/validate"
+require_relative "commands/_modify"
+require "fileutils"
+
+module Unitsdb
+  class CLI < Thor
+    # Fix Thor deprecation warning
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "_modify SUBCOMMAND", "Commands that modify the database"
+    subcommand "_modify", Commands::ModifyCommand
+
+    desc "validate SUBCOMMAND", "Validate database files for different conditions"
+    subcommand "validate", Commands::ValidateCommand
+
+    desc "search QUERY", "Search for entities containing the given text"
+    option :type, type: :string, aliases: "-t",
+                  desc: "Entity type to search (units, prefixes, quantities, dimensions, unit_systems)"
+    option :id, type: :string, aliases: "-i",
+                desc: "Search for an entity with a specific identifier"
+    option :id_type, type: :string,
+                     desc: "Filter get_by_id search by identifier type"
+    option :format, type: :string, default: "text",
+                    desc: "Output format (text, json, yaml)"
+    option :database, type: :string, required: true, aliases: "-d",
+                      desc: "Path to UnitsDB database (required)"
+
+    def search(query)
+      require_relative "commands/search"
+      Commands::Search.new(options).run(query)
+    end
+
+    desc "get ID", "Get detailed information about an entity by ID"
+    option :id_type, type: :string,
+                     desc: "Filter by identifier type"
+    option :format, type: :string, default: "text",
+                    desc: "Output format (text, json, yaml)"
+    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)
+    end
+
+    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",
+                     desc: "Path to the directory containing SI digital framework TTL files"
+    option :output_updated_database, type: :string, aliases: "-o",
+                                     desc: "Directory path to write updated YAML files with added SI references"
+    option :direction, type: :string, default: "both", aliases: "-r",
+                       desc: "Direction to check: 'to_si' (UnitsDB→TTL), 'from_si' (TTL→UnitsDB), or 'both'"
+    option :include_potential_matches, type: :boolean, default: false, aliases: "-p",
+                                       desc: "Include potential matches when updating references (default: false)"
+    option :database, type: :string, required: true, aliases: "-d",
+                      desc: "Path to UnitsDB database (required)"
+
+    def check_si
+      require_relative "commands/check_si"
+      Commands::CheckSi.new(options).run
+    end
+
+    desc "release", "Create release files (unified YAML and/or ZIP archive)"
+    option :format, type: :string, default: "all", aliases: "-f",
+                    desc: "Output format: 'yaml' (single file), 'zip' (archive), or 'all' (both)"
+    option :output_dir, type: :string, default: ".", aliases: "-o",
+                        desc: "Directory to output release files"
+    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
+    end
+  end
+end

data/lib/unitsdb/commands/_modify.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+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: "short",
+                           desc: "Sort units by: 'short' (name), 'nist' (ID), 'unitsml' (ID), or 'none'"
+      method_option :database, type: :string, required: true, aliases: "-d",
+                               desc: "Path to UnitsDB database (required)"
+      method_option :all, type: :boolean, default: false, aliases: "-a",
+                          desc: "Process all YAML files in the repository"
+
+      def normalize(input = nil, output = nil)
+        require_relative "normalize"
+        Normalize.new(options).run(input, output)
+      end
+    end
+  end
+end

data/lib/unitsdb/commands/base.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "thor"
+require "yaml"
+require_relative "../utils"
+require_relative "../database"
+
+module Unitsdb
+  module Commands
+    class Base
+      def initialize(options = {})
+        @options = options
+      end
+
+      protected
+
+      def yaml_files(input = nil, opts = nil)
+        options_to_use = opts || @options
+
+        if options_to_use[:all]
+          Unitsdb::Utils::DEFAULT_YAML_FILES.map { |f| File.join(options_to_use[:database], f) }
+        elsif input
+          [input]
+        else
+          puts "Error: INPUT file is required when not using --all"
+          exit(1)
+        end
+      end
+
+      def load_database(database_path = nil)
+        path = database_path || @options[:database]
+
+        raise Unitsdb::Errors::DatabaseError, "Database path must be specified using the --database option" if path.nil?
+
+        Unitsdb::Database.from_db(path)
+      rescue Unitsdb::Errors::DatabaseError => e
+        puts "Error: #{e.message}"
+        exit(1)
+      end
+
+      def load_yaml(file_path)
+        return nil unless File.exist?(file_path)
+
+        YAML.safe_load(File.read(file_path))
+      end
+
+      def file_type(file_path)
+        File.basename(file_path, ".yaml")
+      end
+    end
+  end
+end

data/lib/unitsdb/commands/check_si.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "../database"
+require_relative "../errors"
+require_relative "si_ttl_parser"
+require_relative "si_formatter"
+require_relative "si_matcher"
+require_relative "si_updater"
+
+module Unitsdb
+  module Commands
+    class CheckSi < Base
+      # Constants
+      ENTITY_TYPES = %w[units quantities prefixes].freeze
+
+      def run
+        # Get options
+        entity_type = @options[:entity_type]&.downcase
+        direction = @options[:direction]&.downcase || "both"
+        output_dir = @options[:output_updated_database]
+        include_potential = @options[:include_potential_matches] || false
+        database_path = @options[:database]
+        ttl_dir = @options[:ttl_dir]
+
+        # Validate parameters
+        validate_parameters(direction, ttl_dir)
+
+        # Use the path as-is without expansion
+        puts "Using database directory: #{database_path}"
+
+        @db = Unitsdb::Database.from_db(database_path)
+
+        puts "Using TTL directory: #{ttl_dir}"
+        puts "Include potential matches: #{include_potential ? "Yes" : "No"}"
+
+        # Parse TTL files
+        graph = SiTtlParser.parse_ttl_files(ttl_dir)
+
+        # Process entity types
+        process_entities(entity_type, graph, direction, output_dir, include_potential)
+      end
+
+      private
+
+      # Process all entity types or a specific one
+      def process_entities(entity_type, graph, direction, output_dir, include_potential)
+        if entity_type && ENTITY_TYPES.include?(entity_type)
+          process_entity_type(entity_type, graph, direction, output_dir, include_potential)
+        else
+          ENTITY_TYPES.each do |type|
+            process_entity_type(type, graph, direction, output_dir, include_potential)
+          end
+        end
+      end
+
+      # Process a specific entity type
+      def process_entity_type(entity_type, graph, direction, output_dir, include_potential = false)
+        puts "\n========== Processing #{entity_type.upcase} References ==========\n"
+
+        db_entities = @db.send(entity_type)
+        ttl_entities = SiTtlParser.extract_entities_from_ttl(entity_type, graph)
+
+        puts "Found #{ttl_entities.size} #{entity_type} in SI digital framework"
+        puts "Found #{db_entities.size} #{entity_type} in database"
+
+        check_from_si(entity_type, ttl_entities, db_entities, output_dir, include_potential) if %w[from_si
+                                                                                                   both].include?(direction)
+
+        return unless %w[to_si both].include?(direction)
+
+        check_to_si(entity_type, ttl_entities, db_entities, output_dir, include_potential)
+      end
+
+      # Validation helpers
+      def validate_parameters(direction, ttl_dir)
+        unless %w[to_si from_si both].include?(direction)
+          puts "Invalid direction: #{direction}. Must be one of: to_si, from_si, both"
+          exit(1)
+        end
+
+        return if Dir.exist?(ttl_dir)
+
+        puts "TTL directory not found: #{ttl_dir}"
+        exit(1)
+      end
+
+      # Direction handler: TTL → DB
+      def check_from_si(entity_type, ttl_entities, db_entities, output_dir, include_potential = false)
+        SiFormatter.print_direction_header("SI → UnitsDB")
+
+        matches, missing_matches, unmatched_ttl = SiMatcher.match_ttl_to_db(entity_type, ttl_entities, db_entities)
+
+        # Print results
+        SiFormatter.display_si_results(entity_type, matches, missing_matches, unmatched_ttl)
+
+        # Update references if needed
+        return unless output_dir && !missing_matches.empty?
+
+        output_file = File.join(output_dir, "#{entity_type}.yaml")
+        SiUpdater.update_references(entity_type, missing_matches, db_entities, output_file, include_potential,
+                                    database_path)
+        puts "\nUpdated references written to #{output_file}"
+      end
+
+      # Direction handler: DB → TTL
+      def check_to_si(entity_type, ttl_entities, db_entities, output_dir, include_potential = false)
+        SiFormatter.print_direction_header("UnitsDB → SI")
+
+        matches, missing_refs, unmatched_db = SiMatcher.match_db_to_ttl(entity_type, ttl_entities, db_entities)
+
+        # Print results
+        SiFormatter.display_db_results(entity_type, matches, missing_refs, unmatched_db)
+
+        # Update references if needed
+        return unless output_dir && !missing_refs.empty?
+
+        output_file = File.join(output_dir, "#{entity_type}.yaml")
+        SiUpdater.update_db_references(entity_type, missing_refs, output_file, include_potential, @options[:database])
+        puts "\nUpdated references written to #{output_file}"
+      end
+    end
+  end
+end

data/lib/unitsdb/commands/get.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "json"
+require_relative "../errors"
+
+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
+
+          # Output based on format
+          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
+
+          # Default text output
+          print_entity_details(entity)
+        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_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.uri}"
+        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
+    end
+  end
+end

data/lib/unitsdb/commands/normalize.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require "yaml"
+
+module Unitsdb
+  module Commands
+    class Normalize < Base
+      def run(input = nil, output = nil)
+        unless @options[:all] || (input && output)
+          puts "Error: INPUT and OUTPUT are required when not using --all"
+          exit(1)
+        end
+
+        if @options[:all]
+          Unitsdb::Utils::DEFAULT_YAML_FILES.each do |file|
+            path = File.join(@options[:database], file)
+            next unless File.exist?(path)
+
+            normalize_file(path, path)
+            puts "Normalized #{path}"
+          end
+          puts "All YAML files normalized successfully!"
+        end
+
+        return unless input && output
+
+        normalize_file(input, output)
+        puts "Normalized YAML written to #{output}"
+      end
+
+      private
+
+      def normalize_file(input, output)
+        # Load the original YAML to work with
+        yaml = load_yaml(input)
+
+        # For schema 2.0.0, we need to handle the schema_version and the main collection key
+        if yaml.key?("schema_version") && yaml["schema_version"] == "2.0.0"
+          # Get the collection key (units, scales, etc.)
+          collection_key = (yaml.keys - ["schema_version"]).first
+
+          # Sort the collection items if requested
+          if @options[:sort] && @options[:sort] != "none" && collection_key
+            # Sort the collection items based on the sort option
+            case @options[:sort]
+            when "nist", "unitsml"
+              # Sort by ID (nist or unitsml)
+              id_type = @options[:sort]
+              yaml[collection_key] = sort_by_id_type(yaml[collection_key], id_type)
+            else # default to "short"
+              # Use the existing sort_yaml_keys method for default sorting
+              yaml[collection_key] = Unitsdb::Utils.sort_yaml_keys(yaml[collection_key])
+            end
+          end
+        elsif @options[:sort] && @options[:sort] != "none"
+          # For any other format, just sort all keys
+          yaml = Unitsdb::Utils.sort_yaml_keys(yaml)
+        end
+
+        # Write the normalized output
+        File.write(output, yaml.to_yaml)
+      end
+
+      # Sort collection items by a specific ID type (nist or unitsml)
+      def sort_by_id_type(collection, id_type)
+        return collection unless collection.is_a?(Array)
+
+        collection.sort_by do |item|
+          # Find the identifier of the specified type
+          identifier = if item.key?("identifiers") && item["identifiers"].is_a?(Array)
+                         item["identifiers"].find { |id| id["type"] == id_type }
+                       end
+
+          # Use the ID if found, otherwise use a placeholder to sort to the end
+          identifier ? identifier["id"].to_s : "zzzzz"
+        end.map { |item| Unitsdb::Utils.sort_yaml_keys(item) }
+      end
+    end
+  end
+end

data/lib/unitsdb/commands/release.rb

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