ecoportal-api-graphql 2.2.1 → 3.0.0

data/lib/ecoportal/api/graphql/model/template/command_synthesis.rb

@@ -0,0 +1,262 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # Diff engine: walks the in-memory tree and emits the ordered `[CommandInput]` batch
+          # `#as_commands` returns, plus the phase-scoped subsets `StagedExecutor` sends one at
+          # a time (each subset re-synthesised against the CURRENT tree, so a node resolved by
+          # an earlier phase — `Node#resolve!` — is addressed by its real id, not its stale
+          # placeholder, the next time a phase is built; see `Node#ref`).
+          #
+          # ORDER — stage -> section -> field -> option/config -> force -> helper -> binding,
+          # matching `Diff::CommandSynthesizer::KIND_ORDER`'s own dependency-safe order plus the
+          # two groups it does not cover (force, helper/binding — no existing gem emitter
+          # before this class). Within a stage: structural section commands first
+          # (add/remove/header), THEN a `reorderSection` TRAILER for every section with a
+          # pending move (see `Section#move`'s own doc for why last) — this mirrors the
+          # EPT-2078 "preserve reorderSection trailer protection" rule.
+          #
+          # SAFETY — never guesses. A field's `field_type` has no setter (see `Field`'s own
+          # doc), so a type "change" cannot even be expressed here; every other write goes
+          # through the same `WorkflowCommand.build` layer `Builder::TemplateBuilder` and
+          # `Diff::CommandSynthesizer` already use, so a missing required key (`value` on a
+          # new option, etc.) raises there — never invented here.
+          class CommandSynthesis
+            def initialize(instance)
+              @instance = instance
+            end
+
+            # The full ordered batch — the public `#as_commands` contract.
+            def commands
+              stage_phase + section_phase + field_phase + force_phase + helper_binding_phase
+            end
+
+            # --- phase-scoped subsets, used by StagedExecutor -------------------
+
+            def stage_phase
+              instance.stages.select(&:new?).flat_map { |stage| stage_commands(stage) }
+            end
+
+            def section_phase
+              instance.stages.flat_map { |stage| section_commands_for_stage(stage) }
+            end
+
+            def field_phase
+              instance.stages.flat_map { |stage| stage.sections.flat_map { |section| field_commands_for_section(section) } }
+            end
+
+            def force_phase
+              instance.stages.flat_map { |stage|
+                stage.forces.reject(&:new?).flat_map { |f| force_edit_commands(f) } +
+                  stage.forces.select(&:new?).flat_map { |f| force_add_commands(f) }
+              }
+            end
+
+            def helper_binding_phase
+              instance.stages.flat_map { |stage| stage.forces.flat_map { |force| helper_and_binding_commands(force) } }
+            end
+
+            private
+
+            attr_reader :instance
+
+            def build(key, **kwargs)
+              Ecoportal::API::GraphQL::Input::WorkflowCommand.build(key, **kwargs)
+            end
+
+            # --- stage -----------------------------------------------------------
+
+            def stage_commands(stage)
+              [build(:addStage, name: stage.name, ordering: stage.ordering, placeholderId: stage.placeholder)]
+            end
+
+            # --- section -----------------------------------------------------------
+
+            def section_commands_for_stage(stage)
+              structural = stage.sections.flat_map { |section| section_structural_commands(stage, section) }
+              trailer    = stage.sections.reject(&:removed?).filter_map { |section| reorder_command(stage, section) }
+              structural + trailer
+            end
+
+            def section_structural_commands(stage, section)
+              return removed_section_commands(section) if section.removed?
+              return new_section_commands(stage, section) if section.new?
+
+              edited_section_commands(section)
+            end
+
+            def removed_section_commands(section)
+              [build(:removeSection, sectionId: section.id)]
+            end
+
+            def new_section_commands(stage, section)
+              cmds = [build(:addSection, placeholderId: section.placeholder, layout: section.layout)]
+              cmds << build(:addStageSection, stageId: stage.ref, sectionId: section.ref)
+              cmds << header_command(section)
+              cmds.compact
+            end
+
+            def edited_section_commands(section)
+              return [] unless section.dirty?
+
+              [header_command(section)].compact
+            end
+
+            def header_command(section)
+              changed = section.new? ? section_header_kwargs(section) : section.changed_attributes
+              return nil if changed.empty? || changed.values.all?(&:nil?)
+
+              build(:editSectionHeader, sectionId: section.ref,
+                                        header: changed[:heading], leftHeader: changed[:left_heading],
+                                        rightHeader: changed[:right_heading])
+            end
+
+            def section_header_kwargs(section)
+              { heading: section.heading, left_heading: section.left_heading, right_heading: section.right_heading }
+            end
+
+            def reorder_command(stage, section)
+              move = section.pending_move
+              return nil if move.nil?
+
+              build(:reorderSection, sectionId: section.ref, stageId: stage.ref,
+                                     anchorId: move[:anchor].ref, anchorPosition: move[:position])
+            end
+
+            # --- field / option ----------------------------------------------------
+
+            def field_commands_for_section(section)
+              section.fields.flat_map { |field| field_commands(section, field) }
+            end
+
+            def field_commands(section, field)
+              return [build(:removeField, id: field.id)] if field.removed?
+
+              cmds = field.new? ? new_field_commands(section, field) : edited_field_commands(field)
+              cmds + option_commands(field)
+            end
+
+            def new_field_commands(section, field)
+              cmds = [build(:addField, placeholderId: field.placeholder, fieldType: field.field_type,
+                                       label: field.label, stageId: field.stage.ref, sectionId: section.ref,
+                                       column: field.column)]
+              cfg = field_config_kwargs(field)
+              cmds << build(:editFieldConfiguration, data_field_id: field.ref, **stage_id_kwarg(field), **cfg) unless cfg.empty?
+              cmds
+            end
+
+            def edited_field_commands(field)
+              cfg = wire_field_config_keys(field.changed_attributes)
+              return [] if cfg.empty?
+
+              [build(:editFieldConfiguration, data_field_id: field.ref, **stage_id_kwarg(field), **cfg)]
+            end
+
+            # `editFieldConfiguration.stageId` disambiguates WHICH stage's copy of the field is
+            # being edited -- REQUIRED on a phased page (`edit_field_configuration.rb`'s own
+            # schema-authority comment), a key the schema does not need (and this class never
+            # sends, not even as an explicit `null`) on a non-phased page. `Field#stage` is
+            # ALWAYS present either way (`Read`'s workflow-first read populates it for BOTH
+            # page kinds) -- `#phased` on the owning `Instance`, not "does the field know its
+            # stage", is the real gate the schema cares about (mirrors the DSL dialect's own
+            # `Bindings.write_field_property`/the downstream `FieldWriter.configure`, both of which only
+            # thread a stage id through when one is actually known/needed).
+            def stage_id_kwarg(field)
+              field.template.phased? ? { stageId: field.stage.ref } : {}
+            end
+
+            # Only the non-nil subset of a NEW field's attributes — `editFieldConfiguration`
+            # after a fresh `addField` should not send a literal `nil` for something the
+            # caller never set. `label` is dropped: it already went through `addField`.
+            def field_config_kwargs(field)
+              wire_field_config_keys({ tooltip: field.tooltip, description: field.description,
+                                        required: field.required, hidden: field.hidden }.compact)
+            end
+
+            # `Field#hidden` (this model's read/write attribute name, matching `Read`'s own
+            # `tf` fragment key) maps onto `EditFieldConfiguration`'s real top-level argument
+            # `hideView` (`input/workflow_command/edit_field_configuration.rb`'s own
+            # `BASE_KEYS` — there is no plain `hidden` key on that input) — the one place this
+            # read/write naming split is bridged, so every other layer can stay consistent.
+            def wire_field_config_keys(cfg)
+              return cfg unless cfg.key?(:hidden)
+
+              cfg.merge(hideView: cfg[:hidden]).except(:hidden)
+            end
+
+            def option_commands(field)
+              field.options.flat_map { |opt| option_command(field, opt) }
+            end
+
+            def option_command(field, opt)
+              return [build(:removeSelectFieldOption, data_field_id: field.ref, option_id: opt.id)] if opt.removed?
+
+              if opt.new?
+                # addSelectFieldOption REQUIRES `value` (backend: AddSelectFieldOptionInput,
+                # required: true — see `Diff::CommandSynthesizer#add_option`'s own identical
+                # rule). `WorkflowCommand::AddSelectFieldOption.build` accepts a literal `nil`
+                # without complaint (it is a required KEYWORD, not a required VALUE — Ruby
+                # only enforces the keyword's presence), so this class enforces the missing-
+                # value rule itself rather than letting a `nil` reach the server.
+                if opt.value.nil?
+                  raise ArgumentError,
+                        "CommandSynthesis: cannot build addSelectFieldOption for option " \
+                        "'#{opt.label}' (field #{field.ref}) — value is nil. Set " \
+                        '`option.value = ...` before calling #as_commands/#save!.'
+                end
+
+                return [build(:addSelectFieldOption, data_field_id: field.ref, placeholderId: opt.placeholder,
+                                                      label: opt.label, value: opt.value, weight: opt.weight)]
+              end
+
+              changed = opt.changed_attributes
+              return [] if changed.empty?
+
+              [build(:editSelectFieldOption, data_field_id: field.ref, option_id: opt.id, **changed)]
+            end
+
+            # --- force / helper / binding ------------------------------------------
+
+            def force_add_commands(force)
+              [build(:addForce, placeholderId: force.placeholder, name: force.name,
+                                customScript: force.custom_script, url: force.url, contentB64: force.content_b64)]
+            end
+
+            def force_edit_commands(force)
+              changed = force.changed_attributes
+              return [] if changed.empty?
+
+              [build(:editForce, id: force.id, name: changed[:name], customScript: changed[:custom_script],
+                                 url: changed[:url], contentB64: changed[:content_b64])]
+            end
+
+            def helper_and_binding_commands(force)
+              force.helpers.select(&:new?).map { |h| helper_command(force, h) } +
+                force.bindings.flat_map { |b| binding_command(force, b) }
+            end
+
+            def helper_command(force, helper)
+              build(:addLinkedHelper, placeholderId: helper.placeholder, forceId: force.ref, name: helper.name,
+                                      filePath: helper.file_path, script: helper.script, contentB64: helper.content_b64)
+            end
+
+            def binding_command(force, binding)
+              return [] if binding.removed?
+
+              if binding.new?
+                [build(:addBinding, placeholderId: binding.placeholder, forceId: force.ref, name: binding.name,
+                                    referenceId: binding.reference_id, type: binding.type)]
+              else
+                changed = binding.changed_attributes
+                return [] if changed.empty?
+
+                [build(:editBinding, id: binding.id, name: changed[:name], referenceId: changed[:reference_id])]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/model/template/field.rb

