expressir 2.1.13 → 2.1.14

data/lib/expressir/model/literals/string.rb

@@ -3,18 +3,15 @@ module Expressir
     module Literals
       # Specified in ISO 10303-11:2004
       # - section 7.5.4 String literal
-      class String < Literal
-        model_attr_accessor :value, "::String"
-        model_attr_accessor :encoded, "::Boolean"
+      class String < ModelElement
+        attribute :value, :string
+        attribute :encoded, :boolean
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [::String] :value
-        # @option options [::Boolean] :encoded
-        def initialize(options = {})
-          @value = options[:value]
-          @encoded = options[:encoded]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "value", to: :value, value_map: { to: { nil: :empty, empty: :empty } }
+          map "encoded", to: :encoded
         end
       end
     end

data/lib/expressir/model/model_element.rb

@@ -3,20 +3,169 @@ require "pathname"
 module Expressir
   module Model
     # Base model element
-    class ModelElement
-      CLASS_KEY = "_class".freeze
-      FILE_KEY = "file".freeze
-      SOURCE_KEY = "source".freeze
+    class ModelElement < Lutaml::Model::Serializable
+      SKIP_ATTRIBUTES = %i[parent _class].freeze
+      # :parent is a special attribute that is used to store the parent of the current element
+      # It is not a real attribute
+      # attribute :parent, ModelElement
+      attr_accessor :parent
 
