rigortype 0.3.3 → 0.3.5

data/lib/rigor/effects/discharge.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "label_set"
+
+module Rigor
+  module Effects
+    # `effects.tolerated:` at judgment time — the discharge policy, **per origin** (ADR-103 WD1 / WD14;
+    # normative in `docs/type-specification/effect-labels.md` § Discharge by policy).
+    #
+    # The rule the whole slice turns on: **a bundle is discharged when ANY of its labels is tolerated.**
+    # An origin is one callee or one construct, and its labels are what that one thing does; tolerating
+    # what the origin was *for* frees the transport it came with. `Logger#info` is `io` + `telemetry`, so
+    # `tolerated: [telemetry]` discharges the whole bundle — the project has said "logging is fine", and
+    # the `io` in that bundle is logging. A `File.read` in the same body is a different origin with a
+    # different bundle, and its `io.fs.read` still counts. That is why summaries keep labels per origin at
+    # all ({Summary#bundles}); a flat label set cannot tell the two `io`s apart.
+    #
+    # Discharge is a **judgment**, never a record. The snapshot on disk holds undischarged sets, the
+    # collector attributes undischarged labels, and only the two consumers below subtract:
+    # {EnvelopeCheck} (through {Propagator}'s second lane) and {SnapshotDiff}. `--no-tolerated-effects` is
+    # the audit switch — the same judgment with {NONE} — and is what makes the policy inspectable
+    # (Steins ADR-0084 invariant 3).
+    class Discharge
+      # The identity policy: nothing is tolerated, so nothing is discharged. What
+      # `--no-tolerated-effects` judges with, and what a project that configured no `tolerated:` list
+      # always has.
+      def self.none
+        @none ||= new([])
+      end
+
+      def initialize(tolerated)
+        @tolerated = tolerated.is_a?(LabelSet) ? tolerated : LabelSet.new(Array(tolerated).map(&:to_s))
+        freeze
+      end
+
+      # Whether the policy discharges nothing at all — the fast path every project that wrote no
+      # `tolerated:` list takes, and the reason the second propagation lane costs zero when unconfigured.
+      def inert?
+        @tolerated.empty?
+      end
+
+      # Whether ONE origin's bundle is discharged: some member of it is tolerated (or subsumed by a
+      # tolerated label — `tolerated: [io]` discharges an `io.fs.read` bundle). An empty bundle is
+      # discharged by nothing, and never carries anything to discharge.
+      def discharges?(labels)
+        return false if inert?
+
+        labels.to_a.any? { |label| @tolerated.admits?(label) }
+      end
+
+      # The join of every bundle this policy does NOT discharge — what a judgment reads in place of
+      # {Summary#proven}. A label that arrives through both a discharged and an undischarged origin
+      # survives, because the undischarged origin proves it on its own.
+      def undischarged(bundles)
+        return flatten(bundles) if inert?
+
+        bundles.reduce(LabelSet::EMPTY) do |acc, (_origin, labels)|
+          discharges?(labels) ? acc : acc.join(labels)
+        end
+      end
+
+      private
+
+      def flatten(bundles)
+        bundles.each_value.reduce(LabelSet::EMPTY) { |acc, set| acc.join(set) }
+      end
+    end
+  end
+end

