hecks 0.2.0 → 0.3.0

data/lib/hecks/projections/oidc.rb

@@ -0,0 +1,110 @@
+require_relative "../naming"
+require_relative "../projector"
+
+module Hecks
+  module Projections
+    # AN OIDC CLIENT/SCOPE MANIFEST derived from a domain's own IR: what
+    # an identity provider has to know about this domain before it can
+    # issue a token that means anything here.
+    #
+    # THE ARTIFACT HALF OF SOMETHING ALREADY HALF-BUILT.
+    # `spec/oidc_projection_spec.rb` covers the INTEGRATION half — verified
+    # claims in, `IdentityResolution.resolve` → `Authorization.holds_role?`
+    # → a dispatch scoped by `Hecks.as_caller(role:)`. That half enforces
+    # a role per command. It just had no way to say, up front and as data,
+    # WHICH role each command wants — every answer came from asking the
+    # live runtime one dispatch at a time.
+    #
+    # This is that catalogue, and the two are checked against each other
+    # rather than merely coexisting: `verb` here is spelled exactly as
+    # `Runtime::Dispatcher#dispatch` takes it and exactly as
+    # `Bluebook#verbs` lists it, so a scope can never name a command
+    # the domain does not have (spec/projections/oidc_projection_spec.rb
+    # holds the two lists equal), and `role` is the same string
+    # `Ports::Authorization.holds_role?` compares against a real
+    # `Governance::RoleAssignment`.
+    #
+    # ROLES COME FROM THE COMMANDS, NOT FROM GOVERNANCE. A command's own
+    # `role "Compliance officer"` is in the bluebook IR
+    # (`Command#role`), whereas `uses_framework "Governance"` is
+    # declared in the `.hecksagon` — which `call(bluebook:, options:)`
+    # cannot see at all. Reading the commands is both the only thing
+    # available here AND the more accurate source: it says what each
+    # command actually demands, not merely which role vocabulary the
+    # application happened to mount.
+    #
+    # A command with no declared role projects `"role" => nil` rather
+    # than being dropped — an unguarded command is a real fact about the
+    # domain, and silently omitting it would make the manifest read as
+    # though the command did not exist.
+    module OIDC
+      extend Projector::Target
+
+      projects_as :oidc
+
+      module_function
+
+      # `audience:` overrides the domain name, for the ordinary case
+      # where the IdP's registered audience is a URL rather than a bare
+      # chapter name.
+      def call(bluebook:, options: {})
+        scopes = scopes_for(bluebook)
+
+        {
+          "audience" => (options[:audience] || bluebook.name).to_s,
+          "scopes"   => scopes,
+          "roles"    => scopes.map { |scope| scope["role"] }.compact.uniq.sort
+        }
+      end
+
+      # Sorted by scope, not left in declaration order — a manifest is
+      # something two versions of get diffed, and the same precedent
+      # `StorageShape.project` sets for its own aggregate list.
+      #
+      # Recurses into entities, not just an aggregate's own direct
+      # commands — the exact same gap `Bluebook#verbs` closed for the
+      # same reason (`chapter.rb`'s own comment): a command reached
+      # through `Dispatcher#dispatch`'s dotted `Entity.Command` routing
+      # is real and callable, so a manifest that never names it can
+      # never grant a client a scope for it either.
+      def scopes_for(bluebook)
+        bluebook.aggregates.flat_map { |aggregate| aggregate_scopes(bluebook, aggregate) }
+                .sort_by { |scope| scope["scope"] }
+      end
+
+      def aggregate_scopes(bluebook, aggregate)
+        verb_prefix  = "#{bluebook.name}::#{aggregate.hecks_name}"
+        scope_prefix = "#{Naming.snake(bluebook.name)}:#{Naming.snake(aggregate.hecks_name)}"
+
+        command_scopes(aggregate.commands, verb_prefix, scope_prefix) +
+          aggregate.entities.flat_map { |entity| entity_scopes(entity, verb_prefix, scope_prefix) }
+      end
+
+      # S17, ADR 0026 — an entity can nest further entities (`Dispatch`,
+      # inside `Handler`), so this recurses the same way `Chapter#verbs`
+      # now does. The verb and scope prefixes grow in lockstep, each
+      # `.`-joined the same way its own kind already was.
+      def entity_scopes(entity, verb_prefix, scope_prefix)
+        verb_prefix  = "#{verb_prefix}.#{entity.hecks_name}"
+        scope_prefix = "#{scope_prefix}.#{Naming.snake(entity.hecks_name)}"
+
+        command_scopes(entity.commands, verb_prefix, scope_prefix) +
+          entity.entities.flat_map { |piece| entity_scopes(piece, verb_prefix, scope_prefix) }
+      end
+
+      # `banking:account.open` — the shape an OIDC scope is conventionally
+      # spelled in, and snake_cased through the SAME `Naming.snake` the
+      # facade uses to name a command's own door method, so a scope and
+      # the Ruby call that satisfies it cannot drift apart.
+      def command_scopes(commands, verb_prefix, scope_prefix)
+        commands.map do |command|
+          {
+            "scope" => "#{scope_prefix}.#{Naming.snake(command.hecks_name)}",
+            "verb"  => "#{verb_prefix}.#{command.hecks_name}",
+            "role"  => command.role
+          }
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/parser_table.rb

