hecks 3.9.1 → 3.11.0

data/lib/hecks/adapters/driving/mcp_scope.rb

@@ -0,0 +1,213 @@
+require_relative "../../runtime/errors"
+
+module Hecks
+  module Adapters
+    module Driving
+      # What a spawned hecks mcp may do: every tool by default; only reader tools against named
+      # domains in reader mode; and in commands mode those plus `dispatch` of a closed list of
+      # commands — reach, not identity (ADR 0072, ADR 0089).
+      class McpScope
+        ENV_PREFIX         = "HECKS_SERVER_".freeze
+        TOOLS_VARIABLE     = "HECKS_SERVER_TOOLS".freeze
+        DOMAINS_VARIABLE   = "HECKS_SERVER_DOMAINS".freeze
+        COMMANDS_VARIABLE  = "HECKS_SERVER_COMMANDS".freeze
+        READERS            = "readers".freeze
+        COMMANDS           = "commands".freeze
+        MODES              = [READERS, COMMANDS].freeze
+        EXIT_STATUS        = 2
+
+        # The tools a reader server serves — each reads a domain or the server's own
+        # audit log and writes no domain state. `validate` still boots its
+        # domain, so it stays bound to the allowed set like every other tool.
+        READER_TOOLS = %w[query events state catalog describe validate domains history follow].freeze
+
+        # The tools a commands server serves: the reader tools, and `dispatch` for the allowed
+        # commands.
+        COMMAND_TOOLS = (READER_TOOLS + %w[dispatch]).freeze
+
+        # Argument names a restricted server never passes on, whatever command carries them: each
+        # one
+        # names a host or a URL, a binary to run, a place to write, a port to open, a store to
+        # switch to, or flips a command from a preview to a change of state.
+        DENIED_ARGUMENTS = %w[
+          adapter artifact confirm expected from gem_only header health_path host live no_wait npm_local
+          npm_only output path payload payload_file port rust_binary scheme stage_dir state_path stdio url
+          write
+        ].freeze
+
+        # Argument names whose values are paths (a comma-separated list for some). A restricted
+        # server
+        # passes them on only when each resolves, symlinks followed, inside `Storehouse::BOOT_ROOT`,
+        # and holds no colon: `host:repo` and `https://host/x` would otherwise pass as relative
+        # paths.
+        PATH_ARGUMENTS = %w[dir domain domains file fixture paths root script].freeze
+
+        # Argument names whose values are git refs: plain names only, so a value cannot read as an
+        # option to git.
+        REF_ARGUMENTS = %w[commit ref].freeze
+
+        # What a plain git ref looks like: no leading dash, no `..`, no spaces.
+        PLAIN_REF = %r{\A[A-Za-z0-9][A-Za-z0-9._/~^@-]*\z}
+
+        # Unrestricted when no HECKS_SERVER_* variable is set.
+        def self.from_env(env = ENV)
+          problems = EnvProblems.setting_problems(env)
+          raise ArgumentError, problems.join("\n") unless problems.empty?
+          return new(allowed_domains: nil) unless env[TOOLS_VARIABLE]
+
+          commands = env[TOOLS_VARIABLE] == COMMANDS ? EnvProblems.split_names(env[COMMANDS_VARIABLE]) : nil
+          new(allowed_domains: EnvProblems.split_paths(env[DOMAINS_VARIABLE]), allowed_commands: commands)
+        end
+
+        # Refuses to stderr, not stdout, which carries the MCP protocol.
+        def self.start!(server:, env: ENV, stderr: $stderr)
+          from_env(env)
+        rescue ArgumentError, Runtime::TypeMismatch => e
+          e.message.each_line { |line| stderr.puts("#{server}: refusing to start: #{line.chomp}") }
+          exit(EXIT_STATUS)
+        end
+
+        # The named domains, resolved against Storehouse::BOOT_ROOT; nil when unrestricted.
+        attr_reader :allowed_domains
+
+        # The command names a commands server dispatches, as the spawner wrote them; nil unless
+        # the server runs in commands mode.
+        attr_reader :allowed_commands
+
+        def initialize(allowed_domains:, allowed_commands: nil)
+          @allowed_domains = allowed_domains&.map { |path| Storehouse.confine!(path, DOMAINS_VARIABLE) }.freeze
+          @allowed_commands = allowed_commands&.dup&.freeze
+        end
+
+        def restricted?
+          !@allowed_domains.nil?
+        end
+
+        def commands_mode?
+          !@allowed_commands.nil?
+        end
+
+        def served_tools
+          commands_mode? ? COMMAND_TOOLS : READER_TOOLS
+        end
+
+        def permits_tool?(name)
+          !restricted? || served_tools.include?(name)
+        end
+
+        def refusal(name)
+          { ok:    false,
+            error: "#{name.inspect} is refused: this server runs in #{mode_label}, " \
+                   "which serves only #{served_tools.join(", ")}" }
+        end
+
+        # Checked before anything boots, so a path outside the allowed set never reaches
+        # Kernel.load.
+        def admit_domain!(domain)
+          return domain unless restricted?
+          return domain if @allowed_domains.include?(Storehouse.confine!(domain, "domain"))
+
+          raise Runtime::TypeMismatch,
+                "domain: #{domain.inspect} is refused: this server runs in #{mode_label} " \
+                "and reads only #{DOMAINS_VARIABLE}: #{@allowed_domains.join(", ")}"
+        end
+
+        # A commands server dispatches only the commands it was given. A requested name and each
+        # allowed name resolve through the alias map `dispatch` uses, and the resolved verbs are
+        # compared, so `complete` cannot reach a command of another aggregate that shares its short
+        # name, and an allowed name that resolves to nothing admits nothing.
+        #
+        # @param runtime [Runtime::Dispatcher] the booted domain
+        # @param command [String, nil] the command name the caller asked for
+        # @param args [Hash, nil] the arguments the caller gave it; see `admit_arguments!`
+        # @raise [Runtime::TypeMismatch] when the command is not on the list or an argument is
+        #   refused
+        def admit_command!(runtime, command, args = nil)
+          return unless commands_mode?
+
+          verbs = Storehouse.verbs_for(runtime, [command, *allowed_commands])
+          unless verbs.first && verbs.drop(1).include?(verbs.first)
+            raise Runtime::TypeMismatch,
+                  "command: #{command.to_s.inspect} is refused: this server runs in #{mode_label} " \
+                  "and dispatches only #{COMMANDS_VARIABLE}: #{allowed_commands.join(", ")}"
+          end
+
+          admit_arguments!(args)
+        end
+
+        # Every step of a batch is admitted before any step runs.
+        #
+        # @param runtime [Runtime::Dispatcher] the booted domain
+        # @param steps [Array<Hash>] the batch, each `{"command" => ..., "args" => ...}`
+        # @raise [Runtime::TypeMismatch] when a step names a command off the list or a bad argument
+        def admit_steps!(runtime, steps)
+          Array(steps).each do |step|
+            step = {} unless step.is_a?(Hash)
+            admit_command!(runtime, step["command"], step["args"])
+          end
+        end
+
+        # The arguments a restricted server is about to pass to a command or a question. A command
+        # list admits commands, not values, so each argument is checked by its name: a denied name
+        # is refused, a path must resolve inside the root with symlinks followed, and a git ref must
+        # be a plain name. Other names pass; a domain with an argument that reaches outside its own
+        # files should name it in `DENIED_ARGUMENTS` or `PATH_ARGUMENTS` (ADR 0089).
+        #
+        # @param args [Hash, Array, nil] the arguments as the caller gave them, nested or not
+        # @raise [Runtime::TypeMismatch] on the first argument refused
+        def admit_arguments!(args)
+          return unless restricted?
+
+          ArgumentPolicy.admit!(args, mode_label)
+        end
+
+        # The one domain a restricted server serves, when it serves exactly one: a call may leave
+        # `domain:` out and get it. Nil for an unrestricted server and for one that names several.
+        #
+        # @return [String, nil] the domain path as `HECKS_SERVER_DOMAINS` named it, resolved
+        def default_domain
+          @allowed_domains.first if restricted? && @allowed_domains.size == 1
+        end
+
+        # The arguments with the default domain filled in when the caller left it out.
+        #
+        # @param args [Hash] a tool call's arguments
+        # @return [Hash] `args`, with `"domain"` set when the server has a default and none was
+        #   given
+        def with_default_domain(args)
+          return args unless default_domain && args["domain"].to_s.strip.empty?
+
+          args.merge("domain" => default_domain)
+        end
+
+        # The tool as `tools/list` shows it; see `Presenter.present`.
+        #
+        # @param tool [Hash] a tool definition from `Mcp::TOOLS`
+        # @param guide [Array<String>, nil] one line per allowed command
+        #   (`Storehouse.command_guide`)
+        # @return [Hash] the definition, narrowed for this server
+        def present(tool, guide = nil)
+          Presenter.present(self, tool, guide)
+        end
+
+        def notes
+          return [] unless restricted?
+
+          return Presenter.reader_notes(@allowed_domains) unless commands_mode?
+
+          Presenter.commands_notes(@allowed_domains, @allowed_commands)
+        end
+
+        private
+
+        def mode_label
+          commands_mode? ? "commands mode (#{TOOLS_VARIABLE}=#{COMMANDS})" : "reader mode (#{TOOLS_VARIABLE}=#{READERS})"
+        end
+      end
+    end
+  end
+end
+
+require_relative "mcp_scope/env_problems"
+require_relative "mcp_scope/argument_policy"
+require_relative "mcp_scope/presenter"