-      private_constant :CLASS_KEY
-      private_constant :FILE_KEY
-      private_constant :SOURCE_KEY
+      attribute :_class, :string, default: -> { send(:name) },
+                                  polymorphic_class: true
+      attribute :source, :string
+
+      # TODO: Add basic mappings that can be inherited by all subclasses
+      key_value do
+        map "_class", to: :_class, render_default: true,
+                      polymorphic_map: {
+                        "Expressir::Model::Cache" =>
+                        "Expressir::Model::Cache",
+                        "Expressir::Model::Repository" =>
+            "Expressir::Model::Repository",
+                        "Expressir::Model::DataTypes::Aggregate" =>
+            "Expressir::Model::DataTypes::Aggregate",
+                        "Expressir::Model::DataTypes::Array" =>
+            "Expressir::Model::DataTypes::Array",
+                        "Expressir::Model::DataTypes::Bag" =>
+            "Expressir::Model::DataTypes::Bag",
+                        "Expressir::Model::DataTypes::Binary" =>
+            "Expressir::Model::DataTypes::Binary",
+                        "Expressir::Model::DataTypes::Boolean" =>
+            "Expressir::Model::DataTypes::Boolean",
+                        "Expressir::Model::DataTypes::EnumerationItem" =>
+            "Expressir::Model::DataTypes::EnumerationItem",
+                        "Expressir::Model::DataTypes::Enumeration" =>
+            "Expressir::Model::DataTypes::Enumeration",
+                        "Expressir::Model::DataTypes::GenericEntity" =>
+            "Expressir::Model::DataTypes::GenericEntity",
+                        "Expressir::Model::DataTypes::Generic" =>
+            "Expressir::Model::DataTypes::Generic",
+                        "Expressir::Model::DataTypes::Integer" =>
+            "Expressir::Model::DataTypes::Integer",
+                        "Expressir::Model::DataTypes::List" =>
+            "Expressir::Model::DataTypes::List",
+                        "Expressir::Model::DataTypes::Logical" =>
+            "Expressir::Model::DataTypes::Logical",
+                        "Expressir::Model::DataTypes::Number" =>
+            "Expressir::Model::DataTypes::Number",
+                        "Expressir::Model::DataTypes::Real" =>
+            "Expressir::Model::DataTypes::Real",
+                        "Expressir::Model::DataTypes::Select" =>
+            "Expressir::Model::DataTypes::Select",
+                        "Expressir::Model::DataTypes::Set" =>
+            "Expressir::Model::DataTypes::Set",
+                        "Expressir::Model::DataTypes::String" =>
+            "Expressir::Model::DataTypes::String",
+                        "Expressir::Model::Declarations::Attribute" =>
+            "Expressir::Model::Declarations::Attribute",
+                        "Expressir::Model::Declarations::Constant" =>
+            "Expressir::Model::Declarations::Constant",
+                        "Expressir::Model::Declarations::Entity" =>
+            "Expressir::Model::Declarations::Entity",
+                        "Expressir::Model::Declarations::Function" =>
+            "Expressir::Model::Declarations::Function",
+                        "Expressir::Model::Declarations::InterfaceItem" =>
+            "Expressir::Model::Declarations::InterfaceItem",
+                        "Expressir::Model::Declarations::Interface" =>
+            "Expressir::Model::Declarations::Interface",
+                        "Expressir::Model::Declarations::InterfacedItem" =>
+            "Expressir::Model::Declarations::InterfacedItem",
+                        "Expressir::Model::Declarations::Parameter" =>
+            "Expressir::Model::Declarations::Parameter",
+                        "Expressir::Model::Declarations::Procedure" =>
+            "Expressir::Model::Declarations::Procedure",
+                        "Expressir::Model::Declarations::RemarkItem" =>
+            "Expressir::Model::Declarations::RemarkItem",
+                        "Expressir::Model::Declarations::Rule" =>
+            "Expressir::Model::Declarations::Rule",
+                        "Expressir::Model::Declarations::SchemaVersionItem" =>
+            "Expressir::Model::Declarations::SchemaVersionItem",
+                        "Expressir::Model::Declarations::SchemaVersion" =>
+            "Expressir::Model::Declarations::SchemaVersion",
+                        "Expressir::Model::Declarations::Schema" =>
+            "Expressir::Model::Declarations::Schema",
+                        "Expressir::Model::Declarations::SubtypeConstraint" =>
+            "Expressir::Model::Declarations::SubtypeConstraint",
+                        "Expressir::Model::Declarations::Type" =>
+            "Expressir::Model::Declarations::Type",
+                        "Expressir::Model::Declarations::UniqueRule" =>
+            "Expressir::Model::Declarations::UniqueRule",
+                        "Expressir::Model::Declarations::Variable" =>
+            "Expressir::Model::Declarations::Variable",
+                        "Expressir::Model::Declarations::WhereRule" =>
+            "Expressir::Model::Declarations::WhereRule",
+                        "Expressir::Model::Expressions::AggregateInitializerItem" =>
+            "Expressir::Model::Expressions::AggregateInitializerItem",
+                        "Expressir::Model::Expressions::AggregateInitializer" =>
+            "Expressir::Model::Expressions::AggregateInitializer",
+                        "Expressir::Model::Expressions::BinaryExpression" =>
+            "Expressir::Model::Expressions::BinaryExpression",
+                        "Expressir::Model::Expressions::EntityConstructor" =>
+            "Expressir::Model::Expressions::EntityConstructor",
+                        "Expressir::Model::Expressions::FunctionCall" =>
+            "Expressir::Model::Expressions::FunctionCall",
+                        "Expressir::Model::Expressions::Interval" =>
+            "Expressir::Model::Expressions::Interval",
+                        "Expressir::Model::Expressions::QueryExpression" =>
+            "Expressir::Model::Expressions::QueryExpression",
+                        "Expressir::Model::Expressions::UnaryExpression" =>
+            "Expressir::Model::Expressions::UnaryExpression",
+                        "Expressir::Model::Literals::Binary" =>
+            "Expressir::Model::Literals::Binary",
+                        "Expressir::Model::Literals::Integer" =>
+            "Expressir::Model::Literals::Integer",
+                        "Expressir::Model::Literals::Logical" =>
+            "Expressir::Model::Literals::Logical",
+                        "Expressir::Model::Literals::Real" =>
+            "Expressir::Model::Literals::Real",
+                        "Expressir::Model::Literals::String" =>
+            "Expressir::Model::Literals::String",
+                        "Expressir::Model::References::AttributeReference" =>
+            "Expressir::Model::References::AttributeReference",
+                        "Expressir::Model::References::GroupReference" =>
+            "Expressir::Model::References::GroupReference",
+                        "Expressir::Model::References::IndexReference" =>
+            "Expressir::Model::References::IndexReference",
+                        "Expressir::Model::References::SimpleReference" =>
+            "Expressir::Model::References::SimpleReference",
+                        "Expressir::Model::Statements::Alias" =>
+            "Expressir::Model::Statements::Alias",
+                        "Expressir::Model::Statements::Assignment" =>
+            "Expressir::Model::Statements::Assignment",
+                        "Expressir::Model::Statements::CaseAction" =>
+            "Expressir::Model::Statements::CaseAction",
+                        "Expressir::Model::Statements::Case" =>
+            "Expressir::Model::Statements::Case",
+                        "Expressir::Model::Statements::Compound" =>
+            "Expressir::Model::Statements::Compound",
+                        "Expressir::Model::Statements::Escape" =>
+            "Expressir::Model::Statements::Escape",
+                        "Expressir::Model::Statements::If" =>
+            "Expressir::Model::Statements::If",
+                        "Expressir::Model::Statements::Null" =>
+            "Expressir::Model::Statements::Null",
+                        "Expressir::Model::Statements::ProcedureCall" =>
+            "Expressir::Model::Statements::ProcedureCall",
+                        "Expressir::Model::Statements::Repeat" =>
+            "Expressir::Model::Statements::Repeat",
+                        "Expressir::Model::Statements::Return" =>
+            "Expressir::Model::Statements::Return",
+                        "Expressir::Model::Statements::Skip" =>
+            "Expressir::Model::Statements::Skip",
+                        "Expressir::Model::SupertypeExpressions::BinarySupertypeExpression" =>
+            "Expressir::Model::SupertypeExpressions::BinarySupertypeExpression",
+                        "Expressir::Model::SupertypeExpressions::OneofSupertypeExpression" =>
+            "Expressir::Model::SupertypeExpressions::OneofSupertypeExpression",
+                      }
+      end
 