@@ -0,0 +1,159 @@
+require_relative "../projector"
+
+module Hecks
+  module Projections
+    # THE RUST PARSER'S KEYWORD TABLE, projected from the chapter's own
+    # Syntax aggregate — "the parser's grammar knowledge is DERIVED from
+    # hecks's self-description, not hand-typed a second time", which
+    # is the anti-drift idea the whole Rust-parser plan rests on.
+    #
+    # A REGISTERED TARGET NOW, rather than a module living inside its own
+    # bin/ script. It was already a projection in everything but call
+    # shape; this only stops it being a fifth way of spelling one.
+    module ParserTable
+      extend Projector::Target
+      projects_as :parser_table, declares: "Syntax"
+
+      module_function
+
+      def call(bluebook:, options: {}) = render(bluebook)
+
+      module_function
+
+      # THE CHAPTER IS HANDED OVER, not reached for. This used to open the
+      # grammar registry itself, which meant the projection could only ever
+      # project one chapter — the language's own. Taking it as an argument is
+      # what the projector protocol asks for, and it costs nothing.
+      def syntax(bluebook) = bluebook.aggregate("Syntax")
+
+      # Every cell as text — exactly spec/syntax_conformance_spec.rb's own
+      # `rows` helper, reused rather than re-derived: a member's fields decode
+      # back through typed literal decoding on the way out of reconstruction,
+      # and this reads it back as what was written.
+      def rows(bluebook, name)
+        syntax(bluebook).value_objects.find { |vo| vo.hecks_name == name }
+              .members.map { |row| row.to_h.transform_values(&:to_s) }
+      end
+
+      def closed_set_members(bluebook, name) = rows(bluebook, name).map { |row| row[:name] }
+
+      KEYWORD_FIELDS  = %i[word context body inner opens fills status was resolves_via disambiguator].freeze
+      ARGUMENT_FIELDS = %i[keyword context at named kind required fills selects
+                           pair_key_fills pair_value_fills pairs_shape status variadic minimum].freeze
+
+      # A Rust string literal for one field's value — every field here is
+      # plain ASCII (a word, a context name, a digit, "true"/"false"), so this
+      # only has to be safe against the two characters Rust string literals
+      # themselves reserve.
+      def rust_string(value) = "\"#{value.to_s.gsub('\\', '\\\\\\\\').gsub('"', '\\"')}\""
+
+      def keyword_row(row)
+        fields = KEYWORD_FIELDS.map { |field| rust_string(row[field]) }
+        "    KeywordRow { #{KEYWORD_FIELDS.zip(fields).map { |name, value| "#{name}: #{value}" }.join(', ')} },"
+      end
+
+      def argument_row(row)
+        fields = ARGUMENT_FIELDS.map { |field| rust_string(row[field]) }
+        "    ArgumentRow { #{ARGUMENT_FIELDS.zip(fields).map { |name, value| "#{name}: #{value}" }.join(', ')} },"
+      end
+
+      def const_str_array(name, values)
+        lines = values.map { |value| "    #{rust_string(value)}," }
+        "pub static #{name}: &[&str] = &[\n#{lines.join("\n")}\n];\n"
+      end
+
+      # S14, ADR 0026 — Keyword/Argument are genuine entities of Syntax
+      # now, dispatched (not merely declared) so their own `status`
+      # really is a lifecycle. `SyntaxBoot.call` reads the STILL-STATIC
+      # seed rows (`KeywordSeed`/`ArgumentSeed`), dispatches each one
+      # through the real admission/lifecycle door, and hands back the
+      # exact same shape `rows` used to read straight off the closed set
+      # — symbol keys, string values, `status` included — so nothing
+      # else in this file needed to change.
+      def render(bluebook)
+        table     = Hecks::Bluebook::MetaValidator::SyntaxBoot.call
+        keywords  = table[:keywords]
+        arguments = table[:arguments]
+
+        <<~RUST
+          // GENERATED by bin/project_parser_table from
+          // aggregate-local syntax tables under lib/hecks/language/ — DO NOT EDIT BY HAND.
+          //
+          // Re-run `bin/project_parser_table` after any syntax-table change.
+          // spec/parser_table_spec.rb regenerates this into memory and fails the
+          // normal `bundle exec rspec` suite the moment this file drifts from what
+          // the language currently declares — see that spec and
+          // bin/project_parser_table's own header for why this file is never
+          // hand-edited.
+
+          #[derive(Debug, Clone, Copy)]
+          pub struct KeywordRow {
+              pub word: &'static str,
+              pub context: &'static str,
+              pub body: &'static str,
+              pub inner: &'static str,
+              pub opens: &'static str,
+              pub fills: &'static str,
+              pub status: &'static str,
+              pub was: &'static str,
+              /// Which shared Hecks::Bluebook::DSL::RuleReference
+              /// primitive this word's own bare form resolves through,
+              /// once it has one ("hash_chain" / "owner_keyed" /
+              /// "sibling_scan") — "" for every word that only ever
+              /// declares.
+              pub resolves_via: &'static str,
+              /// Which disambiguator keyword argument a bare reference
+              /// may supply — "declared_by" today, "" otherwise.
+              pub disambiguator: &'static str,
+          }
+
+          #[derive(Debug, Clone, Copy)]
+          pub struct ArgumentRow {
+              pub keyword: &'static str,
+              pub context: &'static str,
+              pub at: &'static str,
+              pub named: &'static str,
+              pub kind: &'static str,
+              pub required: &'static str,
+              pub fills: &'static str,
+              pub selects: &'static str,
+              pub pair_key_fills: &'static str,
+              pub pair_value_fills: &'static str,
+              pub pairs_shape: &'static str,
+              pub status: &'static str,
+              pub variadic: &'static str,
+              pub minimum: &'static str,
+          }
+
+          impl KeywordRow {
+              /// An absent status reads as admitted — the grown-column convention
+              /// syntax_conformance_spec.rb's own `status_of`/`live?` already use.
+              pub fn live(&self) -> bool {
+                  matches!(self.status, "" | "admitted" | "deprecated")
+              }
+          }
+
+          impl ArgumentRow {
+              pub fn live(&self) -> bool {
+                  matches!(self.status, "" | "admitted" | "deprecated")
+              }
+          }
+
+          pub static KEYWORDS: &[KeywordRow] = &[
+          #{keywords.map { |row| keyword_row(row) }.join("\n")}
+          ];
+
+          pub static ARGUMENTS: &[ArgumentRow] = &[
+          #{arguments.map { |row| argument_row(row) }.join("\n")}
+          ];
+
+          #{const_str_array('CONTEXTS', closed_set_members(bluebook, 'Context'))}
+          #{const_str_array('BODIES', closed_set_members(bluebook, 'Body'))}
+          #{const_str_array('ARGUMENT_KINDS', closed_set_members(bluebook, 'ArgumentKind'))}
+          #{const_str_array('PAIRS_SHAPES', closed_set_members(bluebook, 'PairsShape'))}
+          #{const_str_array('STATUSES', closed_set_members(bluebook, 'Status'))}
+        RUST
+      end
+    end
+  end
+end

