rigortype 0.3.4 → 0.3.5

data/lib/rigor/plugin/manifest.rb

@@ -5,6 +5,7 @@ require_relative "protocol_contract"
 require_relative "additional_initializer"
 require_relative "effect_attribution"
 require_relative "effect_edge"
+require_relative "effect_ancestry"
 require_relative "effect_entry_points"
 require_relative "first_party"
 
@@ -46,7 +47,8 @@ module Rigor
                   :heredoc_templates, :nested_class_templates, :trait_registries,
                   :hkt_registrations, :hkt_definitions, :signature_paths, :protocol_contracts,
                   :source_rbs_synthesizer, :additional_initializers,
-                  :effect_root, :effect_labels, :effect_attributions, :effect_edges, :effect_entry_points
+                  :effect_root, :effect_labels, :effect_attributions, :effect_edges, :effect_entry_points,
+                  :effect_ancestry
 
       def initialize( # rubocop:disable Metrics/ParameterLists
         id:, version:,
@@ -57,7 +59,7 @@ module Rigor
         hkt_registrations: [], hkt_definitions: [], signature_paths: [], protocol_contracts: [],
         source_rbs_synthesizer: nil, additional_initializers: [],
         effect_root: nil, effect_labels: [], effect_attributions: [], effect_edges: [],
-        effect_entry_points: []
+        effect_entry_points: [], effect_ancestry: []
       )
         validate_id!(id)
         validate_version!(version)
@@ -76,11 +78,8 @@ module Rigor
         validate_protocol_contracts!(protocol_contracts)
         validate_source_rbs_synthesizer!(source_rbs_synthesizer)
         validate_additional_initializers!(additional_initializers)
-        validate_effect_root!(effect_root)
-        validate_effect_labels!(effect_labels)
-        validate_effect_attributions!(effect_attributions)
-        validate_effect_edges!(effect_edges)
-        validate_effect_entry_points!(effect_entry_points)
+        validate_effect_fields!(effect_root, effect_labels, effect_attributions, effect_edges,
+                                effect_entry_points, effect_ancestry)
 
         assign_fields(id, version, description, config_schema, produces, consumes, owns_receivers,
                       open_receivers, type_node_resolvers, block_as_methods, heredoc_templates, trait_registries,
@@ -88,7 +87,8 @@ module Rigor
                       source_rbs_synthesizer)
         assign_nested_class_templates(nested_class_templates)
         assign_additional_initializers(additional_initializers)
-        assign_effect_fields(effect_root, effect_labels, effect_attributions, effect_edges, effect_entry_points)
+        assign_effect_fields(effect_root, effect_labels, effect_attributions, effect_edges,
+                             effect_entry_points, effect_ancestry)
         freeze
       end
 
@@ -135,12 +135,26 @@ module Rigor
 
       # ADR-103 WD2 / WD6 / WD10 / WD14 — the effect contract's five fields, assigned together and outside
       # `assign_fields` (which already carries the maximum positional arity).
-      def assign_effect_fields(effect_root, effect_labels, effect_attributions, effect_edges, effect_entry_points)
+      # The six `effect_*` fields validate together, so {#initialize} carries one call rather than six.
+      def validate_effect_fields!(effect_root, effect_labels, effect_attributions, effect_edges,
+                                  effect_entry_points, effect_ancestry)
+        validate_effect_root!(effect_root)
+        validate_effect_labels!(effect_labels)
+        validate_effect_attributions!(effect_attributions)
+        validate_effect_edges!(effect_edges)
+        validate_effect_entry_points!(effect_entry_points)
+        validate_effect_ancestry!(effect_ancestry)
+      end
+      private :validate_effect_fields!
+
+      def assign_effect_fields(effect_root, effect_labels, effect_attributions, effect_edges,
+                               effect_entry_points, effect_ancestry)
         @effect_root = effect_root.nil? ? nil : effect_root.to_s.dup.freeze
         @effect_labels = effect_labels.map { |label| label.to_s.dup.freeze }.uniq.sort.freeze
         @effect_attributions = effect_attributions.dup.freeze
         @effect_edges = effect_edges.dup.freeze
         @effect_entry_points = effect_entry_points.dup.freeze
