hecks 3.4.2 → 3.6.0

data/lib/hecks/cli/interview_session/catalog.rb

@@ -0,0 +1,76 @@
+module Hecks
+  module CLI
+    class InterviewSession
+      NOTICE = "Your answers are sent to a model through your own `claude` login. " \
+               "Run with --no-ai to leave it out.".freeze
+
+      FALLBACK_QUESTIONS = [
+        "What is the main thing this business keeps track of?",
+        "What happens to it, from the beginning to the end?",
+        "What must never happen?",
+        "Is there anything else I should know?"
+      ].freeze
+
+      TASK = "You interview a subject matter expert, through the developer who sits beside them, about the " \
+             "business domain called %<subject>s, so the developer can model it. Ask one plain-language " \
+             "question at a time about what the business keeps track of, what each thing has, what happens to " \
+             "it and who does it, how it moves from one state to the next, and what must never happen. Use the " \
+             "expert's own words. Do not assume what kind of business it is, or an " \
+             "industry, from the name of the domain: learn it from what the expert says. When you interpret " \
+             "an answer, propose findings only with the verbs listed under `verbs`, using the argument " \
+             "names given there, and nothing else.".freeze
+
+      VERBS = {
+        "SME::Interview.ProposeThing"      => {
+          "meaning"   => "a thing the business keeps track of, and the field that identifies one of it",
+          "arguments" => %w[name identifier]
+        },
+        "SME::Interview.ProposeAction"     => {
+          "meaning"   => "something that happens to a thing, and the event it announces, in the past tense; " \
+                         "creates is true for the action that brings the thing into being; takes lists, comma " \
+                         "separated, the fields it needs to be told; by says who does it",
+          "arguments" => %w[name thing event creates takes by]
+        },
+        "SME::Interview.ProposeField"      => {
+          "meaning"   => "something a thing has; values lists, comma separated, what it may be when the " \
+                         "expert gave a closed set, and is left out for free text",
+          "arguments" => %w[thing name values]
+        },
+        "SME::Interview.ProposeTransition" => {
+          "meaning"   => "the state an action leaves a thing in, and the state it had to be in before; the " \
+                         "action that creates the thing has no from",
+          "arguments" => %w[thing action to from]
+        },
+        "SME::Interview.ProposeRule"       => {
+          "meaning"   => "a rule the expert stated, in their own words",
+          "arguments" => %w[statement]
+        }
+      }.freeze
+
+      # What each finding verb needs, the fields it may leave out, and the SME commands that
+      # carry it out and decide it.
+      KINDS = {
+        "SME::Interview.ProposeThing"      => { kind: "thing", fields: %w[name identifier], optional: [],
+                                           propose: :propose_thing!, entity: "ThingFinding",
+                                           accept: "AcceptThing", reject: "RejectThing" },
+        "SME::Interview.ProposeAction"     => { kind: "action", fields: %w[name thing event creates takes by],
+                                            optional: %w[creates takes by], propose: :propose_action!,
+                                            entity: "ActionFinding", accept: "AcceptAction", reject: "RejectAction" },
+        "SME::Interview.ProposeRule"       => { kind: "rule", fields: %w[statement], optional: [],
+                                          propose: :propose_rule!, entity: "RuleFinding",
+                                          accept: "AcceptRule", reject: "RejectRule" },
+        "SME::Interview.ProposeField"      => { kind: "field", fields: %w[thing name values], optional: %w[values],
+                                          propose: :propose_field!, entity: "FieldFinding",
+                                          accept: "AcceptField", reject: "RejectField" },
+        "SME::Interview.ProposeTransition" => { kind: "transition", fields: %w[thing action to from],
+                                                optional: %w[from], propose: :propose_transition!,
+                                                entity: "TransitionFinding", accept: "AcceptTransition",
+                                                reject: "RejectTransition" }
+      }.freeze
+
+      TRUE_WORDS = %w[true yes y 1].freeze
+
+      Result = Struct.new(:status, :interview, keyword_init: true)
+    end
+  end
+end

data/lib/hecks/cli/interview_session/manual_findings.rb

