expressir 2.4.29-arm-linux-musl

data/lib/expressir/model/declarations/schema.rb

@@ -0,0 +1,215 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.3 Schema
+      class Schema < ModelElement
+        include Identifier
+        include ScopeContainer
+
+        # Tree-walker collection attributes (TODO.bugs/12 — single source
+        # of truth; NodePositionIndex derives COLLECTION_REGISTRY from this).
+        collection_attributes :interfaces, :constants, :types, :entities,
+                              :subtype_constraints, :functions, :rules,
+                              :procedures, :remark_items
+
+        # Subset of this schema's collection attributes that hold named
+        # scope declarations (Function, Procedure, Rule, Entity, Type).
+        # Used by ScopeResolver to enumerate scope-capable children without
+        # duplicating the list. Single source of truth: this is the subset
+        # of NodePositionIndex::COLLECTION_REGISTRY[Schema] that holds
+        # scopes rather than remark_items / constants / subtype_constraints.
+        SCOPE_DECL_COLLECTIONS = %i[
+          functions procedures rules entities types
+        ].freeze
+
+        attribute :file, :string
+        attribute :version, SchemaVersion
+        attribute :interfaces, Interface, collection: true
+        attribute :constants, Constant, collection: true
+        attribute :types, ModelElement, collection: true
+        attribute :entities, Entity, collection: true
+        attribute :subtype_constraints, SubtypeConstraint, collection: true
+        attribute :functions, Function, collection: true
+        attribute :rules, Rule, collection: true
+        attribute :procedures, Procedure, collection: true
+        attribute :header, :string
+        attribute :_class, :string, default: -> { self.class.name }
+        attribute :selected, :boolean, default: false
+        attribute :file_basename, :string
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "id", to: :id
+          map "file", to: :file
+          map "header", to: :header
+          map "remarks", to: :remarks
+          map "remark_items", to: :remark_items
+          map "version", to: :version
+          map "interfaces", to: :interfaces
+          map "constants", to: :constants
+          map "types", to: :types
+          map "entities", to: :entities
+          map "subtype_constraints", to: :subtype_constraints
+          map "functions", to: :functions
+          map "rules", to: :rules
+          map "procedures", to: :procedures
+        end
+
+        liquid do
+          map :header, to: :header
+          map :formatted, to: :formatted
+          map :formatted_hyperlinked, to: :formatted_hyperlinked
+          map :formatted_hyperlinked_adoc, to: :formatted_hyperlinked_adoc
+          map :source, to: :source
+          map :source_hyperlinked, to: :source_hyperlinked
+          map :full_source, to: :full_source
+          map :children, to: :children
+          map :safe_children, to: :safe_children
+        end
+
+        # @return [Array<Declaration>]
+        def safe_children
+          [
+            *constants,
+            *types,
+            *types&.flat_map(&:enumeration_items),
+            *entities,
+            *subtype_constraints,
+            *functions,
+            *rules,
+            *procedures,
+            *remark_items,
+          ]
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *interfaced_items,
+            *safe_children,
+          ]
+        end
+
+        def full_source
+          @full_source ||= Expressir::Express::Formatter.format(self)
+        end
+
+        def formatted
+          @formatted ||= format(no_remarks: false)
+        end
+
+        # Schema head text without hyperlinks (#255) — the `source` face
+        # templates call for the verbatim schema declaration block.
+        # Deliberately NOT @source: that ivar holds the raw source span
+        # lutaml-model's `source=` stores when include_source is on.
+        def source
+          @plain_source ||= Expressir::Express::SchemaPlainSourceFormatter.format(self) # rubocop:disable Naming/MemoizedInstanceVariableName
+        end
+
+        # Schema head text with cross-references rendered as hyperlinks
+        # (#255) — the hyperlinked counterpart of #source.
+        def source_hyperlinked
+          Expressir::Express::SchemaSourceFormatter.format(self)
+        end
+
+        # FULL schema text with cross-references rendered as hyperlinks
+        # — what a schema document page renders (#255): every line of
+        # the schema, live links included.
+        def formatted_hyperlinked
+          @formatted_hyperlinked ||= Expressir::Express::SourceFormatter.format(self)
+        end
+
+        # FULL schema text with cross-references as AsciiDoc xref macros
+        # (+<<schema.item,item>>+) — drop-in for a schema document page
+        # rendered through a +subs="+macros"+ source block.
+        def formatted_hyperlinked_adoc
+          @formatted_hyperlinked_adoc ||= Expressir::Express::AdocSourceFormatter.format(self)
+        end
+
+        private
+
+        # @param [String] id
+        # @param [ModelElement] base_item
+        # @return [InterfacedItem]
+        def create_interfaced_item(id, base_item)
+          interfaced_item = InterfacedItem.new(
+            id: id,
+          )
+          interfaced_item.base_item = base_item # skip overriding parent
+          interfaced_item.parent = self
+          interfaced_item
+        end
+
+        # @return [Array<InterfacedItem>]
+        def interfaced_items
+          return [] unless parent
+
+          visited_schemas = {}
+          interfaces.flat_map do |interface|
+            items_for_interface(interface, visited_schemas)
+          end.compact
+        end
+
+        # Direct items of one interface plus the items visible through
+        # the foreign schema's own USE interfaces (transitive USE
+        # visibility, eeng :use-only → :use-from recursion).
+        def items_for_interface(interface, visited_schemas)
+          schema = foreign_schema(interface.schema.id.safe_downcase)
+          return [] unless schema
+          # Visited means this schema's contribution is already in the
+          # caller's result: re-entering — mutual USE FROM included —
+          # recursed forever when the interface carried an item list
+          # (the old guard only fired for the list-less form).
+          return [] if visited_schemas.key?(schema.id.safe_downcase)
+
+          visited_schemas[schema.id.safe_downcase] = true
+
+          safe_children = schema.safe_children
+          children_by_id = safe_children.each_with_object({}) do |child, hash|
+            hash[child.id.safe_downcase] = child if child.id
+          end
+
+          own = if interface.items.empty?
+                  safe_children.map do |base_item|
+                    create_interfaced_item(base_item.id, base_item)
+                  end
+                else
+                  interface.items.filter_map do |item|
+                    base_item = children_by_id[item.ref.id.safe_downcase]
+                    if base_item
+                      create_interfaced_item(item.id || base_item.id,
+                                             base_item)
+                    end
+                  end
+                end
+
+          # Transitive items are not restricted by this interface's
+          # item list: implicit interfacing through USE is unfiltered
+          # (eeng :use-only → :use-from recursion finds any id in the
+          # foreign schema's use scope).
+          own + Array(schema.interfaces).filter_map do |foreign_iface|
+            next nil unless foreign_iface.kind == Interface::USE
+
+            foreign_items = items_for_interface(foreign_iface,
+                                                visited_schemas)
+            foreign_items.empty? ? nil : foreign_items
+          end.flatten
+        end
+
+        # Find a foreign schema by name: same file first, then the
+        # enclosing repository (expressir's compiled/batch repository).
+        def foreign_schema(name)
+          current = parent
+          while current
+            return current.children_by_id[name] if current.respond_to?(:children_by_id) &&
+              current.children_by_id[name]
+
+            current = current.is_a?(ModelElement) ? current.parent : nil
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/declarations/schema_version.rb

