unitsdb 2.1.1 → 2.2.2

data/lib/unitsdb/commands/validate.rb

@@ -4,16 +4,28 @@ require "thor"
 
 module Unitsdb
   module Commands
+    module Validate
+      autoload :Identifiers, "unitsdb/commands/validate/identifiers"
+      autoload :QudtReferences, "unitsdb/commands/validate/qudt_references"
+      autoload :References, "unitsdb/commands/validate/references"
+      autoload :SiReferences, "unitsdb/commands/validate/si_references"
+      autoload :UcumReferences, "unitsdb/commands/validate/ucum_references"
+    end
+
     class ValidateCommand < Thor
+      # Inherit trace option from parent CLI
+      class_option :trace, type: :boolean, default: false,
+                           desc: "Show full backtrace on error"
+
       desc "references", "Validate that all references exist"
-      option :debug_registry, type: :boolean, desc: "Show registry contents for debugging"
+      option :debug_registry, type: :boolean,
+                              desc: "Show registry contents for debugging"
       option :database, type: :string, required: true, aliases: "-d",
                         desc: "Path to UnitsDB database (required)"
-      option :print_valid, type: :boolean, default: false, desc: "Print valid references too"
+      option :print_valid, type: :boolean, default: false,
+                           desc: "Print valid references too"
       def references
-        require_relative "validate/references"
-
-        Commands::Validate::References.new(options).run
+        run_command(Commands::Validate::References, options)
       end
 
       desc "identifiers", "Check for uniqueness of identifier fields"
@@ -21,19 +33,63 @@ module Unitsdb
                         desc: "Path to UnitsDB database (required)"
 
       def identifiers
-        require_relative "validate/identifiers"
-
-        Commands::Validate::Identifiers.new(options).run
+        run_command(Commands::Validate::Identifiers, options)
       end
 
-      desc "si_references", "Validate that each SI digital framework reference is unique per entity type"
+      desc "si_references",
+           "Validate that each SI digital framework reference is unique per entity type"
       option :database, type: :string, required: true, aliases: "-d",
                         desc: "Path to UnitsDB database (required)"
 
       def si_references
-        require_relative "validate/si_references"
+        run_command(Commands::Validate::SiReferences, options)
+      end
+
+      desc "qudt_references",
+           "Validate that each QUDT reference is unique per entity type"
+      option :database, type: :string, required: true, aliases: "-d",
+                        desc: "Path to UnitsDB database (required)"
+
+      def qudt_references
+        run_command(Commands::Validate::QudtReferences, options)
+      end
+
+      desc "ucum_references",
+           "Validate that each UCUM reference is unique per entity type"
+      option :database, type: :string, required: true, aliases: "-d",
+                        desc: "Path to UnitsDB database (required)"
+
+      def ucum_references
+        run_command(Commands::Validate::UcumReferences, 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
 
-        Commands::Validate::SiReferences.new(options).run
+      def handle_error(error)
+        if options[:trace]
+          raise error
+        else
+          warn "Error: #{error.message}"
+          exit 1
+        end
       end
     end
   end

data/lib/unitsdb/commands.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Unitsdb
+  module Commands
+    autoload :ModifyCommand, "unitsdb/commands/_modify"
+    autoload :Base, "unitsdb/commands/base"
+    autoload :CheckSi, "unitsdb/commands/check_si"
+    autoload :CheckSiCommand, "unitsdb/commands/check_si"
+    autoload :Get, "unitsdb/commands/get"
+    autoload :Normalize, "unitsdb/commands/normalize"
+    autoload :Qudt, "unitsdb/commands/qudt"
+    autoload :QudtCommand, "unitsdb/commands/qudt"
+    autoload :Release, "unitsdb/commands/release"
+    autoload :Search, "unitsdb/commands/search"
+    autoload :Ucum, "unitsdb/commands/ucum"
+    autoload :UcumCommand, "unitsdb/commands/ucum"
+    autoload :Validate, "unitsdb/commands/validate"
+    autoload :ValidateCommand, "unitsdb/commands/validate"
+  end
+end

data/lib/unitsdb/config.rb

@@ -2,17 +2,129 @@
 
 module Unitsdb
   class Config
+    CONTEXT_ID = :unitsdb_v2
+
     class << self
+      def context_id
+        @context_id ||= CONTEXT_ID
+      end
+
+      def register_model(klass, id:)
+        registered_models[id.to_sym] = klass
+        klass
+      end
+
+      def registered_models
+        @registered_models ||= {}
+      end
+
       def models
         @models ||= {}
       end
 
       def models=(user_models)
-        models.merge!(user_models)
+        normalized_models = user_models.each_with_object({}) do |(id, klass), result|
+          model_id = id.to_sym
+          result[model_id] = register_model(klass, id: model_id)
+        end
+
+        models.merge!(normalized_models)
       end
 
       def model_for(model_name)
-        models[model_name]
+        model_id = model_name.to_sym
+        models[model_id] || registered_models[model_id]
+      end
+
+      def register(id = context_id)
+        explicit_registers[id.to_sym]
+      end
+
+      def populate_register(id: context_id, fallback_to: [:default], substitutions: [])
+        register_id = id.to_sym
+        context(register_id)
+
+        model_register = Lutaml::Model::Register.new(register_id, fallback: fallback_to)
+        resolve_substitutions(
+          substitutions,
+          registry: build_registry,
+          fallback_to: fallback_to,
+          id: "#{register_id}_register",
+        ).each do |substitution|
+          model_register.register_global_type_substitution(**substitution)
+        end
+
+        explicit_registers[register_id] = Lutaml::Model::GlobalRegister.register(model_register)
+      end
+
+      def find_context(id)
+        Lutaml::Model::GlobalContext.context(id.to_sym)
+      end
+
+      def resolve_type(type_name, context: context_id)
+        Lutaml::Model::GlobalContext.resolve_type(type_name, context.to_sym)
+      end
+
+      def context(id = context_id, force_populate: false)
+        existing = find_context(id)
+        return existing if existing && !force_populate && populated?(id)
+
+        populate_context(id: id)
+      end
+
+      def populate_context(id: context_id, fallback_to: [:default], substitutions: [])
+        Lutaml::Model::GlobalContext.unregister_context(id) if find_context(id)
+
+        opts = { registry: build_registry, fallback_to: fallback_to, id: id }
+        context = Lutaml::Model::GlobalContext.create_context(
+          substitutions: resolve_substitutions(substitutions, **opts),
+          **opts,
+        )
+        mark_populated!(id)
+        context
+      end
+
+      def resolve_substitutions(substitutions, registry:, fallback_to:, id:)
+        resolution_context = Lutaml::Model::TypeContext.derived(
+          id: "#{id}_substitution_resolution",
+          registry: registry,
+          fallback_to: fallback_to,
+        )
+
+        Array(substitutions).map do |substitution|
+          from_key = substitution[:from_type] || substitution[:from]
+          to_key = substitution[:to_type] || substitution[:to]
+
+          {
+            from_type: resolve_substitution_type(from_key, resolution_context),
+            to_type: resolve_substitution_type(to_key, resolution_context),
+          }
+        end
+      end
+
+      def resolve_substitution_type(value, resolution_context)
+        return value if value.is_a?(Class)
+
+        Lutaml::Model::TypeResolver.resolve(value, resolution_context)
+      end
+
+      def build_registry
+        registry = Lutaml::Model::TypeRegistry.new
+        registered_models.each { |model_id, klass| registry.register(model_id, klass) }
+        registry
+      end
+
+      def populated?(context_id)
+        @populated_for&.[](context_id.to_sym)
+      end
+
+      def mark_populated!(context_id)
+        @populated_for ||= {}
+        @populated_for[context_id.to_sym] = true
+      end
+
+      def explicit_registers
+        @explicit_registers ||= {}
       end
     end
   end