expressir 2.4.3 → 2.4.4

data/lib/expressir/express/self_schema_reference.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # Self-schema-qualified references (#125, ISO 10303-11 scope rules).
+    #
+    # A schema may not reference its own declarations through itself:
+    # `'AIC_TOPOLOGICALLY_BOUNDED_SURFACE.B_SPLINE_SURFACE'` inside that
+    # schema's TYPEOF is technically incorrect — the prefix names the
+    # current schema while the item actually comes from another schema
+    # (implicit through the supertype chain of a USEd entity).
+    #
+    # {matches} finds string literals carrying such prefixes and resolves
+    # where the suffixed item truly lives (local declaration, or the
+    # defining schema within the closure). {fix!} rewrites each literal in
+    # place — dropping the prefix for local items, substituting the true
+    # defining schema otherwise.
+    module SelfSchemaReference
+      Match = Struct.new(:literal, :item, :source_schema, :schema,
+                         keyword_init: true) do
+        # :local  - the item is declared in this schema (drop the prefix)
+        # :foreign - the item's defining schema is known (substitute it)
+        # :unknown - the item could not be located; left untouched
+        def status
+          return :local if declared_locally
+          return :foreign if source_schema
+
+          :unknown
+        end
+
+        attr_accessor :declared_locally
+      end
+
+      module_function
+
+      # Every self-qualified string literal in +schema+.
+      def matches(schema)
+        prefix = /\A#{Regexp.escape(schema.id)}\.(.+)\z/i
+        literals(schema).filter_map do |literal|
+          suffix = literal.value[prefix, 1]
+          next unless suffix
+
+          item = suffix.strip
+          declared_locally = declared?(schema, item.safe_downcase)
+          source = declared_locally ? nil : defining_schema(schema, item)
+          match = Match.new(literal: literal, item: item,
+                            source_schema: source, schema: schema)
+          match.declared_locally = declared_locally
+          match
+        end
+      end
+
+      # Rewrite every self-qualified literal in +schema+; returns the
+      # number of rewrites. Local items lose the prefix; foreign items get
+      # their true defining schema's id.
+      def fix!(schema)
+        matches(schema).count do |match|
+          replacement = case match.status
+                        when :local then match.item
+                        when :foreign
+                          "#{match.source_schema.id}.#{match.item}"
+                        else next false
+                        end
+
+          match.literal.value = replacement
+          true
+        end
+      end
+
+      def literals(schema)
+        result = []
+        visitor = lambda do |node|
+          case node
+          when Model::Literals::String
+            result << node
+          when Model::ModelElement
+            node.class.attributes.each_key do |attr|
+              next if Model::ModelElement::SKIP_ATTRIBUTES.include?(attr)
+
+              value = node.public_send(attr)
+              case value
+              when Array then value.each { |item| visitor.call(item) }
+              when Model::ModelElement then visitor.call(value)
+              end
+            end
+          end
+        end
+        visitor.call(schema)
+        result
+      end
+
+      def defining_schema(schema, item)
+        key = item.safe_downcase
+        repository = repository_of(schema)
+        return nil unless repository
+
+        repository.schemas.each do |other|
+          next if other.equal?(schema)
+          next unless declared?(other, key)
+
+          return other
+        end
+        nil
+      end
+
+      def declared?(schema, key)
+        %i[types entities functions procedures constants rules
+           subtype_constraints].any? do |coll|
+          Array(schema.public_send(coll)).any? do |decl|
+            decl.respond_to?(:id) && decl.id&.safe_downcase == key
+          end
+        end
+      end
+
+      def repository_of(schema)
+        current = schema.parent
+        while current
+          return current if current.is_a?(Model::Repository)
+
+          current = current.respond_to?(:parent) ? current.parent : nil
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/expressir/express/shtolo.rb