+        @effect_ancestry = effect_ancestry.dup.freeze
       end
       private :assign_effect_fields
       # rubocop:enable Metrics/ParameterLists, Metrics/AbcSize
@@ -194,7 +208,8 @@ module Rigor
           "effect_labels" => effect_labels,
           "effect_attributions" => effect_attributions.map(&:to_h),
           "effect_edges" => effect_edges.map(&:to_h),
-          "effect_entry_points" => effect_entry_points.map(&:to_h)
+          "effect_entry_points" => effect_entry_points.map(&:to_h),
+          "effect_ancestry" => effect_ancestry.map(&:to_h)
         }
       end
 
@@ -506,6 +521,15 @@ module Rigor
         end
       end
 
+      # ADR-103 WD17 (#465) — `effect_ancestry:` states an ancestry edge the plugin's own gem introduces
+      # and the project's source never writes. Each entry MUST be a {Rigor::Plugin::EffectAncestry}; only
+      # a bundled plugin's survives, which `Effects::PluginFacts` enforces.
+      def validate_effect_ancestry!(entries)
+        validate_array_of!("effect_ancestry", entries, "Rigor::Plugin::EffectAncestry instances") do |e|
+          e.is_a?(EffectAncestry)
+        end
+      end
+
       # ADR-103 WD14 — `effect_entry_points:` names the `effects.snapshot.reach:` presets this plugin
       # supplies. Each entry MUST be a {Rigor::Plugin::EffectEntryPoints}.
       def validate_effect_entry_points!(entries)

data/lib/rigor/plugin/registry.rb

@@ -262,9 +262,15 @@ module Rigor
       # plugin may open, and `discharge_allowed`, whether its attributions may discharge — so nothing
       # downstream has to re-derive who is first-party.
       Contribution = Data.define(:id, :owner, :requested_root, :discharge_allowed, :labels, :attributions,
-                                 :edges, :entry_points) do
+                                 :edges, :entry_points, :ancestry) do
+        # `ancestry:` defaults so a caller written before #465 — and every spec that constructs one by
+        # hand — keeps working; a plugin that declares none contributes none.
+        def initialize(ancestry: [], **rest)
+          super
+        end
+
         def empty?
-          labels.empty? && attributions.empty? && edges.empty? && entry_points.empty?
+          labels.empty? && attributions.empty? && edges.empty? && entry_points.empty? && ancestry.empty?
         end
       end
 
@@ -422,7 +428,8 @@ module Rigor
           id: manifest.id, owner: manifest.effect_owner, requested_root: manifest.effect_root,
           discharge_allowed: manifest.effect_discharge_allowed?,
           labels: plugin.effect_labels, attributions: plugin.effect_attributions,
-          edges: plugin.effect_edges, entry_points: plugin.effect_entry_points
+          edges: plugin.effect_edges, entry_points: plugin.effect_entry_points,
+          ancestry: plugin.effect_ancestry
         )
         contribution.empty? ? nil : contribution
       rescue StandardError

data/lib/rigor/rbs_extended.rb

@@ -4,6 +4,7 @@ require_relative "type"
 require_relative "builtins/imported_refinements"
 require_relative "flow_contribution"
 require_relative "effects/envelope"
+require_relative "effects/inline_anchor"
 require_relative "effects/label"
 require_relative "effects/label_set"
 require_relative "effects/signature_sources"
@@ -769,6 +770,12 @@ module Rigor
 
     # `path:line` for the annotation, project-relative when it sits under the working directory, so a
     # diagnostic message names `sig/foo.rbs:12` rather than an absolute path.
+    #
+    # A synthesized buffer is re-anchored here rather than at any of the surfaces that render it
+    # ({Effects::InlineAnchor}; #432). The buffer's own line numbers describe a document the author
+    # never saw, so an envelope carrying one is wrong for every consumer at once — the diagnostic, the
+    # `effect.unknown-label` position, `rigor explain`, the JSON formatter, LSP hover. Correcting it
+    # where the value is *built* is what makes them agree without each learning the mapping.
     def render_annotation_location(annotation)
       location = annotation_location(annotation)
       return nil if location.nil?