data/lib/rigor/effects/effect_table.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_relative "label_set"
+require_relative "summary"
+
+module Rigor
+  module Effects
+    # The whole-project effect graph after propagation: every method key the run collected, with its
+    # direct summary and its transitive closure (ADR-103 WD12).
+    #
+    # An EffectTable is **not a diagnostic and never enters `rigor check`'s stream**. It hangs off the
+    # runner for the report of this slice and the snapshot of #381 to read, exactly as
+    # [ADR-102](../adr/102-unused-code-reachability-report.md) draws the report-versus-diagnostic line.
+    class EffectTable
+      # One method's row.
+      #
+      # `direct` is the {Summary} the collector produced for this method's own body — what a snapshot
+      # records, because a diff over direct summaries stays attributable to the pull request's own lines.
+      # `proven` / `exhaustive` / `causes` are the transitive readings: this method's own labels joined
+      # with every project method it reaches, and the exhaustiveness bit ANDed along the same edges.
+      #
+      # `undischarged` is the same transitive reading with the origin bundles `effects.tolerated:`
+      # discharges removed at their source (#385; {Discharge}) — what a *judgment* reads, where `proven`
+      # is what the record holds. The two are the same set for a project that tolerates nothing, and
+      # `--no-tolerated-effects` is the switch that makes a judgment read `proven` anyway.
+      #
+      # `declared` is the transitive `≤` lane: it travels the same edges as `proven` (ADR-103 WD1), so a
+      # caller two hops above an attributed gem call reads the claim rather than only the taint it left.
+      # The lanes are kept **raw** here — a declared label a proven one already subsumes is dropped where
+      # output is rendered ({LabelSet#excluding_subsumed_by}), never in the table, because a further join
+      # has to see what was actually declared.
+      class Entry < Data.define(:key, :direct, :proven, :undischarged, :declared, :exhaustive, :causes,
+                                :edges)
+        def initialize(undischarged: nil, declared: nil, **rest)
+          super(undischarged: undischarged || rest.fetch(:proven), declared: declared || LabelSet::EMPTY,
+                **rest)
+        end
+
+        # The declared labels worth printing beside `proven` — the rendering rule, in one place so the
+        # report and the snapshot cannot disagree about it.
+        def rendered_declared
+          declared.excluding_subsumed_by(proven)
+        end
+
+        def exhaustive?
+          exhaustive
+        end
+
+        # Whether the report omits this row by default: exhaustive, proving nothing beyond frame-local
+        # mutation, and claiming nothing the proven lane does not already admit ({Summary#trivial?} for
+        # the reasoning behind the declared half). `--full` lists it anyway.
+        def trivial?
+          exhaustive && proven.subsumed_by?(Summary::TRIVIAL_BOUND) && rendered_declared.empty?
+        end
+      end
+
+      EMPTY_ENTRIES = {}.freeze
+      private_constant :EMPTY_ENTRIES
+
+      def self.empty
+        @empty ||= new(EMPTY_ENTRIES)
+      end
+
+      # @param entries [Hash{String => Entry}]
+      def initialize(entries)
+        @entries = entries.sort_by { |key, _| key }.to_h.freeze
+        freeze
+      end
+
+      def [](key)
+        @entries[key]
+      end
+
+      def keys
+        @entries.keys
+      end
+
+      def each(&)
+        @entries.each_value(&)
+      end
+      include Enumerable
+
+      def size
+        @entries.size
+      end
+
+      def empty?
+        @entries.empty?
+      end
+    end
+  end
+end