@@ -0,0 +1,19 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.3 Schema
+      class SchemaVersion < ModelElement
+        attribute :value, :string
+        attribute :items, SchemaVersionItem, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "value", to: :value
+          map "items", to: :items
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/declarations/schema_version_item.rb

@@ -0,0 +1,19 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.3 Schema
+      class SchemaVersionItem < ModelElement
+        attribute :name, :string
+        attribute :value, :string
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "name", to: :name
+          map "value", to: :value
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/declarations/subtype_constraint.rb

@@ -0,0 +1,32 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.7 Subtype constraints
+      class SubtypeConstraint < ModelElement
+        include Identifier
+
+        attribute :applies_to, ModelElement
+        attribute :abstract, :boolean
+        attribute :total_over, ModelElement, collection: true
+        attribute :supertype_expression, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "applies_to", to: :applies_to
+          map "abstract", to: :abstract
+          map "total_over", to: :total_over
+          map "supertype_expression", to: :supertype_expression
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *remark_items,
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/declarations/type.rb

@@ -0,0 +1,45 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.1 Type declaration
+      class Type < ModelElement
+        include Identifier
+        include ScopeContainer
+        include HasInformalPropositions
+        include HasWhereRules
+
+        collection_attributes :where_rules, :informal_propositions,
+                              :remark_items
+
+        attribute :underlying_type, ModelElement
+        attribute :where_rules, WhereRule, collection: true
+        attribute :informal_propositions, InformalPropositionRule,
+                  collection: true
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "underlying_type", to: :underlying_type
+          map "where_rules", to: :where_rules
+          map "informal_propositions", to: :informal_propositions
+        end
+
+        # @return [Array<DataTypes::EnumerationItem>]
+        def enumeration_items
+          underlying_type.is_a?(DataTypes::Enumeration) ? underlying_type.items : []
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *enumeration_items,
+            *where_rules,
+            *informal_propositions,
+            *remark_items,
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/declarations/unique_rule.rb