data/lib/hecks/projections/reference.rb

@@ -0,0 +1,38 @@
+require_relative "../doc/reference"
+require_relative "../projector"
+
+module Hecks
+  module Projections
+    # THE DSL REFERENCE PAGES, projected from the chapter's own Syntax
+    # aggregate — the tables come from the declaration, the prose is
+    # preserved from whatever is already committed.
+    #
+    # THE FIRST PROJECTION THAT EMITS A TREE. `emits: :files` says so,
+    # and the framework writes the map rather than inferring one: a Hash
+    # of path => contents and a Hash that merely holds strings are the
+    # same object to Ruby, so only the projection can know which it
+    # meant. This is the case the output contract was designed for and
+    # deliberately left unimplemented until something real needed it.
+    #
+    # NOT PURE, and it cannot be. `Doc::Reference.pages` READS the
+    # committed pages to harvest their prose, so the existing directory
+    # is an input — passed as `from:` rather than assumed, so the
+    # projection never reaches for a path of its own choosing.
+    module Reference
+      extend Projector::Target
+
+      projects_as :reference, declares: "Syntax", emits: :files
+
+      module_function
+
+      def call(bluebook:, options: {})
+        from = options[:from] or
+          raise ArgumentError,
+                ":reference harvests prose from the committed pages, so it needs " \
+                "`from:` — the directory they live in"
+
+        Doc::Reference.pages(from)
+      end
+    end
+  end
+end

