oscal 0.2.2 → 0.4.0

data/lib/oscal/v1_2_1.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "metaschema"
+
+module Oscal
+  # OSCAL 1.2.1 version module.
+  #
+  # Contains all model classes for OSCAL version 1.2.1.
+  # Classes are pre-generated from the OSCAL metaschema and loaded
+  # from lib/oscal/v1_2_1/*.rb.
+  module V1_2_1
+    extend Oscal::Versioned
+
+    def self.register_id
+      :oscal_1_2_1
+    end
+
+    def self.oscal_version
+      "1.2.1"
+    end
+
+    def self.fallback_registers
+      %i[oscal_common default]
+    end
+
+    # Maps clean class names to ModelGenerator keys.
+    ROOT_CLASS_KEYS = {
+      "Catalog" => "Assembly_catalog",
+      "Profile" => "Assembly_profile",
+      "ComponentDefinition" => "Assembly_component_definition",
+      "SystemSecurityPlan" => "Assembly_system_security_plan",
+      "AssessmentPlan" => "Assembly_assessment_plan",
+      "AssessmentResults" => "Assembly_assessment_results",
+      "PlanOfActionAndMilestones" => "Assembly_plan_of_action_and_milestones",
+      "MappingCollection" => "Assembly_mapping_collection",
+    }.freeze
+
+    def self.register_models!
+      load_pre_generated
+    end
+
+    # Load pre-generated model files from lib/oscal/v1_2_1/
+    def self.load_pre_generated
+      dir = File.join(__dir__, "v1_2_1")
+      if Dir.exist?(dir) && !Dir.empty?(dir)
+        Dir[File.join(dir, "*.rb")].sort.each { |f| require f }
+      else
+        # Fall back to runtime generation if pre-generated files don't exist
+        generate_runtime
+      end
+
+      # Register all classes with the version register
+      register_all_classes
+    end
+
+    # Generate classes at runtime from the OSCAL metaschema.
+    def self.generate_runtime
+      metaschema_path = find_metaschema("oscal_complete_metaschema.xml")
+      return unless metaschema_path
+
+      @runtime_classes = Metaschema::ModelGenerator.generate_from_file(metaschema_path)
+
+      # Expose as constants on this module
+      @runtime_classes.each do |key, klass|
+        const_name = class_key_to_const_name(key)
+        const_set(const_name, klass) unless const_defined?(const_name)
+      end
+    end
+
+    # Register all loaded classes with this version's register.
+    def self.register_all_classes
+      constants.each do |const_name|
+        klass = const_get(const_name)
+        next unless klass.is_a?(Class) && klass < Lutaml::Model::Serializable
+
+        register.register_model(klass)
+      end
+    end
+
+    # Resolve a class by clean name or ModelGenerator key.
+    def self.resolve_class(name)
+      const_get(name) if const_defined?(name)
+    end
+
+    private
+
+    def self.find_metaschema(filename)
+      paths = [
+        # Local submodule first
+        File.expand_path("../../fixtures/oscal/src/metaschema/#{filename}", __dir__),
+        # Sibling metaschema repo
+        File.expand_path("../../../metaschema/spec/fixtures/oscal/src/metaschema/#{filename}", __dir__),
+        File.expand_path("../../../../metaschema/spec/fixtures/oscal/src/metaschema/#{filename}", __dir__),
+      ]
+
+      paths.find { |p| File.exist?(p) }
+    end
+
+    def self.class_key_to_const_name(key)
+      parts = key.sub(/\A(Assembly|Field|Flag)_/, "").split("_")
+      name = parts.map(&:capitalize).join
+      # Avoid conflicts with Ruby built-ins
+      name = "#{name}Field" if %w[Hash Method Object Class Module].include?(name)
+      name
+    end
+  end
+
+  VersionRegistry.register_version("1.2.1", V1_2_1)
+end

data/lib/oscal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Oscal
-  VERSION = "0.2.2"
+  VERSION = "0.4.0"
 end