@@ -777,12 +784,25 @@ module Rigor
       name = buffer.respond_to?(:name) ? buffer.name.to_s : nil
       return nil if name.nil? || name.empty?
 
-      line = location.respond_to?(:start_line) ? location.start_line : 1
-      "#{relative_annotation_path(name)}:#{line}"
+      path = relative_annotation_path(name)
+      "#{path}:#{annotation_line(annotation, location, buffer, path)}"
     rescue StandardError
       nil
     end
 
+    # The line a reader can open. For a real `.rbs` that is the parser's own answer; for the
+    # `virtual:rbs-inline:…rb` buffer the writer produced, the annotation is found again in the Ruby
+    # source by its own spelling.
+    def annotation_line(annotation, location, buffer, path)
+      line = location.respond_to?(:start_line) ? location.start_line : 1
+      content = buffer.respond_to?(:content) ? buffer.content : nil
+      return line if content.nil?
+
+      Effects::InlineAnchor.ruby_line(
+        path: path, buffer: content, buffer_line: line, spelling: "%a{#{annotation.string}}"
+      )
+    end
+
     # The buffer-name → readable-path rule lives with the walk that produces the buffers
     # ({Effects::SignatureSources}), so a `virtual:` name is stripped identically wherever it surfaces.
     def relative_annotation_path(name)

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.3.4"
+  VERSION = "0.3.5"
 end

data/plugins/rigor-activesupport-core-ext/sig/active_support/core_ext.rbs

@@ -598,8 +598,23 @@ class Date
   %a{pure}
   def advance: (untyped options) -> Date
   def all_day: () -> Range[Time]
-  %a{pure}
-  def to_time: (?Symbol form) -> Time
+  # NOTE: `Date#to_time` is an OVERLOAD CONTINUATION (`| ...`), not a plain
+  # declaration — stdlib `date` already types `to_time: () -> Time`, and a
+  # second full declaration of the same method from a second signature source
+  # makes `RBS::DefinitionBuilder` raise `DuplicatedMethodDefinitionError`,
+  # which collapses `Date` AND `DateTime` to `Dynamic[top]` for every project
+  # that activates this plugin (#437 — the same failure the `DateTime#to_time`
+  # note below records). The row cannot simply be DROPPED the way
+  # `DateTime#to_time` was: ActiveSupport genuinely widens the arity, and
+  # without the row `date.to_time(:utc)` — correct Rails code — would draw an
+  # arity diagnostic. `| ...` appends this overload ahead of the stdlib one, so
+  # both arities resolve and the `%a{pure}` envelope stays attached to the
+  # ActiveSupport overload (which is the one a no-argument call selects).
+  # `| ...` requires the base declaration to exist, which `Environment.for_project`
+  # guarantees: it merges `DEFAULT_LIBRARIES` — including `date` — into every
+  # environment that loads a plugin's `signature_paths`.
+  %a{pure}
+  def to_time: (?Symbol form) -> Time | ...
 end
 
 # ---------------------------------------------------------------

data/plugins/rigor-devise/lib/rigor/plugin/devise.rb

@@ -82,6 +82,33 @@ module Rigor
             },
             always_included: ["Devise::Models::Authenticatable"]
           )
+        ],
+        # ADR-103 WD17 (#465) — the ancestry Devise introduces and a project's own source never writes.
+        #
+        # `class UserMailer < Devise::Mailer` and `class Auth::SessionsController <
+        # Devise::SessionsController` are what a Devise application looks like, and the walk that reaches
+        # a plugin row climbs the project's own `class … <` lines only — so it stopped at the gem class
+        # and `rigor-actionmailer`'s and `rigor-actionpack`'s rows never arrived. Measured on Mastodon:
+        # six classes, five of them controllers, which are entry points.
+        #
+        # Every `parent:` below is a **true ancestor and not the immediate one**, deliberately. Devise's
+        # controllers descend through `DeviseController`, whose own parent is `Devise.parent_controller`
+        # — configurable per project, defaulting to the application's own `ApplicationController`. Naming
+        # the intermediate links would state something a project can make false; naming a true ancestor
+        # loses nothing, because no plugin row is ever keyed on a project class.
+        effect_ancestry: [
+          Rigor::Plugin::EffectAncestry.new(
+            child: "Devise::Mailer", parent: "ActionMailer::Base",
+            why: "Devise::Mailer is an ActionMailer; a true ancestor, skipping Devise's own intermediates"
+          ),
+          *%w[SessionsController RegistrationsController PasswordsController ConfirmationsController
+              UnlocksController OmniauthCallbacksController].map do |controller|
+            Rigor::Plugin::EffectAncestry.new(
+              child: "Devise::#{controller}", parent: "ActionController::Base",
+              why: "a Devise controller is an ActionController; a true ancestor, skipping DeviseController " \
+                   "and `Devise.parent_controller`, which a project may configure"
+            )
+          end
         ]
       )
     end