@@ -0,0 +1,48 @@
+module Hecks
+  module CLI
+    class InterviewSession
+      # The plain prompt: findings typed by the developer, accepted as they are entered.
+      module ManualFindings
+        private
+
+        def manual_findings
+          loop do
+            kind = ask("Add a finding from that answer? thing, action, rule, field or transition (enter to skip): ")
+            kind = kind.to_s.strip.downcase
+            break if kind.empty?
+
+            typed = typed_finding(kind) or next say("  I only know thing, action, rule, field and transition.")
+            config = KINDS["SME::Interview.Propose#{kind.capitalize}"]
+            number = propose(config, typed) or next
+            decide(config, number, true)
+          end
+        end
+
+        def typed_finding(kind)
+          case kind
+          when "thing" then named("Name" => "name", "Identified by" => "identifier")
+          when "action" then typed_action
+          when "rule" then named("The rule, in the expert's words" => "statement")
+          when "field" then named({ "On which thing" => "thing", "Name" => "name",
+                                    "Values it may take, comma separated (enter for any)" => "values" }, %w[values])
+          when "transition" then named({ "On which thing" => "thing", "Caused by which action" => "action",
+                                         "Leaves it in the state" => "to",
+                                         "From the state (enter if it starts there)" => "from" }, %w[from])
+          end
+        end
+
+        def typed_action
+          fields = named("Name" => "name", "On which thing" => "thing", "It announces (event)" => "event") or return nil
+          fields.merge("creates" => TRUE_WORDS.include?(ask("  Does it create the thing? [y/N] ").to_s.strip.downcase))
+        end
+
+        def named(prompts, optional = [])
+          fields = prompts.to_h { |label, key| [key, ask("  #{label}: ").to_s.strip] }
+          return nil unless fields.all? { |key, value| optional.include?(key) || !value.empty? }
+
+          fields.reject { |key, value| optional.include?(key) && value.empty? }
+        end
+      end
+    end
+  end
+end

data/lib/hecks/cli/interview_session/proposals.rb

@@ -0,0 +1,90 @@
+module Hecks
+  module CLI
+    class InterviewSession
+      # Putting an agent's proposed finding to the developer: reading its fields, proposing it to
+      # the SME chapter, describing it, and recording the decision.
+      module Proposals
+        private
+
+        def review(proposal)
+          config = KINDS[proposal.verb]
+          return say("Ignored a proposal for #{proposal.verb}: not a finding I know.") unless config
+
+          fields = fields_of(proposal, config)
+          missing = missing_fields(config, fields)
+          return say("Ignored a #{config[:kind]} proposal with no #{missing.join(", ")}.") unless missing.empty?
+
+          put_to_developer(proposal, config, fields)
+        end
+
+        def missing_fields(config, fields)
+          config[:fields].reject { |f| config[:optional].include?(f) || fields[f].to_s.strip != "" }
+        end
+
+        def put_to_developer(proposal, config, fields)
+          number = propose(config, fields) or return
+          say("  Proposed #{describe(config, fields)}")
+          say("  because: #{proposal.rationale}")
+          decide(config, number, accept?("  Accept? [Y/n] "))
+        end
+
+        def fields_of(proposal, config)
+          fields = argument_fields(proposal, config)
+          fields.reject { |key, value| key != "creates" && config[:optional].include?(key) && value.to_s.strip.empty? }
+        end
+
+        def argument_fields(proposal, config)
+          rows = proposal.arguments.to_h { |row| [row[:name].to_s, row[:value]] }
+          fields = rows.slice(*config[:fields])
+          fields["creates"] = TRUE_WORDS.include?(fields["creates"].to_s.downcase) if fields.key?("creates")
+          fields
+        end
+
+        def propose(config, fields)
+          number = (@number += 1)
+          args = fields.transform_keys(&:to_sym).merge(number: number, source: current.exchanges.size)
+          current.public_send(config[:propose], **args)
+          number
+        rescue StandardError => e
+          say("  Could not keep that finding: #{reason(e)}")
+          nil
+        end
+
+        def decide(config, number, accepted)
+          verb = accepted ? config[:accept] : config[:reject]
+          @runtime.dispatch_flat("SME::Interview.#{config[:entity]}.#{verb}",
+                                 reference: { value: @reference }, number: { value: number })
+          say(accepted ? "  Accepted." : "  Rejected.")
+        rescue StandardError => e
+          say("  Could not record the decision: #{reason(e)}")
+        end
+
+        def describe(config, fields)
+          case config[:kind]
+          when "thing" then "thing: #{fields["name"]}, identified by #{fields["identifier"]}"
+          when "action" then describe_action(fields)
+          when "field" then "field: #{fields["name"]} of #{fields["thing"]}#{", one of #{fields["values"]}" if fields["values"]}"
+          when "transition" then describe_transition(fields)
+          else "rule: #{fields["statement"]}"
+          end
+        end
+
+        def describe_action(fields)
+          "action: #{fields["name"]} on #{fields["thing"]}, announcing #{fields["event"]}" \
+            "#{", creating it" if fields["creates"]}#{action_extras(fields)}"
+        end
+
+        def describe_transition(fields)
+          "transition: #{fields["action"]} leaves #{fields["thing"]} #{fields["to"]}" \
+            "#{", from #{fields["from"]}" if fields["from"]}"
+        end
+
+        def action_extras(fields)
+          "#{", taking #{fields["takes"]}" if fields["takes"]}#{", by #{fields["by"]}" if fields["by"]}"
+        end
+
+        def reason(error) = error.message.sub(/\A[A-Z]\w* refused\s+[—-]\s+/, "").strip
+      end
+    end
+  end
+end

