lutaml-lml 0.1.0

data/lib/lutaml/lml/model_compiler.rb

@@ -0,0 +1,325 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class ModelCompiler
+      class ValidationError < Error; end
+
+      TYPE_MAP = {
+        "String" => :string,
+        "Integer" => :integer,
+        "Boolean" => :boolean,
+        "Float" => :float,
+        "Date" => :date,
+        "date_time" => :date_time,
+        "DateTime" => :date_time,
+        "Time" => :time,
+        "Uri" => :string,
+        "Hash" => :hash,
+      }.freeze
+
+      def initialize(namespace: nil)
+        @namespace = namespace
+        @compiled = {}
+        @forward_refs = {}
+        @enum_names = Set.new
+      end
+
+      def compile(input)
+        doc = Pipeline.call(input, resolve: false)
+        compile_document(doc)
+        @compiled
+      end
+
+      def hydrate(input)
+        doc = input.is_a?(Document) ? input : Pipeline.call(input, resolve: false)
+        compile_document(doc) unless @compiled.any?
+        return {} unless doc.instance
+
+        hydrate_instance(doc.instance)
+      end
+
+      def compiled_classes
+        @compiled
+      end
+
+      def validate(input_or_instance, compiled: nil)
+        if compiled
+          @compiled = compiled
+        elsif input_or_instance.is_a?(String) || input_or_instance.is_a?(IO) || input_or_instance.is_a?(StringIO)
+          doc = Pipeline.call(input_or_instance, resolve: false)
+          compile_document(doc)
+        end
+        errors = []
+        instance = input_or_instance.is_a?(Lutaml::Lml::Instance) ? input_or_instance : nil
+        unless instance
+          doc ||= Pipeline.call(input_or_instance, resolve: false)
+          instance = doc.instance
+        end
+        validate_instance(instance, errors) if instance
+        errors
+      end
+
+      private
+
+      def validate_instance(instance, errors, path = "root")
+        if instance.instance && Array(instance.attributes).empty?
+          validate_instance(instance.instance, errors, "#{path}.instance")
+          return
+        end
+
+        attrs = Array(instance.attributes)
+        type_attr = attrs.find { |a| a.name == "type" }
+        type_name = type_attr ? type_attr.value.to_s : instance.type
+        klass = @compiled[type_name]
+        unless klass
+          errors << "#{path}: unknown type '#{type_name}'"
+          return
+        end
+
+        schema_attrs = klass.attributes.keys.map(&:to_s)
+        present_attrs = attrs.map(&:name)
+        schema_set = schema_attrs.to_set
+        present_set = present_attrs.to_set
+
+        unknown = present_set - schema_set - Set.new(%w[type])
+        unknown.each do |name|
+          errors << "#{path}.#{name}: attribute not defined on #{type_name}"
+        end
+
+        required = klass.attributes.select do |_k, v|
+          !v.collection? && !v.options.key?(:default)
+        end.keys.map(&:to_s).to_set
+
+        missing = required - present_set
+        missing.each do |name|
+          errors << "#{path}.#{name}: required attribute missing (cardinality min >= 1)"
+        end
+
+        attrs.each do |attr|
+          next unless schema_attrs.include?(attr.name)
+          attr_def = klass.attributes[attr.name.to_sym]
+          next unless attr_def
+
+          if attr_def.collection? && attr.instances.any?
+            attr.instances.each_with_index do |nested, i|
+              validate_instance(nested, errors, "#{path}.#{attr.name}[#{i}]")
+            end
+          end
+        end
+
+        if instance.instance
+          validate_instance(instance.instance, errors, "#{path}.instance")
+        end
+      end
+
+      def hydrate_instance(instance)
+        inner = instance.instance
+        return hydrate_instance(inner) if inner && Array(instance.attributes).empty?
+
+        type_name = resolve_instance_type(instance)
+        klass = @compiled[type_name]
+        return hydrate_as_untyped(instance, type_name) unless klass
+
+        attrs = extract_instance_attributes(instance, klass)
+        klass.new(**attrs)
+      end
+
+      def resolve_instance_type(instance)
+        type_attr = Array(instance.attributes).find { |a| a.name == "type" }
+        raw = type_attr ? type_attr.value.to_s : instance.type.to_s
+        demodulize(raw)
+      end
+
+      def demodulize(name)
+        name.split("::").last.to_s
+      end
+
+      def hydrate_as_untyped(instance, type_name)
+        { _name: type_name, **extract_raw_attributes(instance) }
+      end
+
+      def extract_raw_attributes(instance)
+        Array(instance.attributes).each_with_object({}) do |attr, hash|
+          if attr.instances.any?
+            hash[attr.name.to_sym] = attr.instances.map { |i| hydrate_instance(i) }
+          elsif attr.value.is_a?(Array)
+            hash[attr.name.to_sym] = attr.value
+          elsif !attr.value.nil?
+            hash[attr.name.to_sym] = attr.value
+          end
+        end
+      end
+
+      def extract_instance_attributes(instance, klass)
+        schema_keys = klass.attributes.keys
+        Array(instance.attributes).each_with_object({}) do |attr, hash|
+          key = attr.name.to_sym
+          next unless schema_keys.include?(key)
+
+          hash[key] = coerce_attribute_value(attr, klass.attributes[key])
+        end
+      end
+
+      def coerce_attribute_value(attr, _attr_def)
+        if attr.instances.any?
+          attr.instances.map { |i| hydrate_instance(i) }
+        elsif attr.value.is_a?(Array)
+          attr.value
+        elsif !attr.value.nil?
+          attr.value
+        end
+      end
+
+      def compile_document(doc)
+        doc.classes.each { |c| compile_class(c) }
+        doc.enums.each { |e| compile_enum(e) }
+        doc.data_types.each { |dt| compile_data_type(dt) }
+        resolve_forward_references
+        apply_xml_mappings
+      end
+
+      def resolve_forward_references
+        @forward_refs.each do |class_name, deferred_attrs|
+          klass = @compiled[class_name]
+          next unless klass
+
+          deferred_attrs.each do |attr_name, raw_type, _type, options|
+            resolved = resolve_type(raw_type)
+            klass.attribute attr_name, resolved, **options
+          end
+        end
+      end
+
+      def compile_class(klass_def)
+        name = klass_def.name.to_s
+        compiled_klass = build_compiled_class(klass_def)
+        register(name, compiled_klass)
+      end
+
+      alias_method :compile_data_type, :compile_class
+
+      def compile_enum(enum_def)
+        name = enum_def.name.to_s
+        values = extract_enum_values(enum_def)
+
+        compiled_klass = Class.new(Lutaml::Model::Serializable) do
+          attribute :value, :string, default: values.first.to_s
+
+          define_method(:to_s) { value }
+        end
+
+        values.each do |val|
+          compiled_klass.define_singleton_method(val) do
+            new(value: val.to_s)
+          end
+        end
+
+        @enum_names << name
+        register(name, compiled_klass)
+      end
+
+      # Builds a compiled Serializable subclass from a class or data-type
+      # definition: declares attributes and stashes forward-referenced
+      # attributes for post-registration resolution.
+      def build_compiled_class(def_obj)
+        all_attrs = build_attributes(def_obj)
+        immediate, deferred = all_attrs.partition do |(_, raw_type, type, _)|
+          type != :string || TYPE_MAP.key?(raw_type) || raw_type.start_with?("reference:(")
+        end
+
+        compiled_klass = Class.new(Lutaml::Model::Serializable) do
+          immediate.each do |attr_name, _raw, type, options|
+            attribute attr_name, type, options
+          end
+        end
+
+        name = def_obj.name.to_s
+        @forward_refs[name] = deferred unless deferred.empty?
+        compiled_klass
+      end
+
+      # Apply a lutaml-model XML mapping to each compiled class so they
+      # support from_xml/to_xml. Runs after forward references are resolved
+      # so all attributes (immediate + deferred) get element mappings.
+      def apply_xml_mappings
+        @compiled.each do |name, klass|
+          next if @enum_names.include?(name)
+
+          apply_xml_mapping(klass, name)
+        end
+      end
+
+      def apply_xml_mapping(klass, root_name)
+        attr_names = klass.attributes.keys
+        return if attr_names.empty?
+
+        klass.xml do |mapping|
+          mapping.root(root_name)
+          attr_names.each do |attr_name|
+            mapping.map_element(attr_name.to_s, to: attr_name)
+          end
+        end
+      end
+
+      def build_attributes(klass_def)
+        Array(klass_def.attributes).map do |attr|
+          attr_name = attr.name.to_sym
+          raw_type = attr.type.to_s
+          type = resolve_type(raw_type)
+          options = build_options(attr)
+          [attr_name, raw_type, type, options]
+        end
+      end
+
+      def resolve_type(type_name)
+        if TYPE_MAP.key?(type_name)
+          TYPE_MAP[type_name]
+        elsif type_name.start_with?("reference:(")
+          :string
+        elsif @compiled.key?(type_name)
+          @compiled[type_name]
+        else
+          :string
+        end
+      end
+
+      def build_options(attr)
+        options = {}
+        card = attr.cardinality
+        return options unless card
+
+        min = parse_cardinality_value(card.min)
+        max = parse_cardinality_value(card.max)
+
+        if max && (max > 1 || max == Float::INFINITY)
+          options[:collection] = true
+        elsif max.nil? && min && min > 1
+          options[:collection] = true
+        elsif min == 0
+          options[:default] = nil
+        end
+        options
+      end
+
+      def parse_cardinality_value(val)
+        return nil if val.nil?
+        return Float::INFINITY if val == "*" || val == "n"
+        val.to_i
+      end
+
+      def extract_enum_values(enum_def)
+        enum_def.attributes.map do |attr|
+          attr.name.to_s
+        end
+      end
+
+      def register(name, klass)
+        @compiled[name] = klass
+        return unless @namespace
+
+        @namespace.const_set(name, klass)
+      end
+    end
+  end
+end