data/plugins/rigor-rbs-inline/lib/rigor/plugin/rbs_inline.rb

@@ -50,6 +50,19 @@ module Rigor
         # space-free spelling is affected; `# :nodoc:` never reaches upstream's annotation grammar.
         RDOC_DIRECTIVE_COMMENT = /\A#:[a-z_][\w-]*:/
 
+        # An `%a{…}` the author wrote above a `class` / `module`, as upstream's writer echoes it: an ordinary
+        # comment, because the writer emits no annotation on a declaration
+        # ([#452](https://github.com/rigortype/rigor/issues/452)).
+        ECHOED_ANNOTATION = /\A\s*#\s*@rbs\s+(%a\{[^}]*\})\s*\z/
+
+        # The declaration the pending annotations belong to. `class`/`module` and the whitespace after the
+        # keyword, so `class_eval` is not one and the indentation to re-emit at is captured.
+        DECLARATION_LINE = /\A(\s*)(?:class|module)\s/
+
+        COMMENT_LINE = /\A\s*#/
+
+        private_constant :ECHOED_ANNOTATION, :DECLARATION_LINE, :COMMENT_LINE
+
         # @param require_magic_comment [Boolean] when `false` (the default since ADR-93 WD1), the magic
         #   comment is not required and the file is processed only if it actually carries an annotation — see
         #   {#annotated?}. When `true` (the old ADR-32 WD2 gate), only files opening with
@@ -82,7 +95,7 @@ module Rigor
           return nil if parsed.nil?
 
           uses, decls, rbs_decls = parsed
-          rendered = ::RBS::Inline::Writer.write(uses, decls, rbs_decls)
+          rendered = reattach_declaration_annotations(::RBS::Inline::Writer.write(uses, decls, rbs_decls))
           return nil if rendered.nil? || rendered.strip.empty?
 
           notices = unhonoured_annotations(result)
@@ -96,6 +109,48 @@ module Rigor
 
         private
 
+        # Re-attaches a class- or module-level `%a{…}` that upstream's writer dropped (#452).
+        #
+        # `RBS::Inline::Writer` emits a member's annotations as real annotation lines and a *declaration's*
+        # as nothing at all — it echoes the author's comment block above `class Foo` and stops there. So the
+        # cheapest bound in the feature, one line above a class, reached the envelope reader as a comment:
+        # no bound, no diagnostic, and a clean run that had checked nothing. The `.rbs` lane, writing the
+        # same `%a{pure}` above the same `class`, worked. Both lanes now answer the same.
+        #
+        # The rewrite reads only what the writer itself emitted, in one pass, and is deliberately literal:
+        # an annotation the author spelled in a comment block that the writer echoed is re-emitted, at the
+        # declaration's own indentation, on the line the RBS grammar wants it on. Three properties make that
+        # safe rather than clever:
+        #
+        # - a comment block is echoed **only when its member is emitted**, so a detached annotation (one a
+        #   blank line separates from the declaration, which upstream drops) is never echoed and so never
+        #   re-attached — the two lanes agree about that too;
+        # - any non-comment line clears the pending set, so a member's own annotation — which the writer
+        #   *does* emit, on the line between the echo and the `def` — ends the run before a declaration can
+        #   claim it, and no annotation is ever attached twice;
+        # - the same property makes this forward-compatible: if upstream some day emits the declaration
+        #   annotation itself, that line clears the pending set and this contributes nothing.
+        def reattach_declaration_annotations(rendered)
+          return rendered if rendered.nil? || !rendered.include?("%a{")
+
+          pending = []
+          rendered.lines.flat_map do |line|
+            if (annotation = ECHOED_ANNOTATION.match(line))
+              pending << annotation[1]
+              line
+            elsif COMMENT_LINE.match?(line)
+              line
+            elsif (declaration = DECLARATION_LINE.match(line)) && !pending.empty?
+              emitted = pending.map { |spelling| "#{declaration[1]}#{spelling}\n" } << line
+              pending = []
+              emitted
+            else
+              pending = []
+              line
+            end
+          end.join
+        end
+
         # True when the file carries at least one rbs-inline annotation. Gates the magic-comment-free mode,
         # and is the difference between "honour annotations wherever they are" and "fabricate signatures for
         # code nobody annotated" — upstream's opt-out mode does the latter, emitting a full