data/lib/hecks/cli/interview_session.rb

@@ -1,4 +1,8 @@
 require_relative "interview_draft"
+require_relative "interview_session/catalog"
+require_relative "interview_session/proposals"
+require_relative "interview_session/manual_findings"
+require_relative "interview_session/agent_state"
 
 module Hecks
   module CLI
@@ -12,76 +16,9 @@ module Hecks
     # With no agent (`--no-ai`), or for a turn the agent could not answer, a plain prompt stands in:
     # a fixed question, and findings typed by the developer.
     class InterviewSession
-      NOTICE = "Your answers are sent to a model through your own `claude` login. " \
-               "Run with --no-ai to leave it out.".freeze
-
-      FALLBACK_QUESTIONS = [
-        "What is the main thing this business keeps track of?",
-        "What happens to it, from the beginning to the end?",
-        "What must never happen?",
-        "Is there anything else I should know?"
-      ].freeze
-
-      TASK = "You interview a subject matter expert, through the developer who sits beside them, about the " \
-             "business domain called %<subject>s, so the developer can model it. Ask one plain-language " \
-             "question at a time about what the business keeps track of, what each thing has, what happens to " \
-             "it and who does it, how it moves from one state to the next, and what must never happen. Use the " \
-             "expert's own words. Do not assume what kind of business it is, or an " \
-             "industry, from the name of the domain: learn it from what the expert says. When you interpret " \
-             "an answer, propose findings only with the verbs listed under `verbs`, using the argument " \
-             "names given there, and nothing else.".freeze
-
-      VERBS = {
-        "SME::Interview.ProposeThing"      => {
-          "meaning"   => "a thing the business keeps track of, and the field that identifies one of it",
-          "arguments" => %w[name identifier]
-        },
-        "SME::Interview.ProposeAction"     => {
-          "meaning"   => "something that happens to a thing, and the event it announces, in the past tense; " \
-                         "creates is true for the action that brings the thing into being; takes lists, comma " \
-                         "separated, the fields it needs to be told; by says who does it",
-          "arguments" => %w[name thing event creates takes by]
-        },
-        "SME::Interview.ProposeField"      => {
-          "meaning"   => "something a thing has; values lists, comma separated, what it may be when the " \
-                         "expert gave a closed set, and is left out for free text",
-          "arguments" => %w[thing name values]
-        },
-        "SME::Interview.ProposeTransition" => {
-          "meaning"   => "the state an action leaves a thing in, and the state it had to be in before; the " \
-                         "action that creates the thing has no from",
-          "arguments" => %w[thing action to from]
-        },
-        "SME::Interview.ProposeRule"       => {
-          "meaning"   => "a rule the expert stated, in their own words",
-          "arguments" => %w[statement]
-        }
-      }.freeze
-
-      # What each finding verb needs, the fields it may leave out, and the SME commands that
-      # carry it out and decide it.
-      KINDS = {
-        "SME::Interview.ProposeThing"      => { kind: "thing", fields: %w[name identifier], optional: [],
-                                           propose: :propose_thing!, entity: "ThingFinding",
-                                           accept: "AcceptThing", reject: "RejectThing" },
-        "SME::Interview.ProposeAction"     => { kind: "action", fields: %w[name thing event creates takes by],
-                                            optional: %w[creates takes by], propose: :propose_action!,
-                                            entity: "ActionFinding", accept: "AcceptAction", reject: "RejectAction" },
-        "SME::Interview.ProposeRule"       => { kind: "rule", fields: %w[statement], optional: [],
-                                          propose: :propose_rule!, entity: "RuleFinding",
-                                          accept: "AcceptRule", reject: "RejectRule" },
-        "SME::Interview.ProposeField"      => { kind: "field", fields: %w[thing name values], optional: %w[values],
-                                          propose: :propose_field!, entity: "FieldFinding",
-                                          accept: "AcceptField", reject: "RejectField" },
-        "SME::Interview.ProposeTransition" => { kind: "transition", fields: %w[thing action to from],
-                                                optional: %w[from], propose: :propose_transition!,
-                                                entity: "TransitionFinding", accept: "AcceptTransition",
-                                                reject: "RejectTransition" }
-      }.freeze
-
-      TRUE_WORDS = %w[true yes y 1].freeze
-
-      Result = Struct.new(:status, :interview, keyword_init: true)
+      include Proposals
+      include ManualFindings
+      include AgentState
 
       # @param runtime [Runtime] the booted SME chapter
       # @param agent [#question, #proposals, nil] the interviewer; nil runs the plain prompts
