ecoportal-api-graphql 1.3.10 → 1.3.11

data/lib/ecoportal/api/graphql/builder/template_builder.rb

@@ -0,0 +1,174 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Builder
+        # Build-from-scratch emitter for a template/workflow: turns a DECLARATIVE spec
+        # (stages -> sections -> fields -> options / config / gauge-stops) into an ordered batch of
+        # built `WorkflowCommand` hashes, ready for `Builder::Template#create(commands:)` /
+        # `#update(model, commands:)` (which wrap `executeWorkflowCommands`).
+        #
+        # This is the gem-level, reusable BUILD emitter (previously a one-off in eco-helpers samples).
+        # It shares ONE emission layer with the DIFF-DEPLOY pipeline: both produce an ordered
+        # `WorkflowCommand` batch, and both use the SAME `placeholderId` id-threading primitive that
+        # `Diff::CommandSynthesizer` uses — a newly-created node is addressed by a client-chosen
+        # `placeholderId`, and every later command in the same batch that references it substitutes
+        # that placeholder (the server has not assigned real ids yet). Here every node is brand new,
+        # so the whole batch is threaded through placeholders.
+        #
+        # SPEC SHAPE (all keys optional unless noted; only VALID command inputs are emitted):
+        #
+        #   {
+        #     stages: [
+        #       { name: 'Report', ordering: 0, sections: [        # addStage(name, ordering)
+        #         { layout: 'ONE_COLUMN', fields: [               # addSection(layout) + addStageSection
+        #           { field_type: 'PlainText', label: 'Description', column: 0,
+        #             description: 'ID:token' },   # addField (+ editFieldConfiguration for description)
+        #           { field_type: 'Select', label: 'Severity',
+        #             options: [ { label: 'Low', weight: 0 }, ... ],                # addSelectFieldOption
+        #             config: { select: { multiple: false } } },                   # editFieldConfiguration(byType:)
+        #           { field_type: 'Gauge', label: 'Risk',
+        #             stops: [ { threshold: 0, color: '#0f0' }, ... ],              # addGaugeFieldStop
+        #             config: { gauge: { max: 100.0 } } }
+        #         ] }
+        #       ] }
+        #     ]
+        #   }
+        #
+        # ORDER — addStage -> addSection -> addStageSection -> addField -> (addSelectFieldOption |
+        # addGaugeFieldStop | editFieldConfiguration). This is the dependency-safe order the workflow
+        # command bus expects; placeholderId resolution makes the intra-batch references valid.
+        #
+        # SAFETY — only keys present in each command input's VALID_KEYS are emitted (the input classes
+        # slice + compact). A spec key with no corresponding command input is dropped, not fabricated.
+        # `field_type` shape and per-type config (`byType`) are NOT invented: config is passed through
+        # under its byType sub-hash exactly as given (the caller supplies confirmed byType keys), and
+        # is emitted only for a field that carries one.
+        class TemplateBuilder
+          # @param spec [Hash] the declarative template spec (see class doc). String or symbol keys.
+          def initialize(spec)
+            @spec         = symbolize(spec || {})
+            @commands     = []
+            @counter      = 0
+            @built        = false
+          end
+
+          # Ordered Array of built command hashes ({ commandKey => input }), placeholder-threaded.
+          def commands
+            return @commands if @built
+
+            @built = true
+            build_all
+          end
+
+          # Ready to hand to `Builder::Template#create(commands: builder.to_commands)`.
+          alias_method :to_commands, :commands
+
+          def to_h
+            { commands: commands }
+          end
+
+          private
+
+          def build_all
+            Array(@spec[:stages]).each_with_index { |stage, idx| emit_stage(stage, idx) }
+            @commands
+          end
+
+          def emit_stage(stage, index)
+            stage_ph = placeholder(:stg)
+            add(:addStage, name: stage[:name], ordering: stage.fetch(:ordering, index), placeholderId: stage_ph)
+            Array(stage[:sections]).each { |section| emit_section(section, stage_ph) }
+          end
+
+          def emit_section(section, stage_ph)
+            section_ph = placeholder(:sec)
+            add(:addSection, layout: section[:layout], placeholderId: section_ph)
+            # Attach the freshly-created section to its (freshly-created) stage.
+            add(:addStageSection, stageId: stage_ph, sectionId: section_ph)
+            emit_section_heading(section, section_ph)
+            Array(section[:fields]).each { |field| emit_field(field, stage_ph, section_ph) }
+          end
+
+          # A section's heading is not an addSection input; set it via editSectionHeader after create.
+          def emit_section_heading(section, section_ph)
+            heading = section[:heading]
+            return if heading.nil?
+
+            add(:editSectionHeader, sectionId: section_ph, header: heading)
+          end
+
+          def emit_field(field, stage_ph, section_ph)
+            field_ph = placeholder(:fld)
+            add(:addField,
+                fieldType:     field[:field_type] || field[:fieldType],
+                label:         field[:label],
+                stageId:       stage_ph,
+                sectionId:     section_ph,
+                column:        field[:column],
+                placeholderId: field_ph)
+            emit_description(field, field_ph)
+            emit_options(field, field_ph)
+            emit_stops(field, field_ph)
+            emit_config(field, field_ph)
+          end
+
+          # A field's `description` is NOT an addField input (the schema's WorkflowAddFieldInput has
+          # no `description` key — VERIFIED against the 20260605 dump). It is a top-level key of
+          # editFieldConfiguration, so we persist it with a follow-up editFieldConfiguration
+          # addressed to the freshly-created field placeholder. Emitted only when supplied. This is
+          # the seam the CSV/hidden-field identity token rides on. NOTE: `required` has no schema
+          # input key at all, so it is intentionally NOT emitted (a spec `required:` is ignored).
+          def emit_description(field, field_ph)
+            description = field[:description]
+            return if description.nil?
+
+            add(:editFieldConfiguration, data_field_id: field_ph, description: description)
+          end
+
+          def emit_options(field, field_ph)
+            Array(field[:options]).each do |opt|
+              add(:addSelectFieldOption, data_field_id: field_ph, label: opt[:label], weight: opt[:weight])
+            end
+          end
+
+          def emit_stops(field, field_ph)
+            Array(field[:stops]).each do |stop|
+              add(:addGaugeFieldStop, data_field_id: field_ph, threshold: stop[:threshold], color: stop[:color])
+            end
+          end
+
+          # Per-type field configuration passed through under its byType sub-hash exactly as supplied
+          # (e.g. { select: { multiple: true } }, { gauge: { max: 100.0 } }). Emitted only when
+          # present; keys are validated/sliced by the EditFieldConfiguration input, never fabricated.
+          def emit_config(field, field_ph)
+            config = field[:config]
+            return if config.nil? || config.empty?
+
+            add(:editFieldConfiguration, data_field_id: field_ph, byType: symbolize(config))
+          end
+
+          # Build one command and append it. Reuses the SAME builder the diff synthesizer uses, so
+          # BUILD and DIFF-DEPLOY emit through one layer.
+          def add(command_key, **kwargs)
+            @commands << Ecoportal::API::GraphQL::Input::WorkflowCommand.build(command_key, **kwargs)
+          end
+
+          # A deterministic client-chosen placeholderId — the id-threading primitive shared with the
+          # diff synthesizer. Prefix marks the node kind for readability of the emitted batch.
+          def placeholder(prefix)
+            @counter += 1
+            "ph_#{prefix}_#{@counter}"
+          end
+
+          def symbolize(value)
+            case value
+            when Hash  then value.each_with_object({}) { |(k, v), h| h[k.to_sym] = symbolize(v) }
+            when Array then value.map { |e| symbolize(e) }
+            else value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/builder.rb

