expressir 1.2.10-aarch64-linux → 2.4.29-aarch64-linux

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

@@ -3,49 +3,69 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.3 Schema
-      class Schema < Declaration
-        model_attr_accessor :file, 'String'
-
+      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
 
-        model_attr_accessor :version, 'SchemaVersion'
-        model_attr_accessor :interfaces, 'Array<Interface>'
-        model_attr_accessor :constants, 'Array<Constant>'
-        model_attr_accessor :types, 'Array<Type>'
-        model_attr_accessor :entities, 'Array<Entity>'
-        model_attr_accessor :subtype_constraints, 'Array<SubtypeConstraint>'
-        model_attr_accessor :functions, 'Array<Function>'
-        model_attr_accessor :rules, 'Array<Rule>'
-        model_attr_accessor :procedures, 'Array<Procedure>'
-
-        # @param [Hash] options
-        # @option options [String] :file
-        # @option (see Identifier#initialize_identifier)
-        # @option options [SchemaVersion] :version
-        # @option options [Array<Interface>] :interfaces
-        # @option options [Array<Constant>] :constants
-        # @option options [Array<Type>] :types
-        # @option options [Array<Entity>] :entities
-        # @option options [Array<SubtypeConstraint>] :subtype_constraints
-        # @option options [Array<Function>] :functions
-        # @option options [Array<Rule>] :rules
-        # @option options [Array<Procedure>] :procedures
-        def initialize(options = {})
-          @file = options[:file]
-
-          initialize_identifier(options)
-
-          @version = options[:version]
-          @interfaces = options[:interfaces] || []
-          @constants = options[:constants] || []
-          @types = options[:types] || []
-          @entities = options[:entities] || []
-          @subtype_constraints = options[:subtype_constraints] || []
-          @functions = options[:functions] || []
-          @rules = options[:rules] || []
-          @procedures = options[:procedures] || []
-
-          super
+        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>]
@@ -53,13 +73,13 @@ module Expressir
           [
             *constants,
             *types,
-            *types.flat_map{|x| x.enumeration_items},
+            *types&.flat_map(&:enumeration_items),
             *entities,
             *subtype_constraints,
             *functions,
             *rules,
             *procedures,
-            *remark_items
+            *remark_items,
           ]
         end
 
@@ -67,10 +87,46 @@ module Expressir
         def children
           [
             *interfaced_items,
-            *safe_children
+            *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
@@ -78,7 +134,7 @@ module Expressir
         # @return [InterfacedItem]
         def create_interfaced_item(id, base_item)
           interfaced_item = InterfacedItem.new(
-            id: id
+            id: id,
           )
           interfaced_item.base_item = base_item # skip overriding parent
           interfaced_item.parent = self
@@ -89,29 +145,71 @@ module Expressir
         def interfaced_items
           return [] unless parent
 
+          visited_schemas = {}
           interfaces.flat_map do |interface|
-            schema = parent.children_by_id[interface.schema.id.downcase]
-            if schema
-              schema_safe_children = schema.safe_children
-              schema_safe_children_by_id = schema_safe_children.select{|x| x.id}.map{|x| [x.id.downcase, x]}.to_h
-              if interface.items.length > 0
-                interface.items.map do |interface_item|
-                  base_item = schema_safe_children_by_id[interface_item.ref.id.downcase]
-                  if base_item
-                    id = interface_item.id || base_item.id
-                    create_interfaced_item(id, base_item)
+            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
-              else
-                schema_safe_children.map do |base_item|
-                  id = base_item.id
-                  create_interfaced_item(id, base_item)
-                end
-              end
-            end
-          end.select{|x| x}
+
+          # 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
+end

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

@@ -4,19 +4,16 @@ module Expressir
       # Specified in ISO 10303-11:2004
       # - section 9.3 Schema
       class SchemaVersion < ModelElement
-        model_attr_accessor :value, 'String'
-        model_attr_accessor :items, 'Array<SchemaVersionItem>'
+        attribute :value, :string
+        attribute :items, SchemaVersionItem, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option options [String] :value
-        # @option options [Array<SchemaVersionItem>] :items
-        def initialize(options = {})
-          @value = options[:value]
-          @items = options[:items] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "value", to: :value
+          map "items", to: :items
         end
       end
     end
   end
-end
+end

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

@@ -4,19 +4,16 @@ module Expressir
       # Specified in ISO 10303-11:2004
       # - section 9.3 Schema
       class SchemaVersionItem < ModelElement
-        model_attr_accessor :name, 'String'
-        model_attr_accessor :value, 'String'
+        attribute :name, :string
+        attribute :value, :string
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option options [String] :name
-        # @option options [String] :value
-        def initialize(options = {})
-          @name = options[:name]
-          @value = options[:value]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "name", to: :name
+          map "value", to: :value
         end
       end
     end
   end
-end
+end

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

@@ -3,38 +3,30 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.7 Subtype constraints
-      class SubtypeConstraint < Declaration
+      class SubtypeConstraint < ModelElement
         include Identifier
 
-        model_attr_accessor :applies_to, 'Reference'
-        model_attr_accessor :abstract, 'Boolean'
-        model_attr_accessor :total_over, 'Array<Reference>'
-        model_attr_accessor :supertype_expression, 'SupertypeExpression'
+        attribute :applies_to, ModelElement
+        attribute :abstract, :boolean
+        attribute :total_over, ModelElement, collection: true
+        attribute :supertype_expression, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [Reference] :applies_to
-        # @option options [Boolean] :abstract
-        # @option options [Array<Reference>] :total_over
-        # @option options [SupertypeExpression] :supertype_expression
-        def initialize(options = {})
-          initialize_identifier(options)
-
-          @applies_to = options[:applies_to]
-          @abstract = options[:abstract]
-          @total_over = options[:total_over] || []
-          @supertype_expression = options[:supertype_expression]
-
-          super
+        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
+            *remark_items,
           ]
         end
       end
     end
   end