data/plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq/effects.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+module Rigor
+  module Plugin
+    class Sidekiq < Rigor::Plugin::Base
+      # rigor-sidekiq's effect contract (ADR-103 WD4 / WD10; [#456](https://github.com/rigortype/rigor/issues/456)).
+      #
+      # `job.enqueue` shipped in the vocabulary with nothing producing it. Across two Rails applications
+      # the corpus census found zero instances of it, while Mastodon alone writes 219 `perform_async`-shaped
+      # call sites with this plugin loaded — so the label a policy would actually name ("nothing on this
+      # path may enqueue work") could not be written against anything.
+      #
+      # ## Why the rows key on a module
+      #
+      # A Sidekiq worker has no base class: it is `class TriggerWebhookWorker; include Sidekiq::Job`. Every
+      # other first-party plugin's rows key on a base class and reach a project subclass through the
+      # project's own `class … <` lines, which is a walk that cannot see an `include` — so until #456 taught
+      # `Effects::PluginFacts#ancestry` to walk included modules beside the superclass, no spelling of these
+      # rows could have matched. The marker modules are the plugin's existing `worker_marker_modules:`
+      # config, so a project that includes its own concern instead names it once and gets both the arity
+      # check and these rows.
+      #
+      # ## What is deliberately not here
+      #
+      # `perform_inline` / `perform_sync` run the job on the caller's stack. They are not an enqueue and
+      # must not carry `job.enqueue`; the honest reading is an edge into the worker's own `#perform`, which
+      # {Rigor::Plugin::EffectEdge::TARGETS} spells only for the ActiveJob shape today. A row claiming the
+      # enqueue for them would be worse than the silence.
+      module Effects
+        # Redis is the transport, and unlike ActiveJob's adapter there is nothing to read: a project that
+        # loads Sidekiq has chosen it. `io.net` rather than `io` because the round trip is a socket in every
+        # deployment worth naming — a unix socket is still `io.net`'s subsystem, not the filesystem's.
+        TRANSPORT = ["io.net"].freeze
+
+        # The meaning half, and the reason this file exists: what a policy names.
+        MEANING = ["job.enqueue"].freeze
+
+        LABELS = (TRANSPORT + MEANING).freeze
+
+        # The class-side enqueues. `perform_bulk` takes an array of argument arrays and enqueues each.
+        SINGLETON_ENQUEUES = %w[perform_async perform_in perform_at perform_bulk].freeze
+
+        # `Worker.set(queue: "low").perform_async(…)` — `set` returns a lazy `Setter` that has enqueued
+        # nothing, so the enqueue is one link further out, keyed on the class that produced the Setter.
+        RESULT_ENQUEUES = %w[perform_async perform_in perform_at perform_bulk].freeze
+
+        WHY = "Sidekiq's enqueue is a Redis round trip; `job.enqueue` is the meaning a policy names. " \
+              "The row is keyed on the marker module because a Sidekiq worker includes rather than " \
+              "inherits."
+
+        module_function
+
+        # @param marker_modules [Array<String>] the modules a worker includes — the plugin's own
+        #   `worker_marker_modules:` config, so one project setting drives the arity check and these rows.
+        def attributions(marker_modules)
+          marker_modules.flat_map do |marker|
+            SINGLETON_ENQUEUES.map do |selector|
+              EffectAttribution.new(receiver: marker, method: selector, labels: LABELS, singleton: true,
+                                    discharge: true, why: WHY)
+            end +
+              RESULT_ENQUEUES.map do |selector|
+                EffectAttribution.new(
+                  receiver: marker, method: selector, labels: LABELS, on_result: true, discharge: true,
+                  why: "#{WHY} Matched on the RESULT of a call to the worker class, which is the shape " \
+                       "`Worker.set(queue: \"low\").perform_async(…)` takes."
+                )
+              end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq.rb