@@ -1,16 +1,17 @@
-module Ecoportal
-  module API
-    class GraphQL
-      module Builder
-      end
-    end
-  end
-end
-
-require_relative 'builder/location_structure'
-require_relative 'builder/action'
-require_relative 'builder/contractor_entity'
-require_relative 'builder/register'
-require_relative 'builder/page'
-require_relative 'builder/kickstand'
-require_relative 'builder/template'
+module Ecoportal
+  module API
+    class GraphQL
+      module Builder
+      end
+    end
+  end
+end
+
+require_relative 'builder/location_structure'
+require_relative 'builder/action'
+require_relative 'builder/contractor_entity'
+require_relative 'builder/register'
+require_relative 'builder/page'
+require_relative 'builder/kickstand'
+require_relative 'builder/template'
+require_relative 'builder/template_builder'

data/lib/ecoportal/api/graphql/diff/change.rb

@@ -0,0 +1,59 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Diff
+        # One structural change between two snapshots of the same page/template.
+        #
+        # Deliberately command-ready: op + kind + id + before/after is enough for a later pass to
+        # synthesise the matching WorkflowCommand (editStage / addField / removeField /
+        # editFieldConfiguration / addSelectFieldOption / …) — the "portable commit".
+        #
+        # op:   :added | :removed | :changed | :moved
+        # kind: :stage | :section | :field | :option | :field_config | :gauge_stop
+        #
+        # parent_id: id of the owning entity when the change is nested and the child id alone is
+        # not enough to address a command. Set for :option changes (the parent data field id) so a
+        # synthesiser can emit add/edit/removeSelectFieldOption without re-deriving it; also for
+        # :field_config (the data field id) and :gauge_stop (the gauge field id).
+        #
+        # by_type: for :field_config changes, the `byType` sub-hash key (e.g. :gauge, :select, :date)
+        # under which the typed editFieldConfiguration property is nested. nil for other kinds.
+        #
+        # owner_id: the id of the GRANDPARENT node, when a create needs a second structural back-ref
+        # that parent_id alone cannot carry. Set for an ADDED :field (parent_id = its section id,
+        # owner_id = its stage id) because addField requires BOTH sectionId and stageId (both
+        # NON_NULL in the schema). nil for every other kind/op.
+        Change = Struct.new(:op, :kind, :id, :label, :path, :attribute, :before, :after, :parent_id,
+                            :by_type, :owner_id, keyword_init: true) do
+          def to_h
+            {
+              op: op, kind: kind, id: id, label: label, path: path,
+              attribute: attribute, before: before, after: after, parent_id: parent_id,
+              by_type: by_type, owner_id: owner_id
+            }.compact
+          end
+
+          # One-line human description for a changelog / ticket comment.
+          def description
+            case op
+            when :added   then "+ #{kind} '#{label}' added#{at_path}"
+            when :removed then "- #{kind} '#{label}' removed#{at_path}"
+            when :changed then "~ #{kind} '#{label}' #{attribute}: #{fmt(before)} -> #{fmt(after)}#{at_path}"
+            when :moved   then "> #{kind} '#{label}' moved: #{fmt(before)} -> #{fmt(after)}"
+            end
+          end
+
+          private
+
+          def at_path
+            path && !path.empty? ? "  (#{path})" : ''
+          end
+
+          def fmt(value)
+            value.nil? ? 'nil' : value.inspect
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/diff/command_synthesizer.rb