data/lib/oscal/version_registry.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Oscal
+  # Registry for OSCAL version-specific model trees.
+  #
+  # Manages the mapping between OSCAL version strings and their modules.
+  # Version detection is based on the <oscal-version> element in the
+  # document's metadata, not on XML namespace (all OSCAL versions share
+  # the same namespace: http://csrc.nist.gov/ns/oscal/1.0).
+  #
+  # @example
+  #   # Get register for OSCAL 1.2.1
+  #   register = Oscal::VersionRegistry.register_for_version("1.2.1")
+  #
+  # @example
+  #   # Detect version from an OSCAL document
+  #   version = Oscal::VersionRegistry.detect_version(xml_string)
+  module VersionRegistry
+    @versions = {}
+
+    class << self
+      # Register a version module.
+      #
+      # @param version [String] OSCAL version string (e.g., "1.2.1")
+      # @param mod [Module] The version module (e.g., Oscal::V1_2_1)
+      def register_version(version, mod)
+        @versions = @versions.merge(version => mod)
+      end
+
+      # Get the version module for a version string.
+      #
+      # @param version [String] OSCAL version string
+      # @return [Module, nil]
+      def version_module(version)
+        @versions[version]
+      end
+
+      # Get the register for a specific OSCAL version.
+      #
+      # @param version [String] OSCAL version string
+      # @return [Lutaml::Model::Register, nil]
+      def register_for_version(version)
+        mod = @versions[version]
+        return nil unless mod
+
+        mod.init_models! unless mod.initialized?
+        mod.register
+      end
+
+      # Get the latest registered version module.
+      #
+      # @return [Module, nil]
+      def latest_module
+        return nil if @versions.empty?
+
+        @versions.values.last
+      end
+
+      # Get the latest register (initializes if needed).
+      #
+      # @return [Lutaml::Model::Register, nil]
+      def latest_register
+        mod = latest_module
+        return nil unless mod
+
+        mod.init_models! unless mod.initialized?
+        mod.register
+      end
+
+      # All registered version strings, sorted.
+      #
+      # @return [Array<String>]
+      def available_versions
+        @versions.keys.sort
+      end
+
+      # Detect OSCAL version from a document string (XML, JSON, or YAML).
+      #
+      # Looks for the "oscal-version" field in the document's metadata.
+      #
+      # @param content [String] Document content
+      # @return [String, nil] Detected version string
+      def detect_version(content)
+        return nil if content.nil? || content.strip.empty?
+
+        if content.lstrip.start_with?("<")
+          detect_version_xml(content)
+        elsif content.lstrip.start_with?("{")
+          detect_version_json(content)
+        else
+          detect_version_yaml(content)
+        end
+      rescue StandardError
+        nil
+      end
+
+      # Detect the root model type from a document.
+      #
+      # @param content [String] Document content
+      # @return [Symbol, nil] Model type (:catalog, :profile, etc.)
+      def detect_model_type(content)
+        return nil if content.nil? || content.strip.empty?
+
+        if content.lstrip.start_with?("<")
+          detect_model_type_xml(content)
+        elsif content.lstrip.start_with?("{")
+          detect_model_type_json(content)
+        else
+          detect_model_type_yaml(content)
+        end
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def detect_version_xml(xml)
+        doc = Nokogiri::XML(xml, &:noblanks)
+        node = doc.at_xpath("//*[local-name()='oscal-version']")
+        node&.text&.strip
+      end
+
+      def detect_version_json(json_str)
+        data = JSON.parse(json_str)
+        # OSCAL JSON wraps in a root key
+        root_key = data.keys.first
+        metadata = data[root_key]&.dig("metadata")
+        metadata&.dig("oscal-version")
+      end
+
+      def detect_version_yaml(yaml_str)
+        require "yaml"
+        data = YAML.safe_load(yaml_str, permitted_classes: [Date, Time, Symbol])
+        return nil unless data.is_a?(Hash)
+
+        root_key = data.keys.first
+        metadata = data[root_key]&.dig("metadata")
+        metadata&.dig("oscal-version")
+      end
+
+      ROOT_ELEMENTS = %w[
+        catalog profile component-definition
+        system-security-plan assessment-plan
+        assessment-results plan-of-action-and-milestones
+        mapping-collection
+      ].freeze
+
+      ROOT_KEY_MAP = {
+        "catalog" => :catalog,
+        "profile" => :profile,
+        "component-definition" => :component_definition,
+        "system-security-plan" => :system_security_plan,
+        "assessment-plan" => :assessment_plan,
+        "assessment-results" => :assessment_results,
+        "plan-of-action-and-milestones" => :plan_of_action_and_milestones,
+        "mapping-collection" => :mapping_collection,
+      }.freeze
+
+      def detect_model_type_xml(xml)
+        doc = Nokogiri::XML(xml, &:noblanks)
+        root_name = doc.root&.name
+        ROOT_KEY_MAP[root_name]
+      end
+
+      def detect_model_type_json(json_str)
+        data = JSON.parse(json_str)
+        root_key = data.keys.first
+        ROOT_KEY_MAP[root_key]
+      end
+
+      def detect_model_type_yaml(yaml_str)
+        require "yaml"
+        data = YAML.safe_load(yaml_str, permitted_classes: [Date, Time, Symbol])
+        return nil unless data.is_a?(Hash)
+
+        root_key = data.keys.first
+        ROOT_KEY_MAP[root_key]
+      end
+    end
+  end
+end