data/lib/hecks/projections/shape.rb

@@ -0,0 +1,31 @@
+require_relative "../runtime/storage_shape"
+require_relative "../projector"
+
+module Hecks
+  module Projections
+    # THE STORAGE SHAPE of one bluebook — the same structural form
+    # `StorageShape.mint_hash` hashes to name an era, which is what makes
+    # a bump/no-bump question answerable by diffing two of these.
+    #
+    # THE RETROFIT, and the point of it: `Runtime::StorageShape.project`
+    # was written long before this framework existed, and it already
+    # takes exactly one bluebook, already returns a plain Hash, already
+    # touches no disk and no live runtime — it even already uses the
+    # word. Nothing about it was shaped to fit `call(bluebook:, options:)`.
+    #
+    # That it fits anyway, by a two-line keyword adapter and no change to
+    # `StorageShape` itself, is the evidence that the protocol is a real
+    # description of what projections do here rather than a shape fitted
+    # around its own first example (`:ir`, whose `call` is `to_h`, proves
+    # much less on its own).
+    module Shape
+      extend Projector::Target
+
+      projects_as :shape
+
+      module_function
+
+      def call(bluebook:, options: {}) = Runtime::StorageShape.project(bluebook)
+    end
+  end
+end

data/lib/hecks/projections/statements.rb