@@ -0,0 +1,522 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # SHTOLO — short-to-long conversion per ISO 10303-11:2004 Annex G
+    # (expressir#32): flattens a multi-schema specification into a
+    # single ISO 10303-11:1994 longform schema.
+    #
+    # Two stages (annex-g-rules.md):
+    #  G.1  multi-schema → intermediate `artifact` schema: interface
+    #       closure copied as local declarations, renames resolved to
+    #       original names, name clashes munged (G.NM.1), REFERENCE
+    #       entities kept with the dependent-instantiability rule
+    #       (G.1.6), select/rules/supertype expressions pruned (G.1.9).
+    #  G.2  artifact → `longform`: extensible enums/selects resolved
+    #       (G.2.3/G.2.4), subtype constraints eliminated (supertype
+    #       expression → SUPERTYPE, total_over → rule, G.2.5), abstract
+    #       entity → ABSTRACT SUPERTYPE, GENERIC_ENTITY → GENERIC,
+    #       RENAMED → DERIVE (G.2.7), qualified strings rewritten.
+    #
+    # The output is a Model::Declarations::Schema named per the root
+    # schema; format it with the Formatter to obtain the longform file.
+    class Shtolo
+      DEPENDENT_RULE_NAME = "validate_dependently_instantiable_entity_data_types"
+      DEPENDENT_FN_NAME = "dependently_instantiated"
+
+      attr_reader :longform, :renames, :schema
+
+      # `root_schema` — the resolved root schema node.
+      # `repository`  — must hold the full interface closure.
+      # `extenders`   — :all (default, the WG12 requirement) folds every
+      #                 extensible SELECT/ENUMERATION extension found in the
+      #                 closure into its base type (Annex G.2.3/G.2.4);
+      #                 :none leaves extensible types exactly as declared —
+      #                 the shape eengine's default --flat emits.
+      def initialize(root_schema, repository, longform_name: nil,
+                     extenders: :all)
+        @root = root_schema
+        @repository = repository
+        @longform_name = longform_name || @root.id
+        @extenders = extenders
+        @reference_entities = [] # G.1.6 entities
+      end
+
+      def flatten
+        @schema = build_longform
+        self
+      end
+
+      IdPlan = Struct.new(:global, :own_by_schema, keyword_init: true) do
+        def own(schema)
+          own_by_schema[schema] || {}
+        end
+      end
+
+      private
+
+      # ---- interface closure (same semantics as Concatenator) ----
+
+      def closure
+        @closure ||= begin
+          by_name = @repository.schemas.to_h { |s| [s.id.safe_downcase, s] }
+          visited = {}
+          queue = [@root]
+          until queue.empty?
+            schema = queue.shift
+            key = schema.id.safe_downcase
+            next if visited.key?(key)
+
+            visited[key] = schema
+            Array(schema.interfaces).each do |iface|
+              name = iface.schema.is_a?(String) ? iface.schema : iface.schema&.id
+              next unless name
+
+              target = by_name[name.safe_downcase]
+              queue << target if target && !visited.key?(name.safe_downcase)
+            end
+          end
+          visited
+        end
+      end
+
+      # ---- G.1 stage 1 ----
+
+      # Two-phase copy: plan every declaration's final id across the whole
+      # closure FIRST (G.NM.1 clashes are only known once every schema has
+      # been seen), then copy+rewrite each declaration against the complete
+      # map. Rewriting as we copy left stale references in declarations
+      # copied before a later clash was munged.
+      def build_artifact
+        schemas = [@root, *closure.values.reject { |s| s.equal?(@root) }]
+        plan = plan_ids(schemas)
+
+        declarations = []
+        schemas.each do |schema|
+          rename_map = renames_for(schema)
+          # Resolution order for a reference in this schema: its own local
+          # declarations (which may be munged), then interface aliases
+          # resolved through the referenced declaration's final id, then
+          # the global munge map for names the schema doesn't declare.
+          full = plan.global.dup
+          plan.own(schema).each { |k, final| full[k] = final }
+          rename_map.each do |alias_name, original|
+            resolved = plan.own(schema)[original.safe_downcase] ||
+              plan.global[original.safe_downcase] || original
+            full[alias_name.safe_downcase] = resolved
+          end
+
+          all_decls(schema).each do |decl|
+            copy = deep_copy(decl)
+            rewrite_references(copy, full)
+            if decl.respond_to?(:id) && decl.id &&
+                (final = plan.own(schema)[decl.id.safe_downcase])
+              copy.id = final
+            end
+            declarations << copy
+          end
+
+          # G.1.2: interfaces themselves dissolve; REFERENCE entities
+          # keep dependent-instantiability semantics (G.1.6).
+          schema.interfaces.each do |iface|
+            next unless iface.kind == Model::Declarations::Interface::REFERENCE
+
+            iface.items.each do |item|
+              original = original_name(item, schema)
+              next unless closure[original]&.entities&.find { |e| e.id == original }
+
+              @reference_entities << original.safe_downcase
+            end
+          end
+        end
+
+        declarations << build_dependent_rule if @reference_entities.any?
+
+        Model::Declarations::Schema.new(
+          id: @longform_name,
+          version: nil,
+          interfaces: [],
+          constants: declarations.grep(Model::Declarations::Constant).compact,
+          types: declarations.grep(Model::Declarations::Type).compact,
+          entities: declarations.grep(Model::Declarations::Entity).compact,
+          subtype_constraints: declarations.grep(Model::Declarations::SubtypeConstraint).compact,
+          functions: declarations.grep(Model::Declarations::Function).compact,
+          procedures: declarations.grep(Model::Declarations::Procedure).compact,
+          rules: declarations.grep(Model::Declarations::Rule).compact,
+        )
+      end
+
+      def all_decls(schema)
+        schema.constants + schema.types + schema.entities +
+          schema.subtype_constraints + schema.functions +
+          schema.rules + schema.procedures
+      end
+
+      # G.NM.1: the first schema in closure order to declare a name keeps
+      # it; every later declaration of the same name is prefixed with ITS
+      # OWN schema's id, and the global map redirects the bare name so
+      # declarations from third schemas resolve to the first occurrence.
+      def plan_ids(schemas)
+        seen_first = {}      # downcase id => owning schema (first occurrence)
+        global = {}          # downcase id => munged final
+        own_by_schema = {}   # schema => {downcase id => final id}
+        schemas.each do |schema|
+          own = {}
+          all_decls(schema).each do |decl|
+            next unless decl.respond_to?(:id) && decl.id
+
+            key = decl.id.safe_downcase
+            if seen_first.key?(key)
+              final = "#{schema.id.safe_downcase}_dot_#{decl.id}"
+              own[key] = final
+              global[key] = final
+            else
+              seen_first[key] = schema
+              own[key] = decl.id
+            end
+          end
+          own_by_schema[schema] = own
+        end
+        IdPlan.new(global: global, own_by_schema: own_by_schema)
+      end
+
+      # Alias → original map applied when copying `schema`'s
+      # declarations: the aliases are declared by the schema's own
+      # interface items (`USE FROM s (orig AS alias)`, G.1.3).
+      def renames_for(schema)
+        map = {}
+        Array(schema.interfaces).each do |iface|
+          iface.items.each do |item|
+            original = item.ref.is_a?(String) ? item.ref : item.ref&.id
+            next unless original
+
+            map[item.id.safe_downcase] = original if item.id &&
+              item.id.safe_downcase != original.safe_downcase
+          end
+        end
+        map
+      end
+
+      def original_name(item, schema)
+        original = item.ref.is_a?(String) ? item.ref : item.ref&.id
+        return schema.id unless original
+
+        original
+      end
+
+      def deep_copy(obj)
+        sever = []
+        node = obj
+        while node.respond_to?(:parent) && node.parent
+          sever << node
+          node = node.parent
+        end
+        saved = sever.map(&:parent)
+        sever.each { |n| n.parent = nil }
+        Marshal.load(Marshal.dump(obj))
+      ensure
+        sever.each_with_index { |n, i| n.parent = saved[i] }
+      end
+
+      # Rewrite SimpleReference ids against a rename map in ONE tree walk
+      # (each declaration is walked once, whatever the map's size — walking
+      # once per rename made flattening quadratic in the closure).
+      # Map keys are downcased old names, values the final names.
+      def rewrite_references(node, map)
+        return unless node.is_a?(Model::ModelElement)
+
+        if node.is_a?(Model::References::SimpleReference) && node.id &&
+            (to = map[node.id.safe_downcase])
+          node.id = preserve_case(node.id, to)
+        end
+        node.class.attributes.each_key do |attr|
+          next if Model::ModelElement::SKIP_ATTRIBUTES.include?(attr) || attr == :parent
+
+          value = node.public_send(attr)
+          case value
+          when Array then value.each { |item| rewrite_references(item, map) }
+          when Model::ModelElement then rewrite_references(value, map)
+          end
+        end
+      end
+
+      def preserve_case(current, new)
+        current == current.upcase ? new.upcase : new
+      end
+
+      # G.1.6: parse-templates keep the annex rule/function verbatim.
+      def build_dependent_rule
+        list = @reference_entities.map(&:upcase).join(", ")
+        union = @reference_entities.join("+")
+        src = <<~EXP
+          SCHEMA __dependent__;
+          RULE #{DEPENDENT_RULE_NAME} FOR (#{list});
+          LOCAL
+            number_of_input_instances : INTEGER;
+            previous_in_chain : LIST OF GENERIC := [];
+            set_of_input_types : SET OF STRING := [];
+            all_instances : SET OF GENERIC := [];
+          END_LOCAL;
+          all_instances := #{union};
+          WHERE
+            wr1: dependently_instantiated(all_instances, set_of_input_types, previous_in_chain);
+          END_RULE;
+          END_SCHEMA;
+        EXP
+        parse_schema_snippet(src).schemas.first.rules.first
+      end
+
+      def parse_schema_snippet(src)
+        Expressir::Express::Parser.from_exp(src)
+      end
+
+      # ---- G.2 stage 2 ----
+
+      def build_longform
+        artifact = build_artifact
+
+        if @extenders == :all
+          resolve_extensible_enumerations!(artifact)
+          resolve_extensible_selects!(artifact)
+        end
+        eliminate_subtype_constraints!(artifact)
+        convert_abstract_entities!(artifact)
+        convert_generic_entities!(artifact)
+        convert_renamed_attributes!(artifact)
+        rewrite_qualified_strings!(artifact)
+
+        artifact
+      end
+
+      def resolve_extensible_enumerations!(schema)
+        schema.types.select do |t|
+          t.underlying_type.is_a?(Model::DataTypes::Enumeration) && t.underlying_type.extensible
+        end.each do |base|
+          enum = base.underlying_type
+          extensions = schema.types.select do |t|
+            t.underlying_type.is_a?(Model::DataTypes::Enumeration) &&
+              !t.underlying_type.extensible &&
+              t.underlying_type.based_on&.id&.safe_downcase == base.id.safe_downcase
+          end
+          merged = enum.items.map(&:id) +
+            extensions.flat_map { |x| x.underlying_type.items.map(&:id) }
+          enum.items = merged.uniq.map { |id| Model::DataTypes::EnumerationItem.new(id: id) }
+          enum.extensible = false
+          enum.based_on = nil
+
+          extensions.each do |ext|
+            ext_items = ext.underlying_type.items.map(&:id)
+            exclusions = merged - ext_items
+            ext.underlying_type = Model::DataTypes::Enumeration.new(
+              items: enum.items,
+            )
+            ext.where_rules = exclusions.each_with_index.map do |item, i|
+              Model::Declarations::WhereRule.new(
+                id: "wr#{i + 1}",
+                expression: parse_expression("SELF <> #{item};"),
+              )
+            end
+          end
+        end
+      end
+
+      def resolve_extensible_selects!(schema)
+        schema.types.select do |t|
+          t.underlying_type.is_a?(Model::DataTypes::Select) && t.underlying_type.extensible
+        end.each do |base|
+          sel = base.underlying_type
+
+          # all-extenders for GENERIC_ENTITY selects (WG12 requirement,
+          # #32): the extenders are the entity types themselves — fold in
+          # every entity the artifact carries, so the longform select is
+          # complete against the closure. Flags stay as declared: the
+          # extensible/generic-entity markers are part of the shortform's
+          # semantics and are not expressir's to drop.
+          if sel.generic_entity
+            sel.items = schema.entities.map do |e|
+              Model::References::SimpleReference.new(id: e.id)
+            end
+            next
+          end
+
+          extensions = schema.types.select do |t|
+            t.underlying_type.is_a?(Model::DataTypes::Select) &&
+              !t.underlying_type.extensible &&
+              t.underlying_type.based_on&.id&.safe_downcase == base.id.safe_downcase
+          end
+          merged_items = sel.items +
+            extensions.flat_map { |x| x.underlying_type.items }
+          seen_ids = {}
+          uniq = merged_items.select do |item|
+            key = item.id.safe_downcase
+            next false if seen_ids.key?(key) || key.empty?
+
+            seen_ids[key] = true
+          end
+          sel.items = uniq
+          sel.extensible = false
+          sel.based_on = nil
+
+          extensions.each do |ext|
+            keep = ext.underlying_type.items.map { |i| i.id.upcase }
+            exclusions = uniq.reject { |i| keep.include?(i.id.upcase) }
+            base_ref = "#{@longform_name.upcase}.#{base.id.upcase}"
+            ext.underlying_type = Model::DataTypes::Select.new(
+              items: sel.items.map { |i| Model::References::SimpleReference.new(id: i.id) },
+            )
+            ext.where_rules = exclusions.each_with_index.map do |item, i|
+              Model::Declarations::WhereRule.new(
+                id: "wr#{i + 1}",
+                expression: parse_expression("NOT ('#{base_ref}.#{item.id.upcase}' IN TYPEOF(SELF));"),
+              )
+            end
+          end
+        end
+      end
+
+      def eliminate_subtype_constraints!(schema)
+        schema.subtype_constraints.each do |sc|
+          entity = schema.entities.find do |e|
+            e.id.safe_downcase == sc.applies_to&.id&.safe_downcase
+          end
+          next unless entity
+
+          if sc.supertype_expression
+            expr = sc.supertype_expression
+            entity.supertype_expression =
+              entity.supertype_expression ? combine_andor(entity.supertype_expression, expr) : expr
+          end
+          if entity.abstract
+            # G.2.6: abstract entity ⇒ ABSTRACT SUPERTYPE (formatter
+            # renders from abstract + supertype status).
+          end
+          next if Array(sc.total_over).empty?
+
+          rule_name = "total_over_#{sc.id}"
+          targets = Array(sc.total_over).map { |r| r.id.upcase }
+          supertype = sc.applies_to&.id
+          rule = parse_schema_snippet(<<~EXP).schemas.first.rules.first
+            SCHEMA __to__;
+            RULE #{rule_name} FOR (#{supertype.upcase});
+            WHERE
+              wr1: SIZEOF(QUERY(#{supertype.downcase}_i <* #{supertype} |
+                SIZEOF(['#{@longform_name.upcase}.#{targets.first}'] * TYPEOF(#{supertype.downcase}_i)) = 0)) = 0;
+            END_RULE;
+            END_SCHEMA;
+          EXP
+          rule.id = rule_name
+          schema.rules = Array(schema.rules) + [rule]
+        end
+        schema.subtype_constraints = []
+      end
+
+      def combine_andor(left, right)
+        Model::SupertypeExpressions::BinarySupertypeExpression.new(
+          operator: Model::SupertypeExpressions::BinarySupertypeExpression::ANDOR,
+          operand1: left, operand2: right
+        )
+      rescue StandardError
+        left
+      end
+
+      def convert_abstract_entities!(schema)
+        schema.entities.each do |entity|
+          next unless entity.abstract
+
+          entity.abstract = true # formatter renders ABSTRACT SUPERTYPE when supertype present
+        end
+      end
+
+      def convert_generic_entities!(schema)
+        each_node(schema) do |node|
+          replace_in_parent(node, Model::DataTypes::Generic.new) if node.is_a?(Model::DataTypes::GenericEntity)
+        end
+      end
+
+      def replace_in_parent(node, replacement)
+        parent = node.parent
+        return unless parent
+
+        parent.class.attributes.each_key do |attr|
+          next if Model::ModelElement::SKIP_ATTRIBUTES.include?(attr)
+
+          value = parent.public_send(attr)
+          case value
+          when Array
+            value.each_with_index do |item, index|
+              parent.public_send(attr)[index] = replacement if item.equal?(node)
+            end
+          else
+            parent.public_send(:"#{attr}=", replacement) if value.equal?(node) && parent.respond_to?(:"#{attr}=")
+          end
+        end
+      end
+
+      def convert_renamed_attributes!(schema)
+        schema.entities.each do |entity|
+          entity.attributes.each_with_index do |attr, i|
+            next unless attr.supertype_attribute
+
+            old_name, supertype = supertype_target(attr.supertype_attribute)
+            entity.attributes[i] = Model::Declarations::DerivedAttribute.new(
+              id: attr.id || old_name,
+              type: attr.type,
+              expression: parse_expression("SELF\\#{supertype}.#{old_name}"),
+            )
+          end
+        end
+      end
+
+      # `SELF\ENTITY.attr` parses as AttributeReference(ref: GroupReference
+      # (SELF, entity), attribute: attr); a bare qualified attribute has
+      # only the attribute name.
+      def supertype_target(ref)
+        return [ref.id, nil] unless ref.is_a?(Model::References::AttributeReference)
+
+        group = ref.ref
+        [ref.attribute&.id,
+         group.is_a?(Model::References::GroupReference) ? group.entity&.id : nil]
+      end
+
+      # G.NM.2: string literals carrying schema-qualified names (e.g.
+      # TYPEOF arguments 'SCHEMA.TYPE') move to the longform name.
+      # Structurally these appear as DataTypes::String; path references
+      # in expressions are already renamed by the copy pass.
+      def rewrite_qualified_strings!(schema)
+        prefixes = closure.keys.map(&:upcase)
+        each_node(schema) do |node|
+          next unless node.is_a?(Model::Literals::String) && node.value
+
+          node.value = node.value.sub(/\A(#{prefixes.join('|')})\./i,
+                                      "#{@longform_name.upcase}.")
+        end
+      end
+
+      # Attribute-driven structural traversal over the whole subtree.
+      def each_node(root, &)
+        stack = [root]
+        until stack.empty?
+          node = stack.pop
+          yield node
+          next unless node.is_a?(Model::ModelElement)
+
+          node.class.attributes.each_key do |attr|
+            next if Model::ModelElement::SKIP_ATTRIBUTES.include?(attr)
+
+            value = node.public_send(attr)
+            case value
+            when Array then value.each { |item| stack << item if item.is_a?(Model::ModelElement) }
+            when Model::ModelElement then stack << value
+            end
+          end
+        end
+      end
+
+      def parse_expression(src)
+        snippet = "SCHEMA __x__; ENTITY __e__; WHERE w1 : #{src.chomp(';')}; END_ENTITY; END_SCHEMA;"
+        parsed = parse_schema_snippet(snippet)
+        parsed.schemas.first.entities.first.where_rules.first.expression
+      end
+    end
+  end
+end

data/lib/expressir/express.rb

@@ -10,23 +10,36 @@ module Expressir
 
     # Core classes (autoloaded for lazy loading)
     autoload :Cache, "#{__dir__}/express/cache"
+    autoload :Checker, "#{__dir__}/express/checker"
+    autoload :Concatenator, "#{__dir__}/express/concatenator"
+    autoload :Core, "#{__dir__}/express/core"
+    autoload :RemarkOverlay, "#{__dir__}/express/remark_overlay"
+    autoload :ModelTraversal, "#{__dir__}/express/model_traversal"
+    autoload :RefsOverlay, "#{__dir__}/express/refs_overlay"
     autoload :Error, "#{__dir__}/express/error"
     autoload :Formatter, "#{__dir__}/express/formatter"
     autoload :Formatters, "#{__dir__}/express/formatters"
     autoload :Grammar, "#{__dir__}/express/grammar"
     autoload :HyperlinkFormatter, "#{__dir__}/express/hyperlink_formatter"
+    autoload :InterfaceDot, "#{__dir__}/express/interface_dot"
     autoload :LineMap, "#{__dir__}/express/line_map"
+    autoload :Listing, "#{__dir__}/express/listing"
     autoload :ModelVisitor, "#{__dir__}/express/model_visitor"
     autoload :NodePositionIndex, "#{__dir__}/express/node_position_index"
     autoload :ParallelFiles, "#{__dir__}/express/parallel_files"
     autoload :Parser, "#{__dir__}/express/parser"
     autoload :PrettyFormatter, "#{__dir__}/express/pretty_formatter"
+    autoload :PrettyGate, "#{__dir__}/express/pretty_gate"
     autoload :RemarkAttacher, "#{__dir__}/express/remark_attacher"
     autoload :RemarkScanner, "#{__dir__}/express/remark_scanner"
     autoload :ResolveReferencesModelVisitor,
              "#{__dir__}/express/resolve_references_model_visitor"
+    autoload :SelfSchemaReference, "#{__dir__}/express/self_schema_reference"
+    autoload :Shtolo, "#{__dir__}/express/shtolo"
     autoload :SchemaBlockScanner, "#{__dir__}/express/schema_block_scanner"
     autoload :SchemaHeadFormatter, "#{__dir__}/express/schema_head_formatter"
+    autoload :SchemaPlainSourceFormatter,
+             "#{__dir__}/express/schema_plain_source_formatter"
     autoload :SchemaSourceFormatter, "#{__dir__}/express/schema_source_formatter"
     autoload :ScopeResolver, "#{__dir__}/express/scope_resolver"
     autoload :SourceFormatter, "#{__dir__}/express/source_formatter"