data/lib/lutaml/lml/models/action.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class Action < Lutaml::Model::Serializable
+      attribute :verb, :string
+      attribute :direction, :string
+    end
+  end
+end

data/lib/lutaml/lml/models/association.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class Association < Lutaml::Model::Serializable
+      # From TopElement
+      attribute :name, :string
+      attribute :definition, :string
+      attribute :keyword, :string
+      attribute :stereotype, :string, collection: true, default: -> { [] }
+      attribute :visibility, :string, default: "public"
+
+      # From Association
+      attribute :owner_end, :string
+      attribute :owner_end_attribute_name, :string
+      attribute :owner_end_cardinality, "Lutaml::Lml::Cardinality"
+      attribute :owner_end_type, :string
+      attribute :member_end, :string
+      attribute :member_end_attribute_name, :string
+      attribute :member_end_cardinality, "Lutaml::Lml::Cardinality"
+      attribute :member_end_type, :string
+      attribute :static, :string
+      attribute :action, "Lutaml::Lml::Action"
+    end
+  end
+end

data/lib/lutaml/lml/models/cardinality.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class Cardinality < Lutaml::Model::Serializable
+      attribute :min, :string
+      attribute :max, :string
+    end
+  end
+end

data/lib/lutaml/lml/models/collection.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class Collection < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :includes, :string, collection: true
+      attribute :validations, :string, collection: true
+    end
+  end
+end