data/lib/rigor/effects/entry_points.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative "../configuration_error"
+
+module Rigor
+  module Effects
+    # The named entry-point presets `effects.snapshot.reach:` may adopt (ADR-103 WD14).
+    #
+    # `reach:` entries are of two kinds, told apart syntactically:
+    #
+    # - a **path glob** — anything carrying a glob or path character (`* ? [ ] / .`) — matched against the
+    #   project-relative file a method is defined in, with the `rigor unused --entry-point` semantics
+    #   (`File.fnmatch?` with `File::FNM_PATHNAME`, so `**` is the only way across a directory boundary);
+    # - a **preset name** — a bare `[a-z0-9_-]+` token — resolved here to the globs the preset stands for.
+    #
+    # Presets are named by the plugin that models a framework — rigor-actionpack's controller actions,
+    # rigor-activejob's `perform`, rigor-actionmailer's mailer methods, rigor-actioncable's channels —
+    # through the `effect_entry_points:` manifest field (#387), and registered here through
+    # {.register_all} once the plugin set is loaded. `Configuration` checks only that a `reach:` entry is
+    # SHAPED like a preset name; the existence check runs where the snapshot expands it, which is the
+    # first point at which the registered set is complete.
+    #
+    # Registration is process-global and happens before a snapshot is built, in the parent process — the
+    # same shape the other CLI-time registries take. Nothing here crosses a fork or a Ractor boundary.
+    module EntryPoints
+      # What makes a `reach:` entry a path glob rather than a preset name. Kept deliberately wide: a name
+      # that looks at all like a path is read as one, because a mistyped preset that matched a file would
+      # be the confusing failure.
+      GLOB_CHARACTERS = %r{[*?\[\]/.]}
+
+      # What a preset name may be spelled with, so a malformed name is rejected at registration rather
+      # than becoming an unfindable key.
+      NAME_PATTERN = /\A[a-z0-9][a-z0-9_-]*\z/
+
+      # A plugin's registration is wrong: a malformed preset name, or two plugins claiming one name with
+      # different globs. Nothing the user wrote, so it never reaches them as a configuration error —
+      # {PluginFacts} downgrades it to a warning.
+      class Error < StandardError
+      end
+
+      # The user's `effects.snapshot.reach:` names a preset no active plugin registered — the most common
+      # of these being chapter 03's `reach: [rails]` without `rigor-railties` in `plugins:` (#433). A
+      # {Rigor::ConfigurationError}, not an {Error}, because the offending text is in `.rigor.yml`: it is
+      # the CLI's to render as a `rigor:` line, not a crash.
+      class UnknownPreset < Rigor::ConfigurationError
+      end
+
+      @presets = {}
+
+      class << self
+        # Whether `entry` is a path glob rather than a preset name.
+        def glob?(entry)
+          GLOB_CHARACTERS.match?(entry)
+        end
+
+        # Registers `name` as standing for `globs`. Re-registering the same name with the same globs is a
+        # no-op, so a plugin loaded twice in one process does not raise.
+        def register(name, globs)
+          key = name.to_s
+          raise Error, "not a well-formed entry-point preset name: #{key.inspect}" unless NAME_PATTERN.match?(key)
+
+          patterns = Array(globs).map(&:to_s).uniq.sort.freeze
+          existing = @presets[key]
+          return key if existing == patterns
+          raise Error, "entry-point preset already registered with different globs: #{key.inspect}" if existing
+
+          @presets[key] = patterns
+          key
+        end
+
+        def known?(name)
+          @presets.key?(name.to_s)
+        end
+
+        # Whether `entry` is spelled like a preset name at all — the shape check `Configuration` runs at
+        # load, before any plugin has had the chance to register one.
+        def name?(entry)
+          NAME_PATTERN.match?(entry)
+        end
+
+        # Registers every `effect_entry_points:` preset the loaded plugins declare. Idempotent per name +
+        # glob set, so two runs in one process (the spec suite, the LSP) do not collide; two plugins
+        # claiming one name with different globs is a genuine conflict and raises.
+        def register_all(presets)
+          Array(presets).each { |preset| register(preset.name, preset.globs) }
+        end
+
+        # Every registered preset name, sorted. Empty until a plugin declaring `effect_entry_points:`
+        # loads, which is what makes {availability} worth printing.
+        def names
+          @presets.keys.sort.freeze
+        end
+
+        # The globs `name` stands for, or `nil` when nothing registered it.
+        def globs_for(name)
+          @presets[name.to_s]
+        end
+
+        # The globs `name` stands for, or the configuration error that says what this project could have
+        # written instead.
+        #
+        # The existence check lives here and runs from the snapshot build rather than from
+        # `Configuration` — presets are registered by plugins, and the plugins load FROM the configuration
+        # being validated, so at load time the registry is still empty. See {name?} for the shape check
+        # that does run at load.
+        def resolve!(name)
+          globs_for(name) || raise(
+            UnknownPreset,
+            "effects.snapshot.reach names no registered entry-point preset: #{name.to_s.inspect} " \
+            "(#{availability})"
+          )
+        end
+
+        # What this project may write in `effects.snapshot.reach:`, as one parenthetical clause.
+        #
+        # Single-homed here because the answer is a property of the loaded plugin set rather than of any
+        # one message: the unregistered-preset error (#433) and the note `rigor effects update` prints
+        # when `reach:` is empty (#436) have to give the same answer, and neither can hard-code a list
+        # that moves with `plugins:`.
+        #
+        # @return [String]
+        def availability
+          if @presets.empty?
+            return "no plugin in this project registers an entry-point preset — a preset is named by the " \
+                   "plugin that models the framework, so listing that plugin under `plugins:` is what " \
+                   "registers one"
+          end
+
+          "presets registered in this project: #{names.join(', ')}"
+        end
+
+        # Drops every registration. For specs only — production code registers and never unregisters.
+        def reset!
+          @presets = {}
+        end
+      end
+    end
+  end
+end