@@ -90,7 +27,7 @@ module Hecks
       # @param reference [String] the interview's reference, such as `INT-1`
       # @param subject [String] the domain being discovered, as its bluebook will spell it
       # @param expert [String] who is being interviewed
-      def initialize(runtime:, agent:, input:, output:, reference:, subject:, expert:)
+      def initialize(runtime:, agent:, input:, output:, reference:, subject:, expert:) # rubocop:disable Metrics/ParameterLists -- one keyword per collaborator and setting
         @runtime = runtime
         @agent = agent
         @input = input
@@ -171,102 +108,6 @@ module Hecks
         nil
       end
 
-      def review(proposal)
-        config = KINDS[proposal.verb]
-        return say("Ignored a proposal for #{proposal.verb}: not a finding I know.") unless config
-
-        fields = fields_of(proposal, config)
-        missing = config[:fields].reject { |f| config[:optional].include?(f) || fields[f].to_s.strip != "" }
-        return say("Ignored a #{config[:kind]} proposal with no #{missing.join(', ')}.") unless missing.empty?
-
-        number = propose(config, fields) or return
-        say("  Proposed #{describe(config, fields)}")
-        say("  because: #{proposal.rationale}")
-        decide(config, number, accept?("  Accept? [Y/n] "))
-      end
-
-      def fields_of(proposal, config)
-        rows = proposal.arguments.to_h { |row| [row[:name].to_s, row[:value]] }
-        fields = rows.slice(*config[:fields])
-        fields["creates"] = TRUE_WORDS.include?(fields["creates"].to_s.downcase) if fields.key?("creates")
-        fields.reject { |key, value| key != "creates" && config[:optional].include?(key) && value.to_s.strip.empty? }
-      end
-
-      def propose(config, fields)
-        number = (@number += 1)
-        args = fields.transform_keys(&:to_sym).merge(number: number, source: current.exchanges.size)
-        current.public_send(config[:propose], **args)
-        number
-      rescue StandardError => e
-        say("  Could not keep that finding: #{reason(e)}")
-        nil
-      end
-
-      def decide(config, number, accepted)
-        verb = accepted ? config[:accept] : config[:reject]
-        @runtime.dispatch_flat("SME::Interview.#{config[:entity]}.#{verb}",
-                               reference: { value: @reference }, number: { value: number })
-        say(accepted ? "  Accepted." : "  Rejected.")
-      rescue StandardError => e
-        say("  Could not record the decision: #{reason(e)}")
-      end
-
-      def describe(config, fields)
-        case config[:kind]
-        when "thing" then "thing: #{fields['name']}, identified by #{fields['identifier']}"
-        when "action" then "action: #{fields['name']} on #{fields['thing']}, announcing #{fields['event']}" \
-                           "#{', creating it' if fields['creates']}#{action_extras(fields)}"
-        when "field" then "field: #{fields['name']} of #{fields['thing']}#{", one of #{fields['values']}" if fields['values']}"
-        when "transition" then "transition: #{fields['action']} leaves #{fields['thing']} #{fields['to']}" \
-                               "#{", from #{fields['from']}" if fields['from']}"
-        else "rule: #{fields['statement']}"
-        end
-      end
-
-      # @api private
-      def action_extras(fields)
-        "#{", taking #{fields['takes']}" if fields['takes']}#{", by #{fields['by']}" if fields['by']}"
-      end
-
-      # The plain prompt: findings typed by the developer, accepted as they are entered.
-      def manual_findings
-        loop do
-          kind = ask("Add a finding from that answer? thing, action, rule, field or transition (enter to skip): ")
-          kind = kind.to_s.strip.downcase
-          break if kind.empty?
-
-          typed = typed_finding(kind) or next say("  I only know thing, action, rule, field and transition.")
-          config = KINDS["SME::Interview.Propose#{kind.capitalize}"]
-          number = propose(config, typed) or next
-          decide(config, number, true)
-        end
-      end
-
-      def typed_finding(kind)
-        case kind
-        when "thing" then named("Name" => "name", "Identified by" => "identifier")
-        when "action" then typed_action
-        when "rule" then named("The rule, in the expert's words" => "statement")
-        when "field" then named({ "On which thing" => "thing", "Name" => "name",
-                                  "Values it may take, comma separated (enter for any)" => "values" }, %w[values])
-        when "transition" then named({ "On which thing" => "thing", "Caused by which action" => "action",
-                                       "Leaves it in the state" => "to",
-                                       "From the state (enter if it starts there)" => "from" }, %w[from])
-        end
-      end
-
-      def typed_action
-        fields = named("Name" => "name", "On which thing" => "thing", "It announces (event)" => "event") or return nil
-        fields.merge("creates" => TRUE_WORDS.include?(ask("  Does it create the thing? [y/N] ").to_s.strip.downcase))
-      end
-
-      def named(prompts, optional = [])
-        fields = prompts.to_h { |label, key| [key, ask("  #{label}: ").to_s.strip] }
-        return nil unless fields.all? { |key, value| optional.include?(key) || !value.empty? }
-
-        fields.reject { |key, value| optional.include?(key) && value.empty? }
-      end
-
       def suggest_enough
         return if @suggested || !enough?
 