data/lib/oscal/versioned.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Oscal
+  # Base module for version-specific OSCAL model trees.
+  #
+  # Each version module (V1_2_1, V1_3_0, etc.) extends this
+  # and provides its own register.
+  #
+  # Unlike XMI which uses namespace-based version detection, OSCAL
+  # uses schema-version-based detection (the <oscal-version> element
+  # in metadata). All OSCAL versions share the same XML namespace.
+  #
+  # @example
+  #   module Oscal::V1_2_1
+  #     extend Oscal::Versioned
+  #
+  #     def self.register_id
+  #       :oscal_1_2_1
+  #     end
+  #
+  #     def self.oscal_version
+  #       "1.2.1"
+  #     end
+  #
+  #     def self.fallback_registers
+  #       %i[oscal_common default]
+  #     end
+  #
+  #     def self.register_models!
+  #       # Load pre-generated or runtime-generated classes
+  #     end
+  #   end
+  module Versioned
+    def self.extended(base)
+      base.instance_eval do
+        @register = nil
+        @initialized = false
+      end
+    end
+
+    # The version-specific register for type resolution.
+    def register
+      @register ||= create_register
+    end
+
+    # Create and configure the register with fallback chain.
+    def create_register
+      reg = Lutaml::Model::Register.new(register_id,
+                                        fallback: fallback_registers)
+      Lutaml::Model::GlobalRegister.register(reg)
+      reg
+    end
+
+    # Initialize this version's model tree. Safe to call multiple times.
+    def init_models!
+      return if @initialized
+
+      register
+      register_models!
+      @initialized = true
+    end
+
+    # Override in each version module to load/register model classes.
+    def register_models!
+      raise NotImplementedError, "Each version must implement #register_models!"
+    end
+
+    # Override: the register ID symbol for this version.
+    def register_id
+      raise NotImplementedError, "Each version must implement #register_id"
+    end
+
+    # Override: the OSCAL version string (e.g., "1.2.1").
+    def oscal_version
+      raise NotImplementedError, "Each version must implement #oscal_version"
+    end
+
+    # Override: fallback register IDs for type resolution.
+    # Default chain: common types, then global default.
+    def fallback_registers
+      %i[oscal_common default]
+    end
+
+    def initialized?
+      @initialized
+    end
+  end
+end

data/lib/oscal.rb

@@ -1,10 +1,100 @@
 # frozen_string_literal: true
 
-Dir[File.join(__dir__, "oscal", "*.rb")].each { |file| require file }
+require_relative "oscal/version"
+require_relative "oscal/versioned"
+require_relative "oscal/version_registry"
+require "lutaml/model"
 
+# Oscal provides a clean facade for OSCAL model access.
+#
+# Usage:
+#   require "oscal"
+#
+#   # Default version (latest) — auto-resolves constants
+#   catalog = Oscal::Catalog.from_xml(File.read("catalog.xml"))
+#
+#   # Explicit version
+#   v121 = Oscal.version("1.2.1")
+#   catalog = v121::Catalog.from_xml(xml)
+#
+#   # Auto-detect version and parse
+#   doc = Oscal.parse(File.read("catalog.xml"))
+#
 module Oscal
   class Error < StandardError; end
 