-      # @return [ModelElement]
-      attr_accessor :parent
+      def source
+        Expressir::Express::Formatter.format(self)
+      end
 
       # @param [Hash] options
       def initialize(_options = {})
+        super
         attach_parent_to_children
       end
 
@@ -91,147 +240,31 @@ module Expressir
         nil
       end
 
-      # @param [String] root_path
-      # @param [Express::Formatter] formatter
-      # @param [Boolean] include_empty
-      # @param [Proc] select_proc
-      # @return [Hash]
-      def to_hash(root_path: nil, formatter: nil, include_empty: nil, select_proc: nil)
-        # Filter out entries
-        has_filter = !select_proc.nil? && select_proc.is_a?(Proc)
-        return nil if has_filter && !select_proc.call(self)
-
-        hash = {}
-        hash[CLASS_KEY] = self.class.name
-
-        self.class.model_attrs.each do |variable|
-          value = send(variable)
-          empty = value.nil? || (value.is_a?(Array) && value.count.zero?)
-
-          # skip empty values
-          next unless !empty || include_empty
-
-          value_hash = case value
-                       when Array
-                         value.map do |v|
-                           if v.is_a? ModelElement
-                             v.to_hash(
-                               root_path: root_path,
-                               formatter: formatter,
-                               include_empty: include_empty,
-                               select_proc: select_proc,
-                             )
-                           else
-                             v
-                           end
-                         end.compact
-                       when ModelElement
-                         value.to_hash(
-                           root_path: root_path,
-                           formatter: formatter,
-                           include_empty: include_empty,
-                           select_proc: select_proc,
-                         )
-                       else
-                         value
-                       end
-
-          hash[variable.to_s] = value_hash unless value_hash.nil?
-        end
-
-        if is_a?(Declarations::Schema) && file
-          hash[FILE_KEY] = root_path ? Pathname.new(file).relative_path_from(root_path).to_s : file
-        end
-
-        if self.class.method_defined?(:source) && formatter
-          hash[SOURCE_KEY] = formatter.format(self)
-        end
-
-        hash
-      end
-
-      # @return [Liquid::Drop]
-      def to_liquid(options: nil)
-        klass_name = "#{self.class.name.gsub('::Model::', '::Liquid::')}Drop"
-        klass = Object.const_get(klass_name)
-        klass.new(self, options: options)
-      end
-
       def to_s(no_remarks: false, formatter: nil)
         f = formatter || Express::Formatter.new(no_remarks: no_remarks)
         f.no_remarks = no_remarks
         f.format(self)
       end
 
-      # @param [Hash] hash
-      # @param [String] root_path
-      # @return [ModelElement]
-      def self.from_hash(hash, root_path: nil)
-        node_class = Object.const_get(hash[CLASS_KEY])
-        node_options = {}
-
-        node_class.model_attrs.each do |variable|
-          value = hash[variable.to_s]
-
-          node_options[variable] = case value
-                                   when Array
-                                     value.map do |value|
-                                       if value.is_a? Hash
-                                         from_hash(value, root_path: root_path)
-                                       else
-                                         value
-                                       end
-                                     end
-                                   when Hash
-                                     from_hash(value, root_path: root_path)
-                                   else
-                                     value
-                                   end
-        end
-
-        if (node_class == Declarations::Schema) && hash[FILE_KEY]
-          node_options[FILE_KEY.to_sym] = root_path ? File.expand_path("#{root_path}/#{hash[FILE_KEY]}") : hash[FILE_KEY]
-        end
-
-        node_class.new(node_options)
-      end
-
-      # @return [Array<Symbol>]
-      def self.model_attrs
-        @model_attrs ||= []
-      end
-
-      # Define a new model attribute
-      # @param attr_name [Symbol] attribute name
-      # @param attr_type [Symbol] attribute type
-      # @!macro [attach] model_attr_accessor
-      #   @!attribute $1
-      #     @return [$2]
-      def self.model_attr_accessor(attr_name, _attr_type = nil)
-        @model_attrs ||= []
-        @model_attrs << attr_name
-
-        attr_accessor attr_name
-      end
-
       private
 
       # @return [nil]
       def attach_parent_to_children