@@ -301,44 +142,6 @@ module Hecks
         !%w[n no].include?(ask(label).to_s.strip.downcase)
       end
 
-      def state
-        plain = InterviewDraft.from_record(current)
-        { task: format(TASK, subject: @subject), subject: @subject, expert: @expert, verbs: VERBS,
-          exchanges: plain[:exchanges].each_with_index.map { |e, i| e.slice(:question, :answer).merge(number: i + 1) },
-          accepted: accepted_state(plain), gaps: gaps(plain) }
-      end
-
-      def accepted_state(plain)
-        { things:      InterviewDraft.accepted(plain, :things).map { |f| f.slice(:name, :identifier) },
-          actions:     InterviewDraft.accepted(plain, :actions).map { |f| f.slice(:name, :thing, :event, :creates, :takes, :by) },
-          fields:      InterviewDraft.accepted(plain, :fields).map { |f| f.slice(:thing, :name, :values) },
-          transitions: InterviewDraft.accepted(plain, :transitions).map { |f| f.slice(:thing, :action, :to, :from) },
-          rules:       InterviewDraft.accepted(plain, :rules).map { |f| f.slice(:statement) } }
-      end
-
-      # What the interview has not yet pinned down, in words a model can act on.
-      def gaps(plain)
-        things = InterviewDraft.accepted(plain, :things).map { |t| t[:name].to_s }
-        actions = InterviewDraft.accepted(plain, :actions)
-        gaps = things.reject { |t| actions.any? { |a| a[:thing] == t } }.map { |t| "nothing is yet said to happen to #{t}" }
-        gaps += things.reject { |t| actions.any? { |a| a[:thing] == t && a[:creates] } }.map { |t| "nothing yet creates #{t}" }
-        unplaced = actions.reject { |a| things.include?(a[:thing].to_s) }
-        gaps + unplaced.map { |a| "#{a[:name]} names #{a[:thing]}, not yet a thing" } + shape_gaps(plain, things, actions)
-      end
-
-      # What a thing is not yet said to have, and how it moves from one state to the next.
-      def shape_gaps(plain, things, actions)
-        fields = InterviewDraft.accepted(plain, :fields)
-        steps = InterviewDraft.accepted(plain, :transitions)
-        bare = things.reject { |t| fields.any? { |f| f[:thing] == t } }
-        gaps = bare.map { |t| "nothing is yet said #{t} has, beyond its identifier" }
-        changing = things.select { |t| actions.count { |a| a[:thing] == t && !a[:creates] } > 1 }
-        unmoved = changing.reject { |t| steps.any? { |s| s[:thing] == t } }
-        gaps + unmoved.map { |t| "nothing yet says how #{t} moves from one state to the next" }
-      end
-
-      def reason(error) = error.message.sub(/\A[A-Z]\w* refused\s+[—-]\s+/, "").strip
-
       def ask(label)
         @output.print(label)
         @input.gets&.chomp