@@ -6,6 +6,7 @@ require_relative "sidekiq/worker_index"
 require_relative "sidekiq/worker_discoverer"
 require_relative "sidekiq/schedule_scan"
 require_relative "sidekiq/analyzer"
+require_relative "sidekiq/effects"
 
 module Rigor
   module Plugin
@@ -62,9 +63,20 @@ module Rigor
           # these are file paths, not directories, because a schedule is a named document rather than a tree.
           "schedule_paths" => { kind: :array, default: ["config/schedule.yml", "config/sidekiq.yml"] }
         },
-        produces: [:reachability_roots]
+        produces: [:reachability_roots],
+        # ADR-103 WD4 / WD10 (#456). The rows themselves are NOT here: they key on the project's own
+        # `worker_marker_modules:` setting, so they are built in `#effect_attributions` below.
+        effect_labels: []
       )
 
+      # ADR-103 WD10 — the enqueue rows, keyed on whichever modules this project's workers include.
+      # Overridden rather than declared on the manifest because the marker set is configuration;
+      # `Plugin::Registry#effect_contributions` is lazy and asks once per process, and only on a run with
+      # collection on.
+      def effect_attributions
+        Effects.attributions(@worker_marker_modules || Array(config.fetch("worker_marker_modules")).map(&:to_s))
+      end
+
       producer :worker_index, watch: -> { [[@worker_search_paths, "**/*.rb"]] } do |_params|
         WorkerDiscoverer.new(
           io_boundary: io_boundary,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
 platform: ruby
 authors:
 - Rigor contributors
@@ -360,6 +360,7 @@ files:
 - docs/manual/16-rbs-extended-annotations.md
 - docs/manual/17-driving-improvement.md
 - docs/manual/18-removing-dead-code.md
+- docs/manual/19-effect-labels.md
 - docs/manual/README.md
 - docs/manual/ci-templates/README.md
 - docs/manual/plugins/README.md
@@ -533,6 +534,7 @@ files:
 - lib/rigor/configuration.rb
 - lib/rigor/configuration/dependencies.rb
 - lib/rigor/configuration/severity_profile.rb
+- lib/rigor/configuration_error.rb
 - lib/rigor/effects.rb
 - lib/rigor/effects/attribution.rb
 - lib/rigor/effects/catalog.rb
@@ -547,6 +549,7 @@ files:
 - lib/rigor/effects/file_collection.rb
 - lib/rigor/effects/framework_units.rb
 - lib/rigor/effects/identity.rb
+- lib/rigor/effects/inline_anchor.rb
 - lib/rigor/effects/label.rb
 - lib/rigor/effects/label_intent.rb
 - lib/rigor/effects/label_set.rb
@@ -708,6 +711,7 @@ files:
 - lib/rigor/plugin/base.rb
 - lib/rigor/plugin/blueprint.rb
 - lib/rigor/plugin/box.rb
+- lib/rigor/plugin/effect_ancestry.rb
 - lib/rigor/plugin/effect_attribution.rb
 - lib/rigor/plugin/effect_edge.rb
 - lib/rigor/plugin/effect_entry_points.rb
@@ -937,6 +941,7 @@ files:
 - plugins/rigor-sidekiq/lib/rigor-sidekiq.rb
 - plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq.rb
 - plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq/analyzer.rb
+- plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq/effects.rb
 - plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq/schedule_scan.rb
 - plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq/worker_discoverer.rb
 - plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq/worker_index.rb