data/lib/lutaml/lml/models/constraint.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class Constraint < Lutaml::Model::Serializable
+      # From TopElement
+      attribute :name, :string
+      attribute :definition, :string
+      attribute :keyword, :string
+      attribute :stereotype, :string, collection: true, default: -> { [] }
+      attribute :visibility, :string, default: "public"
+
+      # From Constraint
+      attribute :body, :string
+      attribute :type, :string
+      attribute :weight, :string
+      attribute :status, :string
+    end
+  end
+end

data/lib/lutaml/lml/models/data_type.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class DataType < Lutaml::Model::Serializable
+      # From TopElement
+      attribute :name, :string
+      attribute :definition, :string
+      attribute :keyword, :string, default: "dataType"
+      attribute :stereotype, :string, collection: true, default: -> { [] }
+      attribute :visibility, :string, default: "public"
+
+      # From UmlClassifier
+      attribute :is_abstract, :boolean, default: false
+
+      # From DataType
+      attribute :nested_classifier, :string, collection: true, default: -> { [] }
+      attribute :type, :string
+      attribute :attributes, "Lutaml::Lml::TopElementAttribute", collection: true
+      attribute :modifier, :string
+      attribute :constraints, "Lutaml::Lml::Constraint", collection: true
+      attribute :operations, "Lutaml::Lml::Operation", collection: true
+      attribute :data_types, "Lutaml::Lml::DataType", collection: true
+      attribute :associations, "Lutaml::Lml::Association", collection: true
+
+      def self.entity_type
+        :data_types
+      end
+    end
+  end
+end