data/lib/hecks/adapters/driving/ruby/aggregate_module.rb

@@ -0,0 +1,171 @@
+require_relative "../../../bluebook/dsl/hecksagon_builder"
+require_relative "../../../bluebook/dsl/world_builder"
+require_relative "../../../bluebook/dsl/domain_port_builder"
+require_relative "../../../bluebook/dsl/const_shim"
+require_relative "../../../bluebook/dsl/binding_proxy"
+require_relative "../../../bluebook/hecksagon"
+require_relative "../handle"
+require_relative "../../../naming"
+
+module Hecks
+  module Adapters
+    module Driving
+      module Ruby
+        # One aggregate module: creating verbs and queries as module methods, CRUD
+        # delegation, and the `.hecksagon` binding/port hooks it lands on.
+        module AggregateModule
+          # Builds one aggregate module: creating-command methods, query methods,
+          # find/all/count/events, project/docs/narrate, and the port/binding hooks.
+          #
+          # Kept as one method: `:port`/`:method_missing`/`:const_missing` below
+          # cross-reference each other and would lose that thread if split up.
+          # rubocop:disable-next Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+          def aggregate_module(dispatcher, domain, aggregate)
+            fqn = "#{domain}::#{aggregate.hecks_name}"
+            mod = Module.new
+
+            aggregate.attributes.each do |attribute|
+              next unless RESERVED.include?(attribute.name.to_sym)
+
+              warn "[hecks] #{aggregate.hecks_name}##{attribute.name} shadows a built-in — no reader defined"
+            end
+
+            # `!` marks a creating command (Ruby's mutate-and-may-refuse convention).
+            # Without it, a query sharing the same business name (e.g. Account's
+            # "Open") would collide with the creating command's own bare name.
+            aggregate.commands.select(&:creates?).each do |command|
+              mod.define_singleton_method("#{Naming.snake(command.hecks_name)}!") do |**args|
+                Handle.new(dispatcher: dispatcher, domain: domain, aggregate: aggregate,
+                           instance: dispatcher.dispatch("#{fqn}.#{command.hecks_name}", with: args).instance)
+              end
+            end
+
+            # A query is a bare module method (no `!`): it just reads and returns
+            # the same raw row array `dispatcher.query` itself answers.
+            aggregate.queries.each do |query|
+              mod.define_singleton_method(Naming.snake(query.hecks_name)) do |**args|
+                dispatcher.query("#{fqn}.#{query.hecks_name}", **args)
+              end
+            end
+
+            mod.define_singleton_method(:fqn)        { fqn }
+            mod.define_singleton_method(:ir)         { aggregate }
+
+            # Every construct emits its own IR, so an aggregate is a legitimate
+            # `project` target too. A chapter-scoped target refuses here via
+            # `Projector.admits!` rather than answering a confidently empty result.
+            mod.define_singleton_method(:project) do |target, out: nil, **options|
+              key      = Projector.key_for(target)
+              artifact = Projector.call(key, bluebook: aggregate, options: options)
+              return artifact unless out
+
+              Projector.write(artifact, out, as: Projector.emits_for(key))
+            end
+            mod.define_singleton_method(:repository) { dispatcher.registry.repository(domain, aggregate) }
+            mod.define_singleton_method(:commands) do
+              aggregate.commands.map { |c| "#{Naming.snake(c.hecks_name)}!" }.sort
+            end
+            mod.define_singleton_method(:queries) { aggregate.queries.map { |q| Naming.snake(q.hecks_name) }.sort }
+            # This chapter's own `:docs` projection, narrowed to this aggregate.
+            mod.define_singleton_method(:docs) do |**options|
+              Projector.call(:docs, bluebook: dispatcher.registry.bluebook(domain),
+                                    options:  options.merge(aggregate: aggregate.hecks_name))
+            end
+            # Same narrowing as `:docs`, aimed at `:narrate`.
+            mod.define_singleton_method(:narrate) do |**options|
+              Projector.call(:narrate, bluebook: dispatcher.registry.bluebook(domain),
+                                       options:  options.merge(aggregate: aggregate.hecks_name))
+            end
+            mod.define_singleton_method(:count)      { dispatcher.registry.repository(domain, aggregate).count }
+            mod.define_singleton_method(:events)     { dispatcher.events.select { |event| event.aggregate == fqn } }
+
+            mod.define_singleton_method(:find) do |id|
+              found = dispatcher.registry.repository(domain, aggregate).find(id)
+              found && Handle.new(dispatcher: dispatcher, domain: domain, aggregate: aggregate, instance: found)
+            end
+
+            mod.define_singleton_method(:all) do |**opts|
+              dispatcher.registry.repository(domain, aggregate).all(**opts).map do |instance|
+                Handle.new(dispatcher: dispatcher, domain: domain, aggregate: aggregate, instance: instance)
+              end
+            end
+
+            # Re-resolves via `Hecks.current_registry` rather than the closed-over
+            # `aggregate`: this module can be stale from an earlier boot, and its own
+            # `aggregate` would silently port a discarded one instead of the live one.
+            mod.define_singleton_method(:port) do |name, &block|
+              current = Hecks.current_registry&.bluebook(domain)&.aggregate(aggregate.hecks_name) or
+                raise Bluebook::DSL::Malformed, "#{fqn}.port(#{name.inspect}) called outside a boot"
+
+              built = Bluebook::DSL::ConstShim.with(->(const) { const }) do
+                Bluebook::DSL::DomainPortBuilder.build(name, owner: current.hecks_name, &block)
+              end
+
+              # A `verb`-shaped port is a plain `Port`, the same struct `Hecks.port` registers —
+              # it belongs to no aggregate IR the way an operations-shaped `DomainPort` does, so
+              # it takes the registry's `add_port` directly. Mirrors `DSL::BindingProxy#port`,
+              # which handles the identical shape on a domain's first in-process boot (before
+              # this facade constant exists); this method is what a repeat boot reaches instead.
+              if built.is_a?(Bluebook::Port)
+                Hecks.current_registry.add_port(built)
+                return self
+              end
+
+              built.operations.each do |operation|
+                operation.attributes.select(&:reference?).each { |attribute| attribute.type.declared_in = current }
+              end
+              current.add_port(built)
+              self
+            end
+
+            # `BindingProxy#ask_via` for a repeat boot, when this module stands where the proxy is.
+            mod.define_singleton_method(:ask_via) do |name, port:|
+              chapter = Hecks.current_registry&.bluebook(domain)
+              Bluebook::AskResolution.pick!(chapter, aggregate.hecks_name, name, port)
+              self
+            end
+
+            mod.define_singleton_method(:method_missing) do |verb, *args, **kwargs, &block|
+              # A bare call starts a Privacy marking chain (see
+              # `BindingProxy#method_missing`), reached here when the module is already
+              # installed (a second in-process boot) rather than at parse time.
+              return Bluebook::DSL::AttributePath.new(fqn, [verb.to_s]) if args.empty? && kwargs.empty? && !block
+
+              collector = Bluebook::DSL::HecksagonBuilder.collector
+              world     = Bluebook::DSL::WorldBuilder.current
+              # Inside a `.world` block the same qualified spelling records a world setting.
+              return world.record_binding(verb, args, kwargs, block) if world && !collector
+              return super(verb, *args, **kwargs, &block) unless collector
+
+              collector << Bluebook::Bind.new(
+                aggregate: fqn,
+                verb:      verb.to_s,
+                adapter:   args.first.to_s,
+                role:      kwargs[:role]&.to_s
+              )
+              block&.call
+              self
+            end
+
+            mod.define_singleton_method(:respond_to_missing?) do |name, include_private = false|
+              !Bluebook::DSL::HecksagonBuilder.collector.nil? || !Bluebook::DSL::WorldBuilder.current.nil? ||
+                super(name, include_private)
+            end
+
+            # Uses `aggregate.hecks_name`, not the qualified `fqn`: qualifying it here
+            # would make `Account::Debit`'s meaning depend on whether a stale module
+            # from an earlier boot happens to be sitting on this process.
+            mod.define_singleton_method(:const_missing) do |name|
+              resolver = Bluebook::DSL::ConstShim.resolver
+              return resolver.call("#{aggregate.hecks_name}::#{name}") if resolver
+
+              super(name)
+            end
+
+            mod
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/adapters/driving/ruby/chapter.rb