@@ -0,0 +1,68 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # One data field. `field_type` is immutable after creation on purpose: the platform
+          # has no `editFieldType` command (confirmed,
+          # the repo's internal docs section
+          # C.1) — giving this class no setter for it makes a destructive remove+add
+          # structurally unreachable rather than a rule `#as_commands` has to remember to
+          # enforce.
+          class Field
+            include Node
+
+            PLACEHOLDER_PREFIX = 'fld'.freeze
+
+            attr_reader :template, :section, :stage, :field_type, :column, :options
+            attr_accessor :label, :tooltip, :description, :required, :hidden
+
+            def initialize(template:, section:, stage:, field_type:, id: nil, label: nil, column: nil,
+                           tooltip: nil, description: nil, required: nil, hidden: nil, options: [])
+              @template    = template
+              @section     = section
+              @stage       = stage
+              @id          = id
+              @field_type  = field_type
+              @column      = column
+              @label       = label
+              @tooltip     = tooltip
+              @description = description
+              @required    = required
+              @hidden      = hidden
+              @options     = options
+              @snapshot    = snapshot_attrs.freeze
+            end
+
+            # Appends a new (in-memory) option. Only meaningful for a Select-shaped field, but
+            # this class does not enforce `field_type` — the server does, on `addSelectFieldOption`.
+            def add_option(value:, label: nil, weight: nil)
+              opt = Option.new(template: template, field: self, label: label, value: value, weight: weight)
+              options << opt
+              opt
+            end
+
+            def dirty?
+              !removed? && !new? && snapshot_attrs != @snapshot
+            end
+
+            # The subset of `changed_attributes` that maps onto `editFieldConfiguration`'s
+            # top-level keys (label/tooltip/description/required/hidden) — empty when nothing
+            # changed, so callers can `commands << ... unless field_config_changes.empty?`.
+            def changed_attributes
+              return {} if new? || removed?
+
+              snapshot_attrs.each_with_object({}) { |(k, v), h| h[k] = v if v != @snapshot[k] }
+            end
+
+            private
+
+            def snapshot_attrs
+              { label: label, tooltip: tooltip, description: description, required: required, hidden: hidden }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/model/template/force.rb