@@ -0,0 +1,110 @@
+require_relative "../projector"
+
+module Hecks
+  module Projections
+    # A DOMAIN'S OWN DECLARED FACTS, PROJECTED AS PLAIN ENGLISH SENTENCES
+    # — one atomic, independently-checkable statement per fact, not a
+    # flowing document (`Projections::Reference`/`DocsProjector` already
+    # do that job well; this is a flat list a caller can iterate, diff,
+    # or hand to something else entirely — a review, a test-plan seed,
+    # a sanity check that the domain still says what someone thinks it
+    # says).
+    #
+    # NEVER INVENTS A SENTENCE FROM NOTHING — `DocsProjector`'s own
+    # discipline, held here too: a relationship's sentence is built
+    # MECHANICALLY from its own declared shape (holder, target,
+    # relationship kind — the same facts `Projections::Diagrams`'s own
+    # relationship_edge already reads), and an invariant's sentence IS
+    # the domain author's own `description`, capitalized and
+    # punctuated, never paraphrased. If a fact has no author-written
+    # description and no unambiguous mechanical phrasing, it doesn't
+    # get a sentence here — a wrong sentence is worse than a missing
+    # one.
+    #
+    # REACHABLE THE SAME WAY EVERY PROJECTION ALREADY IS, no new facade
+    # wiring needed: `Pizzas.project(Projections::Statements)` —
+    # `Facade::Surface::Chapter#project`'s own comment already settled
+    # this ("anything genuinely needing the graph is a projector, and a
+    # projector is given it"). `bin/statements` is a thin, optional
+    # convenience for reaching the same call from a shell.
+    #
+    # MVP SCOPE: "has many"/"has a"/"belongs to"/"references" sentences
+    # for every list or relationship attribute, and every invariant's
+    # own description (aggregate-level and every nested value object's),
+    # verbatim. Lifecycle transitions and command given/ensures read the
+    # same way and are the natural next sentences — not built yet.
+    module Statements
+      extend Hecks::Projector::Target
+
+      projects_as :statements
+
+      module_function
+
+      def call(bluebook:, options: {})
+        holders(bluebook).flat_map { |holder| statements_for(holder) }
+      end
+
+      def holders(bluebook) = bluebook.aggregates.flat_map { |aggregate| [aggregate, *aggregate.entities] }
+
+      def statements_for(holder)
+        attribute_statements(holder) + invariant_statements(holder)
+      end
+
+      # "MANY" READS THE SAME WAY REGARDLESS OF WHAT'S BEHIND IT — a
+      # `has_many` relationship to another aggregate and a plain
+      # `list_of(Topping)` value-object attribute are the same idea to
+      # someone reading the domain in English ("an Order has many
+      # toppings" is true either way), even though they're two
+      # different IR shapes (a `Reference` versus an ordinary type).
+      # `attribute.name` carries the noun, not the target's own class
+      # name, because the field's own name is what the domain author
+      # actually chose to call the collection — "toppings", not
+      # "Topping".
+      def attribute_statements(holder)
+        holder.attributes.filter_map { |attribute| attribute_statement(holder, attribute) }
+      end
+
+      def attribute_statement(holder, attribute)
+        subject = "#{article(holder.hecks_name)} #{holder.hecks_name}"
+        return "#{subject} has many #{attribute.name}." if attribute.list?
+
+        target = attribute.relationship && attribute.type.target_name
+        target_phrase = target && "#{article(target).downcase} #{target}"
+        case attribute.relationship
+        when "has_one"      then "#{subject} has #{target_phrase}."
+        when "belongs_to"   then "#{subject} belongs to #{target_phrase}."
+        when "reference_to" then "#{subject} references #{target_phrase}."
+        end
+      end
+
+      # "AN ACCOUNT", NOT "A ACCOUNT" — every subject/object noun here is
+      # a bare construct name (`ATMCard`, `ExternalTransfer`, `Account`),
+      # never free text, so the ordinary "starts with a vowel LETTER"
+      # heuristic is safe: this language's own naming never produces the
+      # English exceptions that heuristic gets wrong (an "hour", a
+      # "university") because a construct name is always spelled as a
+      # plain word, never an abbreviation read letter-by-letter or a
+      # word starting with a consonant LETTER but a vowel SOUND.
+      def article(word) = word.to_s.match?(/\A[AEIOUaeiou]/) ? "An" : "A"
+
+      # INVARIANTS LIVE IN TWO PLACES — directly on the holder (an
+      # aggregate-level rule, checked after every command) and on every
+      # value object nested inside it — `DocsProjector#rules_of`'s own
+      # `value_object_for` lookup is the precedent for walking both.
+      def invariant_statements(holder)
+        own = Array(holder.respond_to?(:invariants) ? holder.invariants : [])
+        nested = Array(holder.respond_to?(:value_objects) ? holder.value_objects : []).flat_map(&:invariants)
+        (own + nested).map { |invariant| invariant_statement(invariant) }
+      end
+
+      # THE DOMAIN AUTHOR'S OWN WORDS, CAPITALIZED AND PUNCTUATED —
+      # nothing else. `invariant("a pizza is named")` already reads as
+      # a sentence; this is the entire transformation.
+      def invariant_statement(invariant)
+        text = invariant.description.to_s.strip
+        text = "#{text[0].upcase}#{text[1..]}" if text[0]
+        text.end_with?(".", "!", "?") ? text : "#{text}."
+      end
+    end
+  end
+end

data/lib/hecks/projections/vocabulary.rb