data/lib/rigor/effects/envelope.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "label_set"
+require_relative "summary"
+
+module Rigor
+  module Effects
+    # An author-declared upper bound on one method's effect labels (ADR-103 WD1; normative in
+    # `docs/type-specification/effect-labels.md` § Effect envelopes).
+    #
+    # Four facts and one seam:
+    #
+    # - {#owner_key} — the method key the envelope binds (`Class#m` / `Class.m`). A class-level
+    #   envelope is read once and {#rebind}ed onto each method of that class discovery knows.
+    # - {#bound} — the {LabelSet} the method's proven labels must be subsumed by. {LabelSet::TOP}
+    #   means "no envelope": the fail-open reading a tag carrying an unknown label degrades to.
+    # - {#source} — which spelling produced it: `:pure_annotation` (`%a{pure}`),
+    #   `:effect_annotation` (`%a{rigor:v1:effect …}` on the method), `:class_annotation` (either
+    #   spelling on the class / module declaration, which is also what {#rebind} stamps — what matters
+    #   downstream is that the bound was distributed rather than written on the method) or
+    #   `:config_envelope` (an `effects.envelopes:` entry, {ConfigEnvelopes}). The last one survives
+    #   {#rebind}: a configured envelope is distributed by construction, so "distributed" is not the
+    #   fact worth stamping — where it was written is.
+    # - {#location} — `path:line` of the annotation, or `.rigor.yml effects.envelopes[N]` for a
+    #   configured one, so the diagnostic can name where the bound was written; {#spelling} is the
+    #   author's own text, quoted back verbatim.
+    # - {#unknown_labels} — the well-formed-but-unrecognised spellings that made this envelope read
+    #   ⊤ ([#384](https://github.com/rigortype/rigor/issues/384)'s `effect.unknown-label` reads it).
+    #   Empty otherwise.
+    # - {#declared_labels} — every token the tag listed, in source order, recognised or not (empty
+    #   for `%a{pure}`, whose bound is written by its spelling rather than by a list). It is what
+    #   answers "was some OTHER member of this list known?", one of the four signals
+    #   {LabelIntent} reads intent off.
+    #
+    # `mutate.local` is tolerated by **every** envelope, `%a{pure}` included: a method may freely
+    # mutate what its own frame allocated and never let escape.
+    class Envelope < Data.define(:owner_key, :bound, :source, :location, :spelling, :unknown_labels,
+                                 :declared_labels)
+      NO_LABELS = [].freeze
+      private_constant :NO_LABELS
+
+      # {#source} for a bound written in `.rigor.yml` rather than on a declaration.
+      CONFIG_SOURCE = :config_envelope
+
+      def self.build(owner_key:, bound:, source:, location: nil, spelling: nil, unknown_labels: NO_LABELS,
+                     declared_labels: NO_LABELS)
+        new(
+          owner_key: owner_key, bound: bound, source: source, location: location,
+          spelling: spelling, unknown_labels: unknown_labels.uniq.sort.freeze,
+          declared_labels: declared_labels.dup.freeze
+        )
+      end
+
+      # Whether this reads as ⊤ — no bound at all. An unknown label degrades the whole tag here, so a
+      # typo suppresses findings rather than inventing them (the fail-open rule).
+      def top?
+        bound.top?
+      end
+
+      # Whether `label` is inside the bound. `mutate.local` always is.
+      def tolerates?(label)
+        bound.admits?(label) || Summary::TRIVIAL_BOUND.admits?(label)
+      end
+
+      # The members of `label_set` this envelope does NOT admit, sorted. One diagnostic per member.
+      def exceeded_by(label_set)
+        return NO_LABELS if top?
+
+        label_set.to_a.reject { |label| tolerates?(label) }
+      end
+
+      # Whether the bound was written in `.rigor.yml` rather than on a declaration.
+      def config?
+        source == CONFIG_SOURCE
+      end
+
+      # The same bound, attached to another method key — how a class-level envelope reaches each
+      # method of its class. The source becomes `:class_annotation`, because the distribution is the
+      # fact the diagnostic has to explain; a configured envelope keeps its own source, because for it
+      # distribution is the only mode there is and `.rigor.yml` is the fact worth naming.
+      def rebind(key)
+        config? ? with(owner_key: key) : with(owner_key: key, source: :class_annotation)
+      end
+    end
+  end
+end