-  class UnknownAttributeError < Error; end
-  class InvalidTypeError < Error; end
+  @default_version = nil
+
+  class << self
+    # Load the default version module. Called lazily on first access.
+    def default_version_module
+      @default_version_module ||= begin
+        require_relative "oscal/v1_2_1"
+        VersionRegistry.latest_module
+      end
+    end
+
+    # Use a specific OSCAL version.
+    #
+    # @param version_string [String] OSCAL version (e.g., "1.2.1")
+    # @return [Module] The version module
+    def version(version_string)
+      mod = VersionRegistry.version_module(version_string)
+      raise Error, "Unknown OSCAL version: #{version_string}" unless mod
+
+      mod.init_models! unless mod.initialized?
+      mod
+    end
+
+    # Parse an OSCAL document with automatic version detection.
+    #
+    # @param content [String] XML, JSON, or YAML string
+    # @param model [Symbol] Model type (:catalog, :profile, etc.)
+    # @return [Lutaml::Model::Serializable] Parsed instance
+    def parse(content, model: nil)
+      version = VersionRegistry.detect_version(content)
+      if version
+        ver_mod = VersionRegistry.version_module(version)
+        if ver_mod
+          ver_mod.init_models! unless ver_mod.initialized?
+          register = ver_mod.register
+        end
+      end
+
+      ver_mod ||= default_version_module
+      register ||= ver_mod.register
+
+      model_type = model || VersionRegistry.detect_model_type(content)
+      raise Error, "Cannot detect model type. Specify with model: :catalog" unless model_type
+
+      class_name = model_type.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }
+      klass = ver_mod.resolve_class(class_name)
+      raise Error, "Unknown model type: #{class_name}" unless klass
+
+      if content.lstrip.start_with?("<")
+        register ? klass.from_xml(content, register: register) : klass.from_xml(content)
+      elsif content.lstrip.start_with?("{")
+        klass.from_json(content)
+      else
+        klass.from_yaml(content)
+      end
+    rescue StandardError => e
+      raise Error, "Failed to parse OSCAL document: #{e.message}"
+    end
+
+    # Resolve missing constants from the default version module.
+    def const_missing(name)
+      name_s = name.to_s
+      mod = default_version_module
+      mod.init_models! unless mod.initialized?
+
+      if mod.const_defined?(name_s)
+        klass = mod.const_get(name_s)
+        const_set(name, klass)
+        klass
+      else
+        super
+      end
+    end
+  end
 end

metadata

@@ -1,138 +1,66 @@
 --- !ruby/object:Gem::Specification
 name: oscal
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Ribose Inc.
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-06-30 00:00:00.000000000 Z
+date: 2026-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: yaml
+  name: lutaml-model
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: Ruby library and parser for OSCAL models
+        version: 0.8.0
+- !ruby/object:Gem::Dependency
+  name: metaschema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+description: Ruby library for OSCAL (Open Security Controls Assessment Language) models.
+  Supports XML, JSON, and YAML serialization via metaschema-driven generation.
 email:
 - open.source@ribose.com
-executables:
-- convert2oscalyaml.rb
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".docker/Dockerfile"
-- ".docker/Makefile"
-- ".docker/docker-compose.yml"
-- ".docker/readme.md"
-- ".github/workflows/rake.yml"
-- ".github/workflows/release.yml"
-- ".gitignore"
-- ".gitmodules"
-- ".hound.yml"
-- ".rspec"
-- ".rubocop.yml"
-- ".ruby-version"
-- CODE_OF_CONDUCT.md
-- Gemfile
-- LICENSE
-- Makefile
-- README.adoc
-- Rakefile
-- bin/console
-- bin/rspec
-- bin/setup
-- docker-compose.yml
-- exe/convert2oscalyaml.rb
 - lib/oscal.rb