data/lib/lutaml/lml/models/diagram.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class Diagram < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :definition, :string
+      attribute :keyword, :string
+      attribute :stereotype, :string, collection: true, default: -> { [] }
+      attribute :visibility, :string, default: "public"
+
+      attribute :package_id, :string
+      attribute :package_name, :string
+      attribute :diagram_type, :string
+    end
+  end
+end

data/lib/lutaml/lml/models/document.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class Document < Lutaml::Model::Serializable
+      # Core attributes
+      attribute :name, :string
+      attribute :title, :string
+      attribute :caption, :string
+      attribute :groups, "Lutaml::Lml::Group", collection: true
+      attribute :fidelity, "Lutaml::Lml::Fidelity"
+      attribute :fontname, :string
+      attribute :comments, :string, collection: true
+
+      attribute :classes, "Lutaml::Lml::UmlClass", collection: true, default: -> { [] }
+      attribute :data_types, "Lutaml::Lml::DataType", collection: true, default: -> { [] }
+      attribute :enums, "Lutaml::Lml::Enum", collection: true, default: -> { [] }
+      attribute :packages, "Lutaml::Lml::Package", collection: true, default: -> { [] }
+      attribute :primitives, "Lutaml::Lml::PrimitiveType", collection: true, default: -> { [] }
+      attribute :associations, "Lutaml::Lml::Association", collection: true, default: -> { [] }
+      attribute :diagrams, "Lutaml::Lml::Diagram", collection: true, default: -> { [] }
+
+      # LML-specific
+      attribute :instance, "Lutaml::Lml::Instance"
+      attribute :requires, :string, collection: true
+      attribute :instances, "Lutaml::Lml::InstanceCollection"
+      attribute :view_imports, "Lutaml::Lml::ViewImport", collection: true
+      attribute :show_filter, "Lutaml::Lml::ViewFilter"
+      attribute :hide_filter, "Lutaml::Lml::ViewFilter"
+
+      # All class-like entities on the document. Used by resolvers and
+      # formatters that need to walk every classifiable type without
+      # caring which collection holds it.
+      def all_classes
+        classes + enums + data_types + primitives
+      end
+
+      # Class-like entities that can own associations. Excludes enums
+      # (which have no attributes/associations of their own).
+      def classifiable_classes
+        classes + data_types + primitives
+      end
+    end
+  end
+end

data/lib/lutaml/lml/models/enum.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class Enum < Lutaml::Model::Serializable
+      # From TopElement
+      attribute :name, :string
+      attribute :definition, :string
+      attribute :keyword, :string, default: "enumeration"
+      attribute :stereotype, :string, collection: true, default: -> { [] }
+      attribute :visibility, :string, default: "public"
+
+      # From UmlClassifier
+      attribute :is_abstract, :boolean, default: false
+
+      # From Enum
+      attribute :attributes, "Lutaml::Lml::TopElementAttribute", collection: true,
+                                                                   default: -> { [] }
+      attribute :modifier, :string
+      attribute :operations, "Lutaml::Lml::Operation", collection: true, default: -> { [] }
+      attribute :values, "Lutaml::Lml::Value", collection: true, default: -> { [] }
+
+      def self.entity_type
+        :enums
+      end
+    end
+  end
+end