-        self.class.model_attrs.each do |variable|
-          value = send(variable)
+        self.class.attributes.each_pair do |symbol, _lutaml_attr|
+          value = send(symbol)
 
           case value
           when Array
-            value.each do |value|
-              if value.is_a? ModelElement
-                value.parent = self
+            value.each do |val|
+              if val.is_a?(ModelElement)
+                val.parent = self
               end
             end
           when ModelElement
             value.parent = self
           end
         end
+
         nil
       end
     end

data/lib/expressir/model/references/attribute_reference.rb

@@ -3,18 +3,15 @@ module Expressir
     module References
       # Specified in ISO 10303-11:2004
       # - section 12.7.3 Attribute references
-      class AttributeReference < Reference
-        model_attr_accessor :ref, "Reference"
-        model_attr_accessor :attribute, "Reference"
+      class AttributeReference < ModelElement
+        attribute :ref, ModelElement
+        attribute :attribute, ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [Reference] :ref
-        # @option options [Reference] :attribute
-        def initialize(options = {})
-          @ref = options[:ref]
-          @attribute = options[:attribute]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "ref", to: :ref
+          map "attribute", to: :attribute
         end
       end
     end

data/lib/expressir/model/references/group_reference.rb

@@ -3,18 +3,15 @@ module Expressir
     module References
       # Specified in ISO 10303-11:2004
       # - section 12.7.4 Group references
-      class GroupReference < Reference
-        model_attr_accessor :ref, "Reference"
-        model_attr_accessor :entity, "Reference"
+      class GroupReference < ModelElement
+        attribute :ref, ModelElement
+        attribute :entity, ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [Reference] :ref
-        # @option options [Reference] :entity
-        def initialize(options = {})
-          @ref = options[:ref]
-          @entity = options[:entity]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "ref", to: :ref
+          map "entity", to: :entity
         end
       end
     end

data/lib/expressir/model/references/index_reference.rb

@@ -5,21 +5,17 @@ module Expressir
       # - section 12.3.1 Binary indexing
       # - section 12.5.1 String indexing
       # - section 12.6.1 Aggregate indexing
-      class IndexReference < Reference
-        model_attr_accessor :ref, "Reference"
-        model_attr_accessor :index1, "Expression"
-        model_attr_accessor :index2, "Expression"
+      class IndexReference < ModelElement
+        attribute :ref, ModelElement
+        attribute :index1, ModelElement
+        attribute :index2, ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [Reference] :ref
-        # @option options [Expression] :index1
-        # @option options [Expression] :index2
-        def initialize(options = {})
-          @ref = options[:ref]
-          @index1 = options[:index1]
-          @index2 = options[:index2]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "ref", to: :ref
+          map "index1", to: :index1
+          map "index2", to: :index2
         end
       end
     end

data/lib/expressir/model/references/simple_reference.rb

@@ -3,20 +3,17 @@ module Expressir
     module References
       # Specified in ISO 10303-11:2004
       # - section 12.7.1 Simple references
-      class SimpleReference < Reference
-        model_attr_accessor :id, "String"
+      class SimpleReference < ModelElement
+        attribute :id, :string
+        attribute :ref, ModelElement
+        attribute :base_path, :string
+        attribute :_class, :string, default: -> { send(:name) }
 
-        model_attr_accessor :base_path, "String"
-
-        # @param [Hash] options
-        # @option options [String] :id
-        # @option options [String] :base_path
-        def initialize(options = {})
-          @id = options[:id]
-
-          @base_path = options[:base_path]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "id", to: :id
+          map "ref", to: :ref
+          map "base_path", to: :base_path
         end
       end
     end

data/lib/expressir/model/repository.rb

@@ -2,14 +2,12 @@ module Expressir
   module Model
     # Multi-schema global scope
     class Repository < ModelElement
-      model_attr_accessor :schemas, "Array<Declarations::Schema>"
+      attribute :schemas, Expressir::Model::Declarations::Schema, collection: true
+      attribute :_class, :string, default: -> { send(:name) }
 