@@ -0,0 +1,26 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.2.2.1 Uniqueness rule
+      class UniqueRule < ModelElement
+        include Identifier
+
+        attribute :attributes, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "attributes", to: :attributes
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *remark_items,
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/declarations/variable.rb

@@ -0,0 +1,28 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.5.4 Local variables
+      class Variable < ModelElement
+        include Identifier
+
+        attribute :type, ModelElement
+        attribute :expression, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "type", to: :type
+          map "expression", to: :expression
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *remark_items,
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/declarations/where_rule.rb

@@ -0,0 +1,26 @@
+module Expressir
+  module Model
+    module Declarations
+      # Specified in ISO 10303-11:2004
+      # - section 9.2.2.2 Domain rules (WHERE clause)
+      class WhereRule < ModelElement
+        include Identifier
+
+        attribute :expression, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "expression", to: :expression
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            *remark_items,
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/declarations.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Model
+    module Declarations
+      autoload :Attribute, "#{__dir__}/declarations/attribute"
+      autoload :Constant, "#{__dir__}/declarations/constant"
+      autoload :DerivedAttribute, "#{__dir__}/declarations/derived_attribute"
+      autoload :Entity, "#{__dir__}/declarations/entity"
+      autoload :Function, "#{__dir__}/declarations/function"
+      autoload :Interface, "#{__dir__}/declarations/interface"
+      autoload :InterfaceItem, "#{__dir__}/declarations/interface_item"
+      autoload :InterfacedItem, "#{__dir__}/declarations/interfaced_item"
+      autoload :InverseAttribute, "#{__dir__}/declarations/inverse_attribute"
+      autoload :Parameter, "#{__dir__}/declarations/parameter"
+      autoload :Procedure, "#{__dir__}/declarations/procedure"
+      autoload :RemarkItem, "#{__dir__}/declarations/remark_item"
+      autoload :Rule, "#{__dir__}/declarations/rule"
+      autoload :Schema, "#{__dir__}/declarations/schema"
+      autoload :SchemaVersion, "#{__dir__}/declarations/schema_version"
+      autoload :SchemaVersionItem, "#{__dir__}/declarations/schema_version_item"
+      autoload :SubtypeConstraint, "#{__dir__}/declarations/subtype_constraint"
+      autoload :Type, "#{__dir__}/declarations/type"
+      autoload :UniqueRule, "#{__dir__}/declarations/unique_rule"
+      autoload :Variable, "#{__dir__}/declarations/variable"
+      autoload :WhereRule, "#{__dir__}/declarations/where_rule"
+      autoload :InformalPropositionRule,
+               "#{__dir__}/declarations/informal_proposition_rule"
+    end
+  end
+end