@@ -0,0 +1,91 @@
+require_relative "../../../bluebook/dsl/binding_proxy"
+require_relative "../../../bluebook/dsl/const_shim"
+require_relative "../../../bluebook/dsl/hecksagon_builder"
+
+module Hecks
+  module Adapters
+    module Driving
+      module Ruby
+        # One chapter's module: vision and aggregate list on the singleton, one
+        # aggregate module per declared head, and a `const_missing` hook for undeclared names.
+        module Chapter
+          # Builds the anonymous module that stands for one booted chapter: `vision`,
+          # `aggregates`, `docs`, `narrate` and `project` as singleton methods, plus one
+          # nested constant per aggregate holding that aggregate module.
+          #
+          # @param dispatcher [Runtime::Dispatcher, Runtime::RemoteDispatcher] the booted
+          #   dispatcher each aggregate module closes over
+          # @param bluebook [Bluebook::Chapter] the chapter to project into a module
+          # @return [Module] a fresh, unnamed module; `Ruby.install` gives it its
+          #   top-level name
+          # @raise [NameError] if an aggregate's name is not a valid constant name
+          def chapter_module(dispatcher, bluebook)
+            chapter = Module.new
+            define_readers(chapter, bluebook)
+            define_projections(chapter, bluebook)
+
+            bluebook.aggregates.each do |aggregate|
+              chapter.const_set(aggregate.hecks_name, aggregate_module(dispatcher, bluebook.name, aggregate))
+            end
+
+            define_const_missing(chapter, bluebook)
+            chapter
+          end
+
+          private
+
+          # The chapter's vision and its aggregate names.
+          def define_readers(chapter, bluebook)
+            chapter.define_singleton_method(:vision)     { bluebook.vision }
+            chapter.define_singleton_method(:aggregates) { bluebook.aggregates.map(&:name).sort }
+          end
+
+          # The chapter's documents and projections, each projected from its IR on every call so
+          # none can go stale.
+          def define_projections(chapter, bluebook)
+            chapter.define_singleton_method(:docs) do |**options|
+              Projector.call(:docs, bluebook: bluebook, options: options)
+            end
+
+            # The chapter read back in english, via `Projector::NarrateProjector`.
+            chapter.define_singleton_method(:narrate) do |**options|
+              Projector.call(:narrate, bluebook: bluebook, options: options)
+            end
+
+            define_project(chapter, bluebook)
+          end
+
+          # Projects the chapter's IR through a target; `out:` writes the artifact and
+          # the remaining options go to the projector (`audience:` for OIDC).
+          #
+          #   Pizzas.project(Projections::OIDC)
+          #   Pizzas.project(Projections::Shape, out: "shape.json")
+          def define_project(chapter, bluebook)
+            chapter.define_singleton_method(:project) do |target, out: nil, **options|
+              key      = Projector.key_for(target)
+              artifact = Projector.call(key, bluebook: bluebook, options: options)
+              return artifact unless out
+
+              Projector.write(artifact, out, as: Projector.emits_for(key))
+            end
+          end
+
+          # Inside a hecksagon a name is a declaration: with a collector open it becomes
+          # a `BindingProxy`. Otherwise a scoped reference from a bluebook mid-declaration
+          # goes to the `ConstShim` resolver, so it resolves whether or not a facade exists.
+          def define_const_missing(chapter, bluebook)
+            chapter.define_singleton_method(:const_missing) do |name|
+              collector = Bluebook::DSL::HecksagonBuilder.collector
+              return Bluebook::DSL::BindingProxy.new("#{bluebook.name}::#{name}", collector) if collector
+
+              resolver = Bluebook::DSL::ConstShim.resolver
+              return resolver.call("#{bluebook.name}::#{name}") if resolver
+
+              super(name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hecks/adapters/driving/ruby.rb

@@ -0,0 +1,83 @@
+require_relative "../../chapters"
+require_relative "ruby/chapter"
+require_relative "ruby/aggregate_module"
+
+module Hecks
+  module Adapters
+    module Driving
+      # The Ruby adapter without classes: anonymous per-boot modules whose singleton methods
+      # dispatch by FQN, installed by `Loader.bind_runtime` and replaced whole on the next boot.
+      #
+      # `persisted_by("Heki")` in a `.hecksagon` file lands on the module's `method_missing`,
+      # which records a `Bind` into the open `HecksagonBuilder.collector`.
+      module Ruby
+        # Names that would shadow the machinery a Handle runs on; a field with one gets no reader.
+        RESERVED = %i[id state events reload inspect to_h hash class].freeze
+
+        extend Chapter
+        extend AggregateModule
+
+        module_function
+
+        # Installs one top-level module per booted chapter, and one per aggregate, each
+        # closing over `dispatcher`, so `Pizzas::Pizza` and the bare `Pizza` both open the
+        # module of the boot that ran last.
+        #
+        # A gem chapter a hecksagon `attaches` installs nothing (`Query`, `Port` stay free).
+        # An aggregate sharing its chapter's name gets no second constant. A name that user
+        # code or the stdlib already owns is left alone with a warning (see `Namespace.install`).
+        #
+        # @param dispatcher [Runtime::Dispatcher, Runtime::RemoteDispatcher] the booted
+        #   dispatcher every installed module dispatches and queries through
+        # @return [Runtime::Dispatcher, Runtime::RemoteDispatcher] the same `dispatcher`
+        # @raise [NameError] if a chapter or aggregate name is not a valid constant name
+        def install(dispatcher)
+          Admission.admit!(dispatcher.registry, "Ruby")
+          dispatcher.registry.bluebooks.each_value do |bluebook|
+            install_chapter(dispatcher, bluebook) unless attached_chapter?(dispatcher.registry, bluebook)
+          end
+          dispatcher
+        end
+
+        # Installs one chapter's module, and the top-level shortcut of each of its aggregates.
+        def install_chapter(dispatcher, bluebook)
+          chapter = chapter_module(dispatcher, bluebook)
+          Namespace.install(*placement(bluebook), chapter)
+          # A namespaced chapter keeps its aggregates inside its namespace: top-level
+          # shortcuts would bring back the collisions the namespace exists to avoid.
+          return if bluebook.namespace
+
+          bluebook.aggregates.each do |aggregate|
+            next if aggregate.hecks_name == bluebook.name
+
+            Namespace.install(Object, aggregate.hecks_name, chapter.const_get(aggregate.hecks_name, false))
+          end
+        end
+
+        # Whether `bluebook` is a gem chapter that a hecksagon attached rather than a domain's own.
+        #
+        # @param registry [Runtime::Registry] the booted registry
+        # @param bluebook [Bluebook::Chapter] the chapter under test
+        # @return [Boolean]
+        def attached_chapter?(registry, bluebook)
+          registry.bounded?(bluebook.name) && Hecks::Chapters.index.key?(bluebook.name)
+        end
+
+        # Where a chapter's module installs: `Object::<name>`, or the constant path its
+        # `namespace` names, creating any missing parent modules along the way.
+        #
+        # @param bluebook [Bluebook::Chapter] the chapter being installed
+        # @return [Array(Module, String)] the parent module and the constant name within it
+        def placement(bluebook)
+          return [Object, bluebook.name] unless bluebook.namespace
+
+          *parents, leaf = bluebook.namespace.split("::")
+          parent = parents.reduce(Object) do |outer, name|
+            outer.const_defined?(name, false) ? outer.const_get(name, false) : outer.const_set(name, Module.new)
+          end
+          [parent, leaf]
+        end
+      end
+    end
+  end
+end