@@ -0,0 +1,65 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # One force, owned by a Stage (`18_template_editor_save_path.md` section A.1:
+          # `TemplateStageFields.forces`). Editing an existing force is limited to
+          # name/custom_script/url/content_b64 (`editForce`'s own argument list,
+          # `input/workflow_command/edit_force.rb`) — `weight`/`lastSyncedAt` are
+          # server-managed and not exposed as writable attributes here.
+          class Force
+            include Node
+
+            PLACEHOLDER_PREFIX = 'frc'.freeze
+
+            attr_reader :template, :stage, :bindings, :helpers
+            attr_accessor :name, :custom_script, :url, :content_b64
+
+            def initialize(template:, stage:, id: nil, name: nil, custom_script: nil, url: nil, content_b64: nil)
+              @template      = template
+              @stage         = stage
+              @id            = id
+              @name          = name
+              @custom_script = custom_script
+              @url           = url
+              @content_b64   = content_b64 # rubocop:disable Naming/VariableNumber
+              @bindings      = []
+              @helpers       = []
+              @snapshot      = snapshot_attrs.freeze
+            end
+
+            def add_binding(reference_id:, name: nil, type: Binding::BINDING_TYPE)
+              binding = Binding.new(template: template, force: self, name: name, reference_id: reference_id, type: type)
+              bindings << binding
+              binding
+            end
+
+            def add_helper(name: nil, file_path: nil, script: nil, content_b64: nil)
+              helper = Helper.new(template: template, force: self, name: name, file_path: file_path,
+                                  script: script, content_b64: content_b64)
+              helpers << helper
+              helper
+            end
+
+            def dirty?
+              !removed? && !new? && snapshot_attrs != @snapshot
+            end
+
+            def changed_attributes
+              return {} if new? || removed?
+
+              snapshot_attrs.each_with_object({}) { |(k, v), h| h[k] = v if v != @snapshot[k] }
+            end
+
+            private
+
+            def snapshot_attrs
+              { name: name, custom_script: custom_script, url: url, content_b64: content_b64 }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/model/template/helper.rb