-end
+end

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

@@ -3,26 +3,26 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.1 Type declaration
-      class Type < Declaration
+      class Type < ModelElement
         include Identifier
+        include ScopeContainer
+        include HasInformalPropositions
+        include HasWhereRules
 
-        model_attr_accessor :underlying_type, 'DataType'
-        model_attr_accessor :where_rules, 'Array<WhereRule>'
-        model_attr_accessor :informal_propositions, 'Array<RemarkItem>'
+        collection_attributes :where_rules, :informal_propositions,
+                              :remark_items
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [DataType] :underlying_type
-        # @option options [Array<WhereRule>] :where_rules
-        # @option options [Array<RemarkItem>] :informal_propositions
-        def initialize(options = {})
-          initialize_identifier(options)
+        attribute :underlying_type, ModelElement
+        attribute :where_rules, WhereRule, collection: true
+        attribute :informal_propositions, InformalPropositionRule,
+                  collection: true
+        attribute :_class, :string, default: -> { self.class.name }
 
-          @underlying_type = options[:underlying_type]
-          @where_rules = options[:where_rules] || []
-          @informal_propositions = options[:informal_propositions] || []
-
-          super
+        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>]
@@ -36,10 +36,10 @@ module Expressir
             *enumeration_items,
             *where_rules,
             *informal_propositions,
-            *remark_items
+            *remark_items,
           ]
         end
       end
     end
   end
-end
+end

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

@@ -3,29 +3,24 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.2.2.1 Uniqueness rule
-      class UniqueRule < Declaration
+      class UniqueRule < ModelElement
         include Identifier
 
-        model_attr_accessor :attributes, 'Reference'
+        attribute :attributes, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [Reference] :attributes
-        def initialize(options = {})
-          initialize_identifier(options)
-
-          @attributes = options[:attributes] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "attributes", to: :attributes
         end
 
         # @return [Array<Declaration>]
         def children
           [
-            *remark_items
+            *remark_items,
           ]
         end
       end
     end
   end
-end
+end

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

@@ -3,32 +3,26 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.5.4 Local variables
-      class Variable < Declaration
+      class Variable < ModelElement
         include Identifier
 
-        model_attr_accessor :type, 'DataType'
-        model_attr_accessor :expression, 'Expression'
+        attribute :type, ModelElement
+        attribute :expression, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [DataType] :type
-        # @option options [Expression] :expression
-        def initialize(options = {})
-          initialize_identifier(options)
-
-          @type = options[:type]
-          @expression = options[:expression]
-
-          super
+        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
+            *remark_items,
           ]
         end
       end
     end
   end
-end
+end

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

@@ -3,29 +3,24 @@ module Expressir
     module Declarations
       # Specified in ISO 10303-11:2004
       # - section 9.2.2.2 Domain rules (WHERE clause)
-      class WhereRule < Declaration
+      class WhereRule < ModelElement
         include Identifier
 
-        model_attr_accessor :expression, 'Expression'
+        attribute :expression, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [Expression] :expression
-        def initialize(options = {})
-          initialize_identifier(options)
-
-          @expression = options[:expression]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "expression", to: :expression
         end
 
         # @return [Array<Declaration>]
         def children
           [
-            *remark_items
+            *remark_items,
           ]
         end
       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