data/lib/rigor/effects/envelope_check.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require_relative "envelope"
+require_relative "effect_table"
+require_relative "method_key"
+require_relative "path_finder"
+
+module Rigor
+  module Effects
+    # Judges each method's declared envelope against what the run actually proved (ADR-103 WD1 / WD8;
+    # #383). The one place `effect.envelope-exceeded` is decided.
+    #
+    # Three rules make this FP-safe, and each is load-bearing:
+    #
+    # - **It reads the PROVEN lane only**, never the declared one and never taint. A non-exhaustive
+    #   summary reads "these effects, and possibly more" and contributes no finding of its own; what
+    #   it *did* prove is still proven, so a proven label outside the bound still fires. That is "as
+    #   strict as proven" ([robustness-principle.md](../../../docs/type-specification/robustness-principle.md)),
+    #   and it is why an unresolved call can never manufacture one.
+    # - **The bound binds the method's CODE, transitively.** The envelope is a contract about what the
+    #   method does, and a repository that calls a helper that calls `Net::HTTP` does perform HTTP. So
+    #   the comparison is against {EffectTable::Entry#proven} — the fixpoint's closure over project
+    #   callees — not against the unit's own direct summary.
+    # - **`mutate.local` is tolerated by every envelope**, `%a{pure}` included ({Envelope#tolerates?}).
+    #
+    # **`effects.tolerated:` discharges, per origin** (#385). The comparison reads
+    # {EffectTable::Entry#undischarged} rather than `proven`: the propagator has already dropped every
+    # origin bundle the policy discharges and closed the rest over the graph, so a `pure`-declared method
+    # that logs is silent under `tolerated: [telemetry]` while the `File.read` two lines down still fires.
+    # `apply_tolerated: false` — `--no-tolerated-effects` — judges against `proven` instead, which is the
+    # audit switch that makes the policy inspectable rather than invisible.
+    module EnvelopeCheck
+      # One (method, exceeding label) pair. `chain` is the shortest project-method path from the
+      # method to whatever proves the label and `origin` is the callee key or construct at its end —
+      # the same explanation `rigor effects explain` prints, so the diagnostic tells a reader where to
+      # look rather than only that something is wrong.
+      Finding = Data.define(:key, :label, :envelope, :path, :line, :chain, :origin)
+
+      # The discovery tables a finding's POSITION is read from, as one value — `discovered_def_sources`
+      # (`{class => {method_sym => "path:line"}}`), its `def self.x` mirror, and `discovered_class_sources`
+      # (`{class => Set[path]}`), the fallback for a method with no Ruby `def` at all. Kept together so the
+      # check's own signature stays about the judgment rather than about where a `def` lives.
+      class Positions < Data.define(:def_sources, :singleton_def_sources, :class_sources)
+        NONE = {}.freeze
+        private_constant :NONE
+
+        def self.empty
+          @empty ||= build
+        end
+
+        def self.build(def_sources: nil, singleton_def_sources: nil, class_sources: nil)
+          new(def_sources: def_sources || NONE, singleton_def_sources: singleton_def_sources || NONE,
+              class_sources: class_sources || NONE)
+        end
+
+        # Where a finding about `key` goes: the Ruby `def`, from the discovery tables (ADR-103 WD14 chose
+        # the `def` over the `.rbs` line deliberately — `# rigor:disable` reads only Ruby comments). A
+        # method with no `def` at all is a synthesized accessor, and the class's own source is the closest
+        # thing to a position it has.
+        #
+        # It lives on the value rather than in {EnvelopeCheck} because {LiskovCheck} positions its
+        # findings identically, and two spellings of "where the fix goes" would eventually disagree.
+        #
+        # @return [Array(String, Integer)] `[path, line]`; `[nil, 1]` for a key with no owner.
+        def for(key)
+          class_name, separator, selector = MethodKey.split(key)
+          return [nil, 1] if class_name.nil?
+
+          table = separator == "." ? singleton_def_sources : def_sources
+          site = table.dig(class_name, selector.to_sym)
+          return split_site(site) if site
+
+          [Array(class_sources[class_name]).first, 1]
+        end
+
+        private
+
+        def split_site(site)
+          path, _, line = site.to_s.rpartition(":")
+          return [site.to_s, 1] if path.empty?
+
+          [path, line.to_i.positive? ? line.to_i : 1]
+        end
+      end
+
+      NO_FINDINGS = [].freeze
+      private_constant :NO_FINDINGS
+
+      module_function
+
+      # @param table [EffectTable] the run's propagated graph.
+      # @param method_envelopes [Hash{String => Envelope}] per-method envelopes, as written.
+      # @param class_envelopes [Hash{String => Envelope}] class- / module-level envelopes, to distribute.
+      # @param config_envelopes [Hash{String => Envelope}] `effects.envelopes:` entries already resolved
+      #   to the classes they select ({ConfigEnvelopes.for_classes}), to distribute at the lowest precedence.
+      # @param positions [Positions] the discovery tables a finding's `def` position is read from.
+      # @param apply_tolerated [Boolean] false judges against the undischarged-by-policy `proven` lane —
+      #   the `--no-tolerated-effects` audit switch.
+      # @return [Array<Finding>] sorted by position then key then label, so a run explains identically twice.
+      def run(table:, method_envelopes:, class_envelopes:, config_envelopes: {},
+              positions: Positions.empty, apply_tolerated: true)
+        envelopes = distribute(table, method_envelopes, class_envelopes, config_envelopes)
+        return NO_FINDINGS if envelopes.empty?
+
+        findings = []
+        envelopes.each do |key, envelope|
+          collect(findings, table, key, envelope, positions, apply_tolerated)
+        end
+        findings.sort_by { |f| [f.path.to_s, f.line, f.key, f.label] }.freeze
+      end
+
+      # Resolves the per-method envelope for every unit the table knows, **nearest wins**:
+      #
+      #     per-method annotation  >  class-level annotation  >  `effects.envelopes:` entry
+      #
+      # The two class-shaped strata distribute identically — an envelope keyed by a class name reaches
+      # every method key of THAT Ruby class, so a subclass's keys never match and a module distributes to
+      # its own methods only — and are applied in that order, so a written annotation always wins over a
+      # convention. Which config entry a class matched was already decided by {ConfigEnvelopes.for_classes}.
+      #
+      # Public because {LiskovCheck} resolves the *ancestor's* envelope by exactly these rules: an
+      # inherited bound has to be the same bound the ancestor is itself held to, or the two checks would
+      # disagree about what the author wrote.
+      def distribute(table, method_envelopes, class_envelopes, config_envelopes)
+        resolved = {}
+        unless class_envelopes.empty? && config_envelopes.empty?
+          keys_by_class(table).each do |class_name, keys|
+            envelope = class_envelopes[class_name] || config_envelopes[class_name]
+            next if envelope.nil?
+
+            keys.each { |key| resolved[key] = envelope.rebind(key) }
+          end
+        end
+        method_envelopes.each { |key, envelope| resolved[key] = envelope if table[key] }
+        resolved
+      end
+
+      # `{class name => [method key]}` over the units the run collected — the "every method discovery
+      # knows" of the class-level distribution rule, including reopenings in other files and the
+      # synthesized `attr_*` / `define_method` members the effects scanner adds.
+      def keys_by_class(table)
+        table.keys.each_with_object({}) do |key, out|
+          owner = MethodKey.owner(key)
+          next if owner.nil?
+
+          (out[owner] ||= []) << key
+        end
+      end
+
+      def collect(findings, table, key, envelope, positions, apply_tolerated)
+        return if envelope.top?
+
+        entry = table[key]
+        return if entry.nil?
+
+        exceeding = envelope.exceeded_by(apply_tolerated ? entry.undischarged : entry.proven)
+        return if exceeding.empty?
+
+        path, line = positions.for(key)
+        exceeding.each do |label|
+          trail = PathFinder.shortest(table, symbol: key, label: label)
+          findings << Finding.new(
+            key: key, label: label, envelope: envelope, path: path, line: line,
+            chain: trail&.chain || [key].freeze, origin: trail&.origin
+          )
+        end
+      end
+
+      private_class_method :keys_by_class, :collect
+    end
+  end
+end