@@ -0,0 +1,32 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # A force's linked helper (`addLinkedHelper`). ADD-only in this design — no live
+          # call site or schema citation for `editLinkedHelper`'s read-side shape was available
+          # to this session (see `Read.call`'s header for the read-side field-name caveat), so
+          # editing an existing helper is left unimplemented rather than guessed.
+          class Helper
+            include Node
+
+            PLACEHOLDER_PREFIX = 'hlp'.freeze
+
+            attr_reader :template, :force
+            attr_accessor :name, :file_path, :script, :content_b64
+
+            def initialize(template:, force:, id: nil, name: nil, file_path: nil, script: nil, content_b64: nil)
+              @template    = template
+              @force       = force
+              @id          = id
+              @name        = name
+              @file_path   = file_path
+              @script      = script
+              @content_b64 = content_b64 # rubocop:disable Naming/VariableNumber
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/model/template/instance.rb

@@ -0,0 +1,202 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # The mutable, in-memory template: `Model::Template.load(client, id:)` returns one of
+          # these. Owns the placeholder counters every `Node` mints from (see `Node#placeholder`
+          # — keeping them on the Instance rather than globally means two `Instance`s loaded in
+          # the same process never share a counter, so specs get deterministic `ph_sec_1`-style
+          # ids per fixture without any manual reset).
+          #
+          # THE THREE LINES (see the internal design doc,
+          #  section 2.4):
+          #
+          #   template = Ecoportal::API::GraphQL::Model::Template.load(client, id: page_id)
+          #   template.fields.each { |f| f.label = "#{f.label} (reviewed)" }
+          #   template.save!(client)
+          #
+          # `#save!` defaults to `simulate: true` (see its own doc) — nothing is sent to the
+          # server until the caller explicitly asks for `simulate: false`.
+          class Instance
+            attr_reader :id, :patch_ver, :stages, :phased
+
+            # @param phased [Boolean] true for a `PhasedPage` (the server's own type name),
+            #   false for a `BasicPage`/build-from-nothing. Drives whether field-level EDIT
+            #   commands need a `stageId` disambiguator (see `CommandSynthesis#stage_id_kwarg`)
+            #   -- a `Field` always carries a `#stage` reference either way (workflow-first
+            #   reads populate it for BOTH page kinds, per `Read`'s own header), so `#phased`,
+            #   not "does the field know its stage", is the real gate the schema cares about.
+            def initialize(id:, patch_ver:, stages: [], phased: false)
+              @id        = id
+              @patch_ver = patch_ver
+              @stages    = stages
+              @phased    = phased
+              @counters  = Hash.new(0)
+            end
+
+            alias_method :phased?, :phased
+
+            def next_placeholder(prefix)
+              @counters[prefix] += 1
+              "ph_#{prefix}_#{@counters[prefix]}"
+            end
+
+            class << self
+              # @param client [Ecoportal::API::GraphQL]
+              # @param id [String]
+              def load(client, id:)
+                page = Read.call(client, id)
+                from_doc(page)
+              end
+
+              # Builds an Instance from an already-fetched `page` doc (same shape `Read.call`
+              # returns) — used by both `.load` and `StagedExecutor`'s between-phase re-reads,
+              # so both paths build the SAME tree shape from the SAME doc reader.
+              def from_doc(page)
+                instance = new(id: page['id'], patch_ver: page['patchVer'], phased: page['__typename'] == 'PhasedPage')
+                Read.stages(page).each { |stage_doc| instance.stages << build_stage(instance, stage_doc) }
+                instance
+              end
+
+              private
+
+              def build_stage(instance, stage_doc)
+                stage = Stage.new(template: instance, id: stage_doc['id'], name: stage_doc['name'],
+                                  ordering: stage_doc['ordering'])
+                Array(stage_doc['sections']).each { |sec_doc| stage.sections << build_section(instance, stage, sec_doc) }
+                Array(stage_doc['forces']).each { |force_doc| stage.forces << build_force(instance, stage, force_doc) }
+                stage
+              end
+
+              def build_section(instance, stage, doc)
+                split = doc['__typename'] == 'SplitSection'
+                section = Section.new(template: instance, stage: stage, id: doc['id'],
+                                      kind: (split ? :split : :content), heading: doc['heading'],
+                                      left_heading: doc['leftHeading'], right_heading: doc['rightHeading'])
+                if split
+                  Array(doc['leftDataFields']).each { |f| section.left_fields << build_field(instance, section, stage, f) }
+                  Array(doc['rightDataFields']).each { |f| section.right_fields << build_field(instance, section, stage, f) }
+                else
+                  Array(doc['dataFields']).each { |f| section.left_fields << build_field(instance, section, stage, f) }
+                end
+                section
+              end
+
+              def build_field(instance, section, stage, doc)
+                field = Field.new(template: instance, section: section, stage: stage, id: doc['id'],
+                                  field_type: doc['__typename'], label: doc['label'], tooltip: doc['tooltip'],
+                                  description: doc['description'], required: doc['required'], hidden: doc['hidden'])
+                Array(doc['options']).each do |opt_doc|
+                  field.options << Option.new(template: instance, field: field, id: opt_doc['id'],
+                                              label: opt_doc['name'], value: opt_doc['value'])
+                end
+                field
+              end
+
+              def build_force(instance, stage, doc)
+                force = Force.new(template: instance, stage: stage, id: doc['id'], name: doc['name'],
+                                  custom_script: doc['customScript'], url: doc['url'], content_b64: doc['contentB64'])
+                Array(doc['bindings']).each do |b|
+                  force.bindings << Binding.new(template: instance, force: force, name: b['name'], reference_id: b['referenceId'])
+                end
+                Array(doc['helpers']).each do |h|
+                  force.helpers << Helper.new(template: instance, force: force, id: h['id'], name: h['name'],
+                                              file_path: h['filePath'], script: h['script'], content_b64: h['contentB64'])
+                end
+                force
+              end
+            end
+
+            # Every (non-removed) field across every stage, document order.
+            def fields
+              stages.flat_map(&:fields)
+            end
+
+            def sections
+              stages.flat_map(&:sections)
+            end
+
+            def forces
+              stages.flat_map(&:forces)
+            end
+
+            # The public diff engine — see `CommandSynthesis`'s own doc for ordering/safety.
+            def as_commands
+              CommandSynthesis.new(self).commands
+            end
+
+            def dirty?
+              !as_commands.empty?
+            end
+
+            # @param client [Ecoportal::API::GraphQL, nil] required unless `simulate: true`.
+            # @param simulate [Boolean] default true — returns the staged PLAN (stages, chunks,
+            #   command counts, placeholders) WITHOUT calling the server at all. Pass
+            #   `simulate: false` to actually execute it.
+            # @param chunk_size [Integer]
+            # @return [StagedExecutor::Plan, StagedExecutor::Result]
+            def save!(client = nil, simulate: true, chunk_size: StagedExecutor::DEFAULT_CHUNK_SIZE)
+              executor = StagedExecutor.new(self, client: client, chunk_size: chunk_size)
+              simulate ? executor.plan : executor.execute!
+            end
+
+            # Re-reads the template fresh and reports, per node this Instance currently holds
+            # (and is not flagged removed), whether the live server agrees with THIS model's
+            # own current in-memory state. Call after a `save!(simulate: false)` — compares
+            # against the model's post-save state, not the pre-save snapshot, so a call with
+            # zero pending changes never reports a false "verified" for something it never
+            # actually checked (every tracked node is still compared, `changed or not`).
+            #
+            # @param client [Ecoportal::API::GraphQL]
+            # @return [Hash] { verified: [...], mismatch: [...], missing: [...] } — each entry
+            #   `{ kind:, id:, attribute:, expected:, actual: }`. `missing` covers both "no
+            #   node with this id exists live" and "this node never resolved a real id at all"
+            #   (a save that silently no-oped).
+            def verify(client)
+              live = Instance.load(client, id: id)
+              report = { verified: [], mismatch: [], missing: [] }
+              verify_fields(live, report)
+              verify_options(live, report)
+              verify_sections(live, report)
+              report
+            end
+
+            private
+
+            def verify_fields(live, report)
+              live_by_id = live.fields.to_h { |f| [f.id, f] }
+              fields.reject(&:removed?).each { |field| compare_node(field, live_by_id[field.id], :field, %i[label tooltip description required hidden], report) }
+            end
+
+            def verify_options(live, report)
+              live_by_id = live.fields.flat_map(&:options).to_h { |o| [o.id, o] }
+              fields.reject(&:removed?).flat_map(&:options).reject(&:removed?).each do |opt|
+                compare_node(opt, live_by_id[opt.id], :option, %i[label value weight], report)
+              end
+            end
+
+            def verify_sections(live, report)
+              live_by_id = live.sections.to_h { |s| [s.id, s] }
+              sections.reject(&:removed?).each { |section| compare_node(section, live_by_id[section.id], :section, %i[heading left_heading right_heading], report) }
+            end
+
+            def compare_node(node, live_node, kind, attrs, report)
+              if node.id.nil? || live_node.nil?
+                report[:missing] << { kind: kind, id: node.id, attribute: nil, expected: nil, actual: nil }
+                return
+              end
+
+              attrs.each do |attr|
+                expected = node.public_send(attr)
+                actual   = live_node.public_send(attr)
+                entry    = { kind: kind, id: node.id, attribute: attr, expected: expected, actual: actual }
+                (expected == actual ? report[:verified] : report[:mismatch]) << entry
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end