data/lib/hecks/cli/interview_shape.rb

@@ -108,19 +108,26 @@ module Hecks
       # @param rest [Array<Hash>] its other accepted actions
       # @return [Array<String>] the lines, or none when no step and start state can be placed
       def lifecycle(steps, creating, rest)
-        births = creating.map { |action| InterviewDraft.word(action[:name]) }
-        has = ->(names, step) { names.include?(InterviewDraft.word(step[:action])) }
-        starts, moves = steps.partition { |step| has.call(births, step) }
-        heres = rest.map { |action| InterviewDraft.word(action[:name]) }
-        placed, loose = moves.partition { |step| has.call(heres, step) }
+        starts, moves = steps.partition { |step| names_action?(creating, step) }
+        placed, loose = moves.partition { |step| names_action?(rest, step) }
         placed = merged(placed)
         start = beginning(starts, placed)
         return [] if start.empty? || placed.empty?
 
+        lifecycle_block(start, placed, loose)
+      end
+
+      # @api private
+      def lifecycle_block(start, placed, loose)
         ["", "    lifecycle :status, default: #{start.inspect} do", *placed.map { |step| transition_line(step) },
          "    end", *loose.map { |step| loose_line(step) }]
       end
 
+      # @api private
+      def names_action?(actions, step)
+        actions.map { |action| InterviewDraft.word(action[:name]) }.include?(InterviewDraft.word(step[:action]))
+      end
+
       # One action for each name: an expert who refines an answer gets the same action accepted more
       # than once, and a command can be declared only once. The first one's event and place in the
       # interview stay; what each takes is joined, who does it is joined, and it creates if any did.
@@ -187,7 +194,7 @@ module Hecks
         states = step[:from].to_s.split(/\s*,\s*/).map { |text| state_word(text) }.reject(&:empty?)
         return "" if states.empty?
 
-        states.one? ? ", from: #{states.first.inspect}" : ", from: %w[#{states.join(' ')}]"
+        states.one? ? ", from: #{states.first.inspect}" : ", from: %w[#{states.join(" ")}]"
       end
 
       # A state as a lowercase word: `Not Yet Triaged` is `not_yet_triaged`.

data/lib/hecks/cli/ir.rb

@@ -24,21 +24,18 @@ module Hecks
       # @raise [SystemExit] when no domain is named and there is no default
       def call(argv, program:, default_domain: nil)
         argv = argv.dup
-        if argv.delete("--meta")
-          require_relative "../bluebook/meta_validator"
-          puts Projector::Exporter.json(Bluebook::MetaValidator.grammar_registry)
-          return
-        end
+        return print_meta if argv.delete("--meta")
 
         translations_only = argv.delete("--translations")
         domain = argv.shift || default_domain or abort "usage: #{program} <domain> [--translations] | #{program} --meta"
-        runtime = Hecks.boot(domain)
+        registry = Hecks.boot(domain).registry
+        puts(translations_only ? Projector::Exporter.translations_json(registry) : Projector::Exporter.json(registry))
+      end
 
-        if translations_only
-          puts Projector::Exporter.translations_json(runtime.registry)
-        else
-          puts Projector::Exporter.json(runtime.registry)
-        end
+      # @api private
+      def print_meta
+        require_relative "../bluebook/meta_validator"
+        puts Projector::Exporter.json(Bluebook::MetaValidator.grammar_registry)
       end
     end
   end