-      # @param [Hash] options
-      # @option options [Array<Declarations::Schema>] :schemas
-      def initialize(options = {})
-        @schemas = options[:schemas] || []
-
-        super
+      key_value do
+        map "_class", to: :_class, render_default: true
+        map "schemas", to: :schemas
       end
 
       # @return [Array<Declaration>]

data/lib/expressir/model/statements/alias.rb

@@ -3,23 +3,17 @@ module Expressir
     module Statements
       # Specified in ISO 10303-11:2004
       # - section 13.2 Alias statement
-      class Alias < Statement
+      class Alias < ModelElement
         include Identifier
 
-        model_attr_accessor :expression, "Expression"
-        model_attr_accessor :statements, "Array<Statement>"
+        attribute :expression, ModelElement
+        attribute :statements, ModelElement, collection: true
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [Expression] :expression
-        # @option options [Array<Statement>] :statements
-        def initialize(options = {})
-          initialize_identifier(options)
-
-          @expression = options[:expression]
-          @statements = options[:statements] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "expression", to: :expression
+          map "statements", to: :statements
         end
 
         # @return [Array<Declaration>]

data/lib/expressir/model/statements/assignment.rb

@@ -3,18 +3,15 @@ module Expressir
     module Statements
       # Specified in ISO 10303-11:2004
       # - section 13.3 Assignment
-      class Assignment < Statement
-        model_attr_accessor :ref, "Reference"
-        model_attr_accessor :expression, "Expression"
+      class Assignment < ModelElement
+        attribute :ref, ModelElement
+        attribute :expression, ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [Reference] :ref
-        # @option options [Expression] :expression
-        def initialize(options = {})
-          @ref = options[:ref]
-          @expression = options[:expression]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "ref", to: :ref
+          map "expression", to: :expression
         end
       end
     end

data/lib/expressir/model/statements/case.rb

@@ -3,21 +3,17 @@ module Expressir
     module Statements
       # Specified in ISO 10303-11:2004
       # - section 13.4 Case statement
-      class Case < Statement
-        model_attr_accessor :expression, "Expression"
-        model_attr_accessor :actions, "Array<CaseAction>"
-        model_attr_accessor :otherwise_statement, "Statement"
+      class Case < ModelElement
+        attribute :expression, ModelElement
+        attribute :actions, CaseAction, collection: true
+        attribute :otherwise_statement, ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [Expression] :expression
-        # @option options [Array<CaseAction>] :statements
-        # @option options [Statement] :otherwise_statement
-        def initialize(options = {})
-          @expression = options[:expression]
-          @actions = options[:actions] || []
-          @otherwise_statement = options[:otherwise_statement]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "expression", to: :expression
+          map "actions", to: :actions
+          map "otherwise_statement", to: :otherwise_statement
         end
       end
     end

data/lib/expressir/model/statements/case_action.rb

@@ -4,17 +4,14 @@ module Expressir
       # Specified in ISO 10303-11:2004
       # - section 13.4 Case statement
       class CaseAction < ModelElement
-        model_attr_accessor :labels, "Array<Expression>"
-        model_attr_accessor :statement, "Statement"
+        attribute :labels, ModelElement, collection: true
+        attribute :statement, ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [Array<Expression>] :labels
-        # @option options [Statement] :statement
-        def initialize(options = {})
-          @labels = options[:labels] || []
-          @statement = options[:statement]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "labels", to: :labels
+          map "statement", to: :statement
         end
       end
     end

data/lib/expressir/model/statements/compound.rb

@@ -3,15 +3,13 @@ module Expressir
     module Statements
       # Specified in ISO 10303-11:2004
       # - section 13.5 Compound statement
-      class Compound < Statement
-        model_attr_accessor :statements, "Array<Statement>"
+      class Compound < ModelElement
+        attribute :statements, ModelElement, collection: true
+        attribute :_class, :string, default: -> { send(:name) }
 
-        # @param [Hash] options
-        # @option options [Array<Statement>] :statements
-        def initialize(options = {})
-          @statements = options[:statements] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "statements", to: :statements
         end
       end
     end

data/lib/expressir/model/statements/escape.rb

@@ -3,7 +3,12 @@ module Expressir
     module Statements
       # Specified in ISO 10303-11:2004
       # - section 13.6 Escape statement
-      class Escape < Statement
+      class Escape < ModelElement
+        attribute :_class, :string, default: -> { send(:name) }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+        end
       end
     end
   end