@@ -0,0 +1,100 @@
+require_relative "../projector"
+
+module Hecks
+  module Projections
+    # THE CLOSED SETS, PROJECTED — lib/hecks/vocabulary.rb rendered
+    # from whichever chapter declares a `Vocabulary` aggregate, which in
+    # practice is the language projecting its own tables.
+    #
+    #   Projector.call(:vocabulary, bluebook: <the Bluebook chapter>)
+    #
+    # A PROJECTION RATHER THAN A BIN/ SCRIPT, and that correction is the
+    # point of it. This was first written as its own program with its own
+    # call shape, beside `bin/project_parser_table`, `bin/reference` and
+    # `bin/expression_projection` — four tools doing "canonical IR in,
+    # external artifact out" four different ways, which is the exact
+    # thing the projector registry exists to stop.
+    #
+    # Reads the chapter's JUDGED IR, so what is written out is what the
+    # language actually holds rather than what a builder happened to
+    # produce.
+    module Vocabulary
+      extend Projector::Target
+
+      projects_as :vocabulary, declares: "Vocabulary"
+
+      HEADER = <<~RUBY.freeze
+        # GENERATED — projected from the language's own Vocabulary aggregate
+        # (lib/hecks/language/bluebook/vocabulary.bluebook).
+        #
+        # DO NOT EDIT. spec/vocabulary_table_spec.rb re-projects this in memory
+        # and refuses a diff, so an edit here fails the ordinary suite.
+        #
+        # Plain data on purpose — no requires, no dependency on the model —
+        # because several of these sets are read while a bluebook is still
+        # being parsed. A table that needed the framework to load could not
+        # be the table the framework loads with.
+      RUBY
+
+      module_function
+
+      # The projector protocol. `options` is unused: a vocabulary table
+      # has nothing to vary.
+      def call(bluebook:, options: {}) = render(bluebook)
+
+      # FULL ROWS, not just the first field of each.
+      #
+      # Most vocabularies ARE one-field lists and the field is the term.
+      # Several are not: `Comparison` declares the algebra each operator
+      # computes with, `RefusalTemplate` an error plus its key and text.
+      # Taking the first field of those produced a list of thirty-nine
+      # duplicated error names — well-formed and meaningless. So rows are
+      # carried whole, and the terms are derived from them.
+      def tables(bluebook)
+        bluebook.aggregate("Vocabulary").value_objects.to_h do |vo|
+          [vo.hecks_name, vo.members.map { |row| row.to_h.transform_keys(&:to_s).transform_values(&:to_s) }]
+        end
+      end
+
+      def render(bluebook)
+        rows = tables(bluebook).sort_by(&:first).map do |name, members|
+          "      #{name.inspect} => [\n" +
+            members.map { |row| "        #{row.inspect}.freeze" }.join(",\n") +
+            "\n      ].freeze"
+        end
+
+        <<~RUBY
+          #{HEADER}
+          module Hecks
+            module Vocabulary
+              TABLES = {
+          #{rows.join(",\n")}
+              }.freeze
+
+              # THE TERMS — the first field of each row, which for a
+              # one-field vocabulary is the whole of it. Derived ONCE and
+              # frozen rather than mapped per call: these are constant
+              # tables, and a constant that allocates a new array every
+              # time it is read is not one.
+              TERMS = TABLES.transform_values { |rows| rows.map { |row| row.values.first }.freeze }.freeze
+
+              module_function
+
+              # Refuses an unknown name rather than answering nil: a set
+              # the language does not declare is a typo, not an empty set.
+              def fetch(name) = TERMS.fetch(name)
+
+              # The rows whole, for the vocabularies that carry more than
+              # a term — Comparison's own algebra, RefusalTemplate's text.
+              def rows(name) = TABLES.fetch(name)
+
+              def symbols(name) = fetch(name).map(&:to_sym)
+
+              def names = TABLES.keys
+            end
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/hecks/projections.rb

@@ -0,0 +1,32 @@
+require_relative "projector"
+
+module Hecks
+  # THE TARGETS A DOMAIN CAN BE PROJECTED INTO, as constants rather than
+  # bare symbols — `Pizzas.project(Projections::OIDC)`.
+  #
+  # A constant is worth the namespace for two reasons a Symbol cannot
+  # give: a typo raises `NameError` at the call site instead of
+  # `UnknownProjector` at dispatch time, and each target has somewhere to
+  # carry its own documentation and defaults.
+  #
+  # Namespaced rather than top-level because `IR` is already taken —
+  # `Hecks::Bluebook` is the MODEL (`Bluebook::Command`, and the
+  # chapter class itself).
+  # `Projections::IR` is the projection OF that model, a different thing
+  # that would be genuinely confusing under the same bare name.
+  #
+  # `include Hecks::Projections` gets the short spelling where the
+  # extra qualification is noise (`bin/` scripts, a console session).
+  module Projections
+  end
+end
+
+require_relative "projections/ir"
+require_relative "projections/shape"
+require_relative "projections/oidc"
+require_relative "projections/vocabulary"
+require_relative "projections/parser_table"
+require_relative "projections/reference"
+require_relative "projections/model"
+require_relative "projections/diagrams"
+require_relative "projections/statements"