data/lib/lutaml/lml/models/fidelity.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class Fidelity < Lutaml::Model::Serializable
+      attribute :hideMembers, :boolean
+      attribute :hideOtherClasses, :boolean
+    end
+  end
+end

data/lib/lutaml/lml/models/group.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class Group < Lutaml::Model::Serializable
+      attribute :id, :string
+      attribute :values, :string, collection: true
+      attribute :groups, "Lutaml::Lml::Group", collection: true
+    end
+  end
+end

data/lib/lutaml/lml/models/instance.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class Instance < Lutaml::Model::Serializable
+      attribute :type, :string
+      attribute :attributes, "Lutaml::Lml::TopElementAttribute", collection: true
+      attribute :instance, "Lutaml::Lml::Instance"
+      attribute :template, "Lutaml::Lml::TopElementAttribute", collection: true
+      attribute :parent, :string
+    end
+  end
+end

data/lib/lutaml/lml/models/instance_collection.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class InstanceCollection < Lutaml::Model::Serializable
+      attribute :instances, "Lutaml::Lml::Instance", collection: true, default: []
+      attribute :imports, "Lutaml::Lml::InstancesImport", collection: true, default: []
+      attribute :exports, "Lutaml::Lml::InstancesExport", collection: true, default: []
+      attribute :collections, "Lutaml::Lml::Collection", default: []
+    end
+  end
+end

data/lib/lutaml/lml/models/instances_export.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class InstancesExport < Lutaml::Model::Serializable
+      attribute :format_type, :string
+      attribute :attributes, "Lutaml::Lml::TopElementAttribute", collection: true, default: []
+    end
+  end
+end

data/lib/lutaml/lml/models/instances_import.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class InstancesImport < Lutaml::Model::Serializable
+      attribute :format_type, :string
+      attribute :file, :string
+      attribute :attributes, "Lutaml::Lml::TopElementAttribute", collection: true, default: []
+    end
+  end
+end

data/lib/lutaml/lml/models/operation.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class Operation < Lutaml::Model::Serializable
+      # From TopElement
+      attribute :name, :string
+      attribute :definition, :string
+      attribute :keyword, :string
+      attribute :stereotype, :string, collection: true, default: -> { [] }
+      attribute :visibility, :string, default: "public"
+
+      # From Operation
+      attribute :id, :string
+      attribute :return_type, :string
+      attribute :parameter_type, :string
+      attribute :is_static, :boolean, default: false
+      attribute :is_abstract, :boolean, default: false
+      attribute :owned_parameter, "Lutaml::Lml::OperationParameter", collection: true,
+                                                                          default: -> { [] }
+    end
+  end
+end

data/lib/lutaml/lml/models/operation_parameter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class OperationParameter < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :type, :string
+      attribute :direction, :string, default: "in"
+    end
+  end
+end

data/lib/lutaml/lml/models/package.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class Package < Lutaml::Model::Serializable
+      # From TopElement
+      attribute :name, :string
+      attribute :definition, :string
+      attribute :keyword, :string
+      attribute :stereotype, :string, collection: true, default: -> { [] }
+      attribute :visibility, :string, default: "public"
+
+      # From Package
+      attribute :contents, :string, collection: true, default: -> { [] }
+      attribute :classes, "Lutaml::Lml::UmlClass", collection: true, default: -> { [] }
+      attribute :enums, "Lutaml::Lml::Enum", collection: true, default: -> { [] }
+      attribute :data_types, "Lutaml::Lml::DataType", collection: true, default: -> { [] }
+      attribute :packages, "Lutaml::Lml::Package", collection: true, default: -> { [] }
+      attribute :diagrams, "Lutaml::Lml::Diagram", collection: true, default: -> { [] }
+    end
+  end
+end