@@ -0,0 +1,329 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Diff
+        # Turns a set of `Diff::Change` objects (from `VersionDiff`) into an ordered batch of built
+        # `WorkflowCommand` hashes — the replayable "commit".
+        #
+        #   changes  = VersionDiff.new(v1, v2).changes
+        #   synth    = CommandSynthesizer.new(changes)
+        #   synth.commands     # => [{ editFieldConfiguration: {...} }, { removeField: {...} }, ...]
+        #   synth.unsupported  # => [Change, ...]  (change kinds/ops with no matching command)
+        #
+        # SCOPE — self-version diff by default. The ids carried by each Change are REAL server ids of
+        # the SAME object across two of its own versions, so they can be replayed as-is. For a
+        # cross-object diff (UAT<->PROD, page<->template) every id in the emitted commands must first
+        # be translated through a pairing map before replay.
+        #
+        # RESOLVER — some edits address a TARGET node by an id the Change does not carry (a field
+        # move needs the destination *section id*; a section move needs the destination *stage id*).
+        # `VersionDiff` records those targets by their human key (section heading, stage name) because
+        # that is all a structural diff knows. Pass a `resolver` that maps
+        # `resolve(kind, key) => id` (e.g. the pairing engine's ledger, or a lookup built from the
+        # target doc) and those moves become supported. WITHOUT a resolver they stay UNSUPPORTED —
+        # the synthesiser never guesses a target id.
+        #
+        # ORDERING — structure before children, and within a kind: removes, then adds, then moves,
+        # then edits. Structural creates (stages, sections, fields) precede the option-level edits
+        # that depend on them, so a straight left-to-right replay stays valid.
+        #
+        # SAFETY — a change with no faithful command is NEVER guessed. It is collected into
+        # `unsupported` for the caller to inspect. In particular a field *type* change has no edit
+        # command in the schema (there is no editFieldType), so it is reported as unsupported rather
+        # than silently rebuilt (a rebuild would drop the field's data and history).
+        class CommandSynthesizer
+          # Emit order: structure first (stages -> sections -> fields), then options; and within a
+          # kind, removes -> adds -> moves -> edits, so a straight left-to-right replay stays valid.
+          KIND_ORDER = { stage: 0, section: 1, field: 2, field_config: 3, gauge_stop: 4, option: 5 }.freeze
+          OP_ORDER   = { removed: 0, added: 1, moved: 2, changed: 3 }.freeze
+
+          # @param changes  [Array<Change>]
+          # @param resolver [#resolve, nil] maps (kind, human-key) -> target id for move commands.
+          #   Any object answering `resolve(kind, key)` (returning an id or nil). When nil, moves
+          #   that need a target id are reported as unsupported.
+          # @param thread_placeholders [Boolean] when true, structural creates (addStage/addSection/
+          #   addField) emit a client-chosen `placeholderId`, and any later command in the SAME batch
+          #   that references a node created here substitutes that placeholder for the (target-invalid)
+          #   source id. This keeps add-then-reference sequences self-consistent within one
+          #   executeWorkflowCommands call. Off by default (self-version replay uses the real ids).
+          def initialize(changes, resolver: nil, thread_placeholders: false)
+            @changes             = Array(changes)
+            @resolver            = resolver
+            @thread_placeholders = thread_placeholders
+            @unsupported         = []
+          end
+
+          # Ordered Array of built command hashes (each `{ commandKey => {..input..} }`).
+          def commands
+            @commands ||= build_all
+          end
+
+          # Changes that could not be mapped to a command. Populated as a side effect of `commands`.
+          def unsupported
+            commands
+            @unsupported
+          end
+
+          private
+
+          # Group by (kind, op) and emit in a dependency-safe order:
+          # stages -> sections -> fields -> options, and remove -> add -> move -> change within each.
+          def build_all
+            build_placeholder_map
+            ordered = @changes.sort_by { |c| [KIND_ORDER.fetch(c.kind, 99), OP_ORDER.fetch(c.op, 99)] }
+            # command_for may return a single built hash, an Array of them (a move that emits
+            # remove+add), or nil (unsupported). Normalise each to a list, flatten, drop nils.
+            ordered.flat_map { |change| wrap(command_for(change)) }
+          end
+
+          # When threading is on, assign a deterministic placeholderId to every ADDED structural
+          # node (stage/section/field), keyed by its source id. A later command in this batch that
+          # references such an id is rewritten to the placeholder (the source id is not valid on the
+          # target). Threading OFF -> empty map -> `ref`/`placeholder_for` are no-ops.
+          def build_placeholder_map
+            @placeholders = {}
+            return unless @thread_placeholders
+
+            prefixes = { stage: 'stg', section: 'sec', field: 'fld' }
+            @changes.select { |c| c.op == :added && prefixes.key?(c.kind) }.each_with_index do |change, i|
+              next if change.id.nil?
+
+              @placeholders[change.id] = "ph_#{prefixes[change.kind]}_#{i}"
+            end
+          end
+
+          # The placeholder token for a node created in THIS batch, or nil if it was not.
+          def placeholder_for(id)
+            @placeholders[id]
+          end
+
+          # Reference an id the way a sibling command must: the batch-local placeholder if the node
+          # is being created here, otherwise the id as-is (a pre-existing target node).
+          def ref(id)
+            placeholder_for(id) || id
+          end
+
+          def command_for(change)
+            case change.kind
+            when :stage        then stage_command(change)
+            when :section      then section_command(change)
+            when :field        then field_command(change)
+            when :field_config then field_config_command(change)
+            when :gauge_stop   then gauge_stop_command(change)
+            when :option       then option_command(change)
+            else unsupported!(change)
+            end
+          end
+
+          # --- stage ---------------------------------------------------------
+
+          def stage_command(change)
+            case change.op
+            when :added   then build(:addStage, name: change.label, placeholderId: placeholder_for(change.id))
+            when :removed then build(:removeStage, stageId: change.id)
+            when :moved   then build(:moveStage, stageId: change.id, ordering: change.after)
+            when :changed
+              return build(:editStage, stageId: change.id, name: change.after) if change.attribute == 'name'
+
+              unsupported!(change)
+            else unsupported!(change)
+            end
+          end
+
+          # --- section -------------------------------------------------------
+
+          def section_command(change)
+            case change.op
+            when :added   then add_section(change)
+            when :removed then build(:removeSection, sectionId: change.id)
+            when :moved   then section_move(change)
+            when :changed
+              return build(:editSectionHeader, sectionId: change.id, header: change.after) if change.attribute == 'heading'
+
+              unsupported!(change)
+            else unsupported!(change)
+            end
+          end
+
+          # An added section is created with addSection (layout/placeholder), then WIRED to its
+          # parent stage with a follow-up addStageSection — addSection itself has no stage-id key in
+          # the schema, the stage<->section link is a separate command. The stage back-ref threads
+          # through `ref`: the parent stage's placeholder when it is created in this same batch, else
+          # its real id. When the parent stage id is unknown (a hand-assembled Change with no
+          # parent_id), only addSection is emitted — the historical behaviour, unchanged.
+          def add_section(change)
+            cmds = [build(:addSection, placeholderId: placeholder_for(change.id))]
+            cmds << build(:addStageSection, stageId: ref(change.parent_id), sectionId: ref(change.id)) unless change.parent_id.nil?
+            cmds
+          end
+
+          # A section 'move' is a stage reassignment: detach from the old stage, attach to the new.
+          # Both need a stage id; VersionDiff records only the stage NAME (before/after), so a
+          # resolver is required to turn those names into ids. Emitted as two commands so the replay
+          # is faithful (remove then add). Without a resolver -> unsupported (never guess a stage id).
+          def section_move(change)
+            return unsupported!(change) if change.attribute != 'stage'
+
+            from_id = resolve(:stage, change.before)
+            to_id   = resolve(:stage, change.after)
+            return unsupported!(change) if to_id.nil?
+
+            cmds = []
+            cmds << build(:removeStageSection, stageId: from_id, sectionId: change.id) if from_id
+            cmds << build(:addStageSection, stageId: to_id, sectionId: change.id)
+            cmds
+          end
+
+          # --- field ---------------------------------------------------------
+
+          def field_command(change)
+            case change.op
+            when :added   then add_field(change)
+            when :removed then build(:removeField, id: change.id)
+            when :moved   then field_move(change)
+            when :changed then field_edit(change)
+            else unsupported!(change)
+            end
+          end
+
+          # An added field carries its structural back-refs: sectionId (parent_id) and stageId
+          # (owner_id) — both NON_NULL on the schema's addField input. Each threads through `ref`:
+          # the parent's placeholder when the parent stage/section is created in this same batch,
+          # else its real id. When a back-ref id is unknown (a hand-assembled Change without
+          # parent_id/owner_id) that key is simply omitted (AddField.build compacts nils) — the
+          # historical behaviour, unchanged.
+          def add_field(change)
+            build(:addField,
+                  label:         change.label,
+                  sectionId:     (ref(change.parent_id) unless change.parent_id.nil?),
+                  stageId:       (ref(change.owner_id) unless change.owner_id.nil?),
+                  placeholderId: placeholder_for(change.id))
+          end
+
+          def field_edit(change)
+            return build(:editFieldConfiguration, data_field_id: change.id, label: change.after) if change.attribute == 'label'
+
+            # Field TYPE change: no editFieldType command exists in the schema. Do not synthesise a
+            # remove+add (it would destroy the field's data) — report it for manual handling.
+            unsupported!(change)
+          end
+
+          # A field 'move' is a section reassignment. moveField needs the destination SECTION id;
+          # VersionDiff records only the section HEADING (before/after). A resolver turns the target
+          # heading into a section id. Without one -> unsupported (never guess a section id).
+          def field_move(change)
+            return unsupported!(change) if change.attribute != 'section'
+
+            section_id = resolve(:section, change.after)
+            return unsupported!(change) if section_id.nil?
+
+            build(:moveField, id: change.id, sectionId: section_id)
+          end
+
+          # --- typed field configuration (byType) ----------------------------
+
+          # A per-type field-configuration change maps to editFieldConfiguration with the changed
+          # property nested under its `byType` sub-hash (e.g. { gauge: { max: 5.0 } }). VersionDiff
+          # stamps `by_type` (the sub-hash key) and `parent_id` (the data field id). Without a
+          # by_type key we cannot address the typed input -> unsupported (never guessed).
+          def field_config_command(change)
+            return unsupported!(change) unless change.op == :changed
+
+            field_id = change.parent_id || change.id
+            by_type  = change.by_type
+            return unsupported!(change) if field_id.nil? || by_type.nil? || change.attribute.nil?
+
+            body = { by_type => { change.attribute.to_sym => change.after } }
+            build(:editFieldConfiguration, data_field_id: ref(field_id), byType: body)
+          end
+
+          # --- gauge stops ---------------------------------------------------
+
+          # Gauge stops address the parent gauge field id (parent_id). Add needs threshold+color
+          # (carried on change.after); edit/remove need the stop id (change.id).
+          def gauge_stop_command(change)
+            field_id = change.parent_id
+            return unsupported!(change) if field_id.nil?
+
+            field_ref = ref(field_id)
+            case change.op
+            when :added   then add_gauge_stop(change, field_ref)
+            when :removed then build(:removeGaugeFieldStop, data_field_id: field_ref, stop_id: change.id)
+            when :changed then edit_gauge_stop(change, field_ref)
+            else unsupported!(change)
+            end
+          end
+
+          def add_gauge_stop(change, field_id)
+            spec = change.after
+            return unsupported!(change) unless spec.is_a?(Hash)
+
+            build(:addGaugeFieldStop, data_field_id: field_id, threshold: spec[:threshold], color: spec[:color])
+          end
+
+          def edit_gauge_stop(change, field_id)
+            case change.attribute
+            when 'threshold' then build(:editGaugeFieldStop, data_field_id: field_id, stop_id: change.id, threshold: change.after)
+            when 'color'     then build(:editGaugeFieldStop, data_field_id: field_id, stop_id: change.id, color: change.after)
+            else unsupported!(change)
+            end
+          end
+
+          # --- option --------------------------------------------------------
+
+          def option_command(change)
+            field_id = change.parent_id
+            return unsupported!(change) if field_id.nil?
+
+            field_ref = ref(field_id)
+            case change.op
+            when :added   then build(:addSelectFieldOption, data_field_id: field_ref, label: change.label)
+            when :removed then build(:removeSelectFieldOption, data_field_id: field_ref, option_id: change.id)
+            when :changed then edit_option(change, field_ref)
+            else unsupported!(change)
+            end
+          end
+
+          def edit_option(change, field_id)
+            case change.attribute
+            when 'label'  then build(:editSelectFieldOption, data_field_id: field_id, option_id: change.id, label: change.after)
+            when 'weight' then build(:editSelectFieldOption, data_field_id: field_id, option_id: change.id, weight: change.after)
+            else unsupported!(change)
+            end
+          end
+
+          # --- helpers -------------------------------------------------------
+
+          def build(command_key, **kwargs)
+            Ecoportal::API::GraphQL::Input::WorkflowCommand.build(command_key, **kwargs)
+          end
+
+          # Ask the resolver for the target id of `key` (a heading / stage name). Returns nil when
+          # there is no resolver or it cannot resolve — callers treat nil as "unsupported".
+          def resolve(kind, key)
+            return nil if key.nil? || @resolver.nil?
+
+            @resolver.resolve(kind, key)
+          end
+
+          # Normalise a command_for result (nil | Hash | Array<Hash>) into a flat list of hashes.
+          # A built command is a Hash, so we must NOT use Kernel#Array (it would splat a Hash into
+          # key/value pairs).
+          def wrap(result)
+            case result
+            when nil   then []
+            when Array then result.compact
+            else [result]
+            end
+          end
+
+          # Record an unmappable change and return nil (filtered out of the command list).
+          def unsupported!(change)
+            @unsupported << change
+            nil
+          end
+        end
+      end
+    end
+  end
+end