-- lib/oscal/add.rb
-- lib/oscal/address.rb
-- lib/oscal/address_line.rb
-- lib/oscal/alter.rb
-- lib/oscal/assembly.rb
-- lib/oscal/assessment_plan.rb
-- lib/oscal/assessment_result.rb
-- lib/oscal/attribute_type_hash.rb
-- lib/oscal/back_matter.rb
-- lib/oscal/base64_object.rb
-- lib/oscal/base_class.rb
-- lib/oscal/catalog.rb
-- lib/oscal/choice.rb
-- lib/oscal/citation.rb
-- lib/oscal/combine.rb
-- lib/oscal/common_utils.rb
-- lib/oscal/constraint.rb
-- lib/oscal/control.rb
-- lib/oscal/custom.rb
-- lib/oscal/datatypes.rb
-- lib/oscal/document_id.rb
-- lib/oscal/email_address.rb
-- lib/oscal/exclude_control.rb
-- lib/oscal/external_id.rb
-- lib/oscal/group.rb
-- lib/oscal/guideline.rb
-- lib/oscal/hash_object.rb
-- lib/oscal/import_object.rb
-- lib/oscal/include_control.rb
-- lib/oscal/insert_control.rb
-- lib/oscal/link.rb
-- lib/oscal/list.rb
-- lib/oscal/location.rb
-- lib/oscal/location_uuid.rb
-- lib/oscal/logger.rb
-- lib/oscal/matching.rb
-- lib/oscal/member_of_organization.rb
-- lib/oscal/merge.rb
-- lib/oscal/metadata_block.rb
-- lib/oscal/modify.rb
-- lib/oscal/parameter.rb
-- lib/oscal/parsing_functions.rb
-- lib/oscal/part.rb
-- lib/oscal/party.rb
-- lib/oscal/party_uuid.rb
-- lib/oscal/profile.rb
-- lib/oscal/property.rb
-- lib/oscal/remove.rb
-- lib/oscal/resource.rb
-- lib/oscal/responsible_party.rb
-- lib/oscal/revision.rb
-- lib/oscal/rlink.rb
-- lib/oscal/role.rb
-- lib/oscal/select.rb
-- lib/oscal/serializer.rb
-- lib/oscal/set_parameter.rb
-- lib/oscal/telephone_number.rb
-- lib/oscal/test.rb
-- lib/oscal/url.rb
-- lib/oscal/value.rb
+- lib/oscal/v1_2_1.rb
+- lib/oscal/v1_2_1/all_models.rb
 - lib/oscal/version.rb
-- lib/oscal/with_id.rb
-- oscal.gemspec
-- sig/oscal.rbs
-- spec/oscal/catalog_spec.rb
-- spec/oscal_spec.rb
-- spec/sample_inputs/import-ap.json
-- spec/spec_helper.rb
-homepage: https://github.com/metanorma/oscal-ruby/
+- lib/oscal/version_registry.rb
+- lib/oscal/versioned.rb
+homepage: https://github.com/lutaml/oscal-ruby/
 licenses:
 - BSD-2-Clause
 metadata:
-  homepage_uri: https://github.com/metanorma/oscal-ruby/
-  source_code_uri: https://github.com/metanorma/oscal-ruby/
-  changelog_uri: https://github.com/metanorma/oscal-ruby/CHANGELOG
+  homepage_uri: https://github.com/lutaml/oscal-ruby/
+  source_code_uri: https://github.com/lutaml/oscal-ruby/
+  changelog_uri: https://github.com/lutaml/oscal-ruby/CHANGELOG
   rubygems_mfa_required: 'true'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -140,15 +68,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.27
-signing_key: 
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
-summary: Interact with OSCAL models
+summary: OSCAL Ruby models with multi-version support
 test_files: []

data/.docker/Dockerfile

@@ -1,19 +0,0 @@
-ARG RUBY_IMAGE=ruby:3.1.2-slim
-
-FROM ${RUBY_IMAGE}
-
-RUN apt-get update \
-    && apt-get install -y build-essential git \
-    && apt-get clean && rm -rf /var/lib/apt/lists/*
-
-# install latest bundler
-RUN gem install bundler
-
-# Create app directory
-WORKDIR /workspace
-
-# Set bundle path
-ENV BUNDLE_PATH /bundle
-
-# Default to console
-CMD ["bin/console"]