rigortype 0.1.10 → 0.1.12

data/plugins/rigor-activerecord/sig/active_record/relation.rbs

@@ -0,0 +1,182 @@
+# ActiveRecord::Relation — generic signature bundled by
+# rigor-activerecord (ADR-25 plugin-contributed RBS).
+#
+# Purpose: give `has_many` / `has_and_belongs_to_many` accessors,
+# `Model.where(...)` / `Model.all` / `Model.order(...)` and
+# user-declared `scope`s a precise *element* type. The plugin
+# contributes `ActiveRecord::Relation[Model]` for those call
+# sites; this file is what makes the chained relation methods
+# (`.where`, `.order`, `.first`, `.each { |m| ... }`, …) resolve.
+#
+# This is NOT a faithful transcription of Rails' Relation API —
+# it is the surface Rigor needs to type-check idiomatic relation
+# usage WITHOUT false positives. Two design rules:
+#
+# - Chain methods return `self`, so `Relation[Model]` survives an
+#   arbitrarily long query chain.
+# - The method list is deliberately generous. A method that is
+#   genuinely on `ActiveRecord::Relation` but missing here would
+#   surface as a false `call.undefined-method` once the plugin
+#   has typed the receiver — so the list errs toward inclusion.
+#   `include Enumerable[Elem]` carries the whole iteration
+#   surface; the class body only adds relation-specific methods
+#   and the ones whose argument shape differs from Enumerable's.
+#
+# If the project supplies its own ActiveRecord RBS (e.g. via
+# `rbs collection`), that definition conflicts with this one and
+# the conflict degrades through Rigor's plugin-RBS failure memo
+# (ADR-25 WD4) — the richer upstream definition simply wins.
+
+module ActiveRecord
+  class Relation[Elem]
+    include Enumerable[Elem]
+
+    # `Enumerable` only *requires* `each` (the includer supplies
+    # it); it is declared here so `relation.each { |m| ... }`
+    # resolves and the block parameter carries the element type.
+    def each: () { (Elem) -> void } -> self
+            | () -> Enumerator[Elem, self]
+
+    # --- query builders (return another relation) ---
+    def where: (*untyped) ?{ () -> untyped } -> self
+    def rewhere: (*untyped) -> self
+    def not: (*untyped) -> self
+    def or: (untyped) -> self
+    def and: (untyped) -> self
+    def order: (*untyped) -> self
+    def reorder: (*untyped) -> self
+    def in_order_of: (*untyped) -> self
+    def limit: (untyped) -> self
+    def offset: (untyped) -> self
+    def distinct: (?untyped) -> self
+    def group: (*untyped) -> self
+    def regroup: (*untyped) -> self
+    def having: (*untyped) -> self
+    def includes: (*untyped) -> self
+    def preload: (*untyped) -> self
+    def eager_load: (*untyped) -> self
+    def joins: (*untyped) -> self
+    def left_joins: (*untyped) -> self
+    def left_outer_joins: (*untyped) -> self
+    def references: (*untyped) -> self
+    def select: (*untyped) -> self
+    def reselect: (*untyped) -> self
+    def unscope: (*untyped) -> self
+    def merge: (untyped) -> self
+    def except: (*untyped) -> self
+    def only: (*untyped) -> self
+    def extending: (*untyped) -> self
+    def from: (untyped, ?untyped) -> self
+    def lock: (?untyped) -> self
+    def readonly: (?untyped) -> self
+    def strict_loading: (?untyped) -> self
+    def create_with: (untyped) -> self
+    def none: () -> self
+    def all: () -> self
+    def unscoped: () -> self
+    def default_scoped: () -> self
+    def annotate: (*untyped) -> self
+    def optimizer_hints: (*untyped) -> self
+    def excluding: (*untyped) -> self
+    def without: (*untyped) -> self
+    def with: (*untyped) -> self
+    def scoping: () { () -> untyped } -> untyped
+
+    # --- finders (return an element) ---
+    def find: (*untyped) -> Elem
+    def find_by: (*untyped) -> Elem?
+    def find_by!: (*untyped) -> Elem
+    def find_sole_by: (*untyped) -> Elem
+    def sole: () -> Elem
+    def first: () -> Elem?
+            | (Integer limit) -> Array[Elem]
+    def first!: () -> Elem
+    def last: () -> Elem?
+           | (Integer limit) -> Array[Elem]
+    def last!: () -> Elem
+    def take: () -> Elem?
+           | (Integer limit) -> Array[Elem]
+    def take!: () -> Elem
+    def second: () -> Elem?
+    def third: () -> Elem?
+    def fourth: () -> Elem?
+    def fifth: () -> Elem?
+    def forty_two: () -> Elem?
+    def second_to_last: () -> Elem?
+    def third_to_last: () -> Elem?
+
+    # --- batched enumeration ---
+    def find_each: (**untyped) ?{ (Elem) -> void } -> untyped
+    def find_in_batches: (**untyped) ?{ (Array[Elem]) -> void } -> untyped
+    def in_batches: (**untyped) ?{ (ActiveRecord::Relation[Elem]) -> void } -> untyped
+
+    # --- scalars / aggregates ---
+    def count: (*untyped) ?{ (Elem) -> untyped } -> untyped
+    def sum: (*untyped) ?{ (Elem) -> untyped } -> untyped
+    def average: (untyped) -> untyped
+    def minimum: (untyped) -> untyped
+    def maximum: (untyped) -> untyped
+    def calculate: (*untyped) -> untyped
+    def pluck: (*untyped) -> Array[untyped]
+    def pick: (*untyped) -> untyped
+    def ids: () -> Array[untyped]
+    def size: () -> Integer
+    def length: () -> Integer
+    def empty?: () -> bool
+    def any?: (*untyped) ?{ (Elem) -> boolish } -> bool
+    def none?: (*untyped) ?{ (Elem) -> boolish } -> bool
+    def one?: (*untyped) ?{ (Elem) -> boolish } -> bool
+    def many?: () ?{ (Elem) -> boolish } -> bool
+    def exists?: (*untyped) -> bool
+    def include?: (untyped) -> bool
+    def member?: (untyped) -> bool
+
+    # --- conversion / state ---
+    def to_a: () -> Array[Elem]
+    def to_ary: () -> Array[Elem]
+    def entries: () -> Array[Elem]
+    def load: (?untyped) -> self
+    def reload: () -> self
+    def reset: () -> self
+    def loaded?: () -> bool
+    def to_sql: () -> String
+    def explain: (*untyped) -> String
+    def cache_key: (?untyped) -> String
+    def cache_version: (?untyped) -> untyped
+    def to_json: (*untyped) -> String
+    def as_json: (?untyped) -> untyped
+    def blank?: () -> bool
+    def present?: () -> bool
+    def klass: () -> untyped
+    def model: () -> untyped
+    def table: () -> untyped
+    def arel: () -> untyped
+
+    # --- whole-relation persistence ---
+    def update_all: (untyped) -> Integer
+    def delete_all: () -> Integer
+    def destroy_all: () -> Array[Elem]
+    def update: (*untyped) -> untyped
+    def update!: (*untyped) -> untyped
+    def delete_by: (*untyped) -> Integer
+    def destroy_by: (*untyped) -> Array[Elem]
+    def touch_all: (*untyped) -> Integer
+    def insert_all: (untyped, **untyped) -> untyped
+    def insert_all!: (untyped, **untyped) -> untyped
+    def upsert_all: (untyped, **untyped) -> untyped
+
+    # --- instantiating builders (return an element) ---
+    def new: (*untyped) ?{ (Elem) -> void } -> Elem
+    def build: (*untyped) ?{ (Elem) -> void } -> Elem
+    def create: (*untyped) ?{ (Elem) -> void } -> Elem
+    def create!: (*untyped) ?{ (Elem) -> void } -> Elem
+    def find_or_create_by: (untyped) ?{ (Elem) -> void } -> Elem
+    def find_or_create_by!: (untyped) ?{ (Elem) -> void } -> Elem
+    def find_or_initialize_by: (untyped) ?{ (Elem) -> void } -> Elem
+    def create_or_find_by: (untyped) ?{ (Elem) -> void } -> Elem
+    def create_or_find_by!: (untyped) ?{ (Elem) -> void } -> Elem
+    def first_or_create: (?untyped) ?{ (Elem) -> void } -> Elem
+    def first_or_create!: (?untyped) ?{ (Elem) -> void } -> Elem
+    def first_or_initialize: (?untyped) ?{ (Elem) -> void } -> Elem
+  end
+end

data/plugins/rigor-activestorage/lib/rigor/plugin/activestorage/analyzer.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Plugin
+    class Activestorage < Rigor::Plugin::Base
+      # Per-file walker. Emits one `:info` `attachment-call`
+      # diagnostic per recognised attachment access on a
+      # known AR class. The diagnostic surfaces what the
+      # plugin recognised so users can verify the model →
+      # attachment mapping the plugin sees.
+      #
+      # No `:error` diagnostics in this slice — the
+      # `flow_contribution_for` return-type narrowing carries
+      # the type-checking value; surfacing unknown attachment
+      # names as errors requires a coupled receiver-class
+      # narrowing pass that the integration spec doesn't yet
+      # rely on. A future slice can add `unknown-attachment`
+      # similar to `rigor-activerecord`'s `unknown-column`.
+      class Analyzer
+        attr_reader :diagnostics
+
+        def initialize(path:, attachment_index:)
+          @path = path
+          @attachment_index = attachment_index
+          @diagnostics = []
+        end
+
+        def analyze(root)
+          walk(root) { |node| visit_call(node) if node.is_a?(Prism::CallNode) }
+          self
+        end
+
+        private
+
+        def walk(node, &)
+          return if node.nil?
+
+          yield node
+          node.compact_child_nodes.each { |child| walk(child, &) }
+        end
+
+        def visit_call(node)
+          return unless node.receiver.is_a?(Prism::ConstantReadNode)
+
+          owner = node.receiver.name.to_s
+          attachments = @attachment_index.attachments_for(owner) ||
+                        @attachment_index.attachments_for("::#{owner}")
+          return if attachments.nil?
+
+          # Only flag when the method matches a known
+          # attachment name (the `flow_contribution_for`
+          # tier provides the narrowing; the diagnostic just
+          # confirms the recognition).
+          attachment = attachments.find { |a| a[:name] == node.name.to_s }
+          return if attachment.nil?
+
+          push_info(node, "attachment-call",
+                    "`#{owner}.#{attachment[:name]}` returns " \
+                    "ActiveStorage::Attached::#{attachment[:kind] == :singular ? 'One' : 'Many'}")
+        end
+
+        def push_info(node, rule, message)
+          location = node.location
+          @diagnostics << Rigor::Analysis::Diagnostic.new(
+            path: @path,
+            line: location.start_line,
+            column: location.start_column + 1,
+            message: message,
+            severity: :info,
+            rule: rule
+          )
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-activestorage/lib/rigor/plugin/activestorage/attachment_discoverer.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Plugin
+    class Activestorage < Rigor::Plugin::Base
+      # Walks the configured model search paths via the plugin's
+      # `IoBoundary`, parses each `.rb` file with Prism, and
+      # collects `has_one_attached` / `has_many_attached`
+      # declarations.
+      #
+      # Returns rows the {AttachmentIndex} consumes:
+      #
+      #   { class_name: "User",
+      #     attachments: [{ name: "avatar", kind: :singular },
+      #                   { name: "photos", kind: :collection }] }
+      #
+      # Limitations (intentional for v0.1.0 of the plugin):
+      #
+      # - The walker matches any class declaration that
+      #   contains a `has_*_attached` call. Whether the class
+      #   IS an ActiveRecord model is not verified here —
+      #   `rigor-activerecord` provides that check via its
+      #   own model index. The analyser is intentionally
+      #   lenient so the plugin runs standalone in projects
+      #   that haven't loaded `rigor-activerecord` yet.
+      # - Only Symbol-literal attachment names are recognised.
+      #   `has_one_attached(args)` or computed names decline.
+      # - Modules (`class Admin::User`) are recognised; the
+      #   resulting class name is the lexical path
+      #   (`Admin::User`).
+      class AttachmentDiscoverer
+        ATTACHMENT_METHODS = {
+          has_one_attached: :singular,
+          has_many_attached: :collection
+        }.freeze
+        private_constant :ATTACHMENT_METHODS
+
+        def initialize(io_boundary:, search_paths:)
+          @io_boundary = io_boundary
+          @search_paths = search_paths
+        end
+
+        def discover
+          rows = []
+          ruby_files_under(@search_paths).each do |path|
+            contents = read_safely(path)
+            next if contents.nil?
+
+            tree = Prism.parse(contents).value
+            walk(tree, []) do |class_name, attachments|
+              rows << { class_name: class_name, attachments: attachments } unless attachments.empty?
+            end
+          end
+          rows
+        end
+
+        private
+
+        def read_safely(path)
+          @io_boundary.read_file(path)
+        rescue Plugin::AccessDeniedError, Errno::ENOENT
+          nil
+        end
+
+        def ruby_files_under(roots)
+          roots.flat_map do |root|
+            absolute = File.expand_path(root)
+            next [] unless File.directory?(absolute)
+
+            Dir.glob(File.join(absolute, "**", "*.rb"))
+          end
+        end
+
+        def walk(node, lexical_path, &)
+          return if node.nil?
+
+          case node
+          when Prism::ClassNode
+            visit_class(node, lexical_path, &)
+          when Prism::ModuleNode
+            visit_module(node, lexical_path, &)
+          else
+            node.compact_child_nodes.each { |child| walk(child, lexical_path, &) }
+          end
+        end
+
+        def visit_class(node, lexical_path, &)
+          class_local_name = constant_path_name(node.constant_path)
+          return if class_local_name.nil?
+
+          full_name = (lexical_path + [class_local_name]).join("::")
+          attachments = collect_attachments(node.body)
+          yield full_name, attachments
+
+          inner_path = lexical_path + [class_local_name]
+          walk(node.body, inner_path, &) if node.body
+        end
+
+        def visit_module(node, lexical_path, &)
+          module_local_name = constant_path_name(node.constant_path)
+          return if module_local_name.nil?
+
+          inner_path = lexical_path + [module_local_name]
+          walk(node.body, inner_path, &) if node.body
+        end
+
+        def collect_attachments(body)
+          return [] if body.nil?
+
+          rows = []
+          body.compact_child_nodes.each do |node|
+            next unless node.is_a?(Prism::CallNode)
+
+            kind = ATTACHMENT_METHODS[node.name]
+            next if kind.nil?
+            next if node.receiver # skip self.has_one_attached and similar
+
+            name = symbol_literal_arg(node)
+            next if name.nil?
+
+            rows << { name: name, kind: kind }
+          end
+          rows
+        end
+
+        def symbol_literal_arg(node)
+          args = node.arguments&.arguments
+          return nil if args.nil? || args.empty?
+
+          first = args.first
+          return nil unless first.is_a?(Prism::SymbolNode)
+
+          first.unescaped
+        end
+
+        def constant_path_name(node)
+          return nil if node.nil?
+
+          case node
+          when Prism::ConstantReadNode
+            node.name.to_s
+          when Prism::ConstantPathNode
+            parts = []
+            current = node
+            while current.is_a?(Prism::ConstantPathNode)
+              parts.unshift(current.name.to_s)
+              current = current.parent
+            end
+            case current
+            when nil
+              "::#{parts.join('::')}"
+            when Prism::ConstantReadNode
+              "#{current.name}::#{parts.join('::')}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-activestorage/lib/rigor/plugin/activestorage/attachment_index.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    class Activestorage < Rigor::Plugin::Base
+      # Maps a discovered class name to the list of attachment
+      # rows declared on it. Marshal-clean so the cache producer
+      # round-trips it through the standard pair.
+      #
+      # Each row is `{ name:, kind: }`:
+      #
+      # - `name` — String, the attachment method name as the
+      #            user invokes it (`"avatar"`).
+      # - `kind` — `:singular` (`has_one_attached`) or
+      #            `:collection` (`has_many_attached`).
+      class AttachmentIndex
+        attr_reader :entries
+
+        def initialize(entries)
+          @entries = entries.freeze
+          freeze
+        end
+
+        def attachments_for(class_name)
+          entries[class_name.to_s]
+        end
+
+        def class_names = entries.keys
+
+        def empty? = entries.empty?
+
+        def self.build(rows:)
+          entries = rows.each_with_object({}) do |row, acc|
+            class_name = row.fetch(:class_name)
+            attachments = Array(row[:attachments]).map(&:freeze).freeze
+            acc[class_name] = attachments
+          end
+          new(entries.freeze)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+require_relative "activestorage/attachment_discoverer"
+require_relative "activestorage/attachment_index"
+require_relative "activestorage/analyzer"
+
+module Rigor
+  module Plugin
+    # rigor-activestorage — recognises `has_one_attached` /
+    # `has_many_attached` macros on ActiveRecord models and
+    # contributes attachment accessor return types so chained
+    # calls (`user.avatar.attached?`) route through Rigor's
+    # normal dispatch.
+    #
+    # ## Architecture
+    #
+    # One discovery pass per run reads the configured AR model
+    # paths (default `app/models/`) via the plugin's
+    # `IoBoundary`, walks each `.rb` file with Prism, and
+    # collects `has_one_attached :avatar` /
+    # `has_many_attached :photos` macros into an
+    # {AttachmentIndex} keyed by class name. The walker is
+    # stand-alone (mirrors `rigor-activerecord`'s
+    # `ModelDiscoverer`) so the plugin works even when
+    # `rigor-activerecord` is not loaded; when it IS loaded,
+    # the published `:model_index` fact (ADR-9 cross-plugin
+    # API) drives the same class set so the two plugins agree
+    # on what counts as a model.
+    #
+    # ## Configuration
+    #
+    #     plugins:
+    #       - gem: rigor-activerecord  # producer of :model_index
+    #       - gem: rigor-activestorage
+    #         config:
+    #           model_search_paths: ["app/models"]
+    #
+    # `model_search_paths` defaults to `["app/models"]`.
+    #
+    # The class name `Rigor::Plugin::Activestorage` (single
+    # capital A) matches the constant-distinguishing convention
+    # used by `rigor-activerecord`.
+    class Activestorage < Rigor::Plugin::Base
+      manifest(
+        id: "activestorage",
+        version: "0.1.0",
+        description: "Types ActiveStorage attachment macros (has_one_attached / has_many_attached) on AR models.",
+        config_schema: {
+          "model_search_paths" => :array
+        },
+        consumes: [{ plugin_id: "activerecord", name: :model_index, optional: true }]
+      )
+
+      DEFAULT_MODEL_SEARCH_PATHS = ["app/models"].freeze
+
+      # Cached: attachment index. Walks every `.rb` file under
+      # `model_search_paths` for `has_*_attached` macros.
+      producer :attachment_index do |_params|
+        rows = AttachmentDiscoverer.new(
+          io_boundary: io_boundary,
+          search_paths: @model_search_paths
+        ).discover
+        AttachmentIndex.build(rows: rows)
+      end
+
+      def init(_services)
+        @model_search_paths = Array(
+          config.fetch("model_search_paths", DEFAULT_MODEL_SEARCH_PATHS)
+        ).map(&:to_s)
+        @attachment_index = nil
+        @load_errors = []
+      end
+
+      def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
+        index = attachment_index
+        return load_error_diagnostics(path) if index.nil?
+        return [] if index.empty?
+
+        Analyzer.new(path: path, attachment_index: index).analyze(root).diagnostics
+      end
+
+      # Return-type contribution: when the receiver is
+      # `Nominal[Model]` and the method matches a discovered
+      # attachment, narrow to
+      # `Nominal[ActiveStorage::Attached::One]` (singular) or
+      # `Nominal[ActiveStorage::Attached::Many]` (collection).
+      # The chained call (`.attached?`, `.purge`, `.url`)
+      # then resolves through ActiveStorage's RBS surface.
+      # Attachment setters (`user.avatar=`) decline — they
+      # take side-effecting argument types that the RBS
+      # surface already covers.
+      def flow_contribution_for(call_node:, scope:)
+        return nil unless call_node.is_a?(Prism::CallNode)
+        return nil if call_node.receiver.nil?
+        return nil unless call_node.arguments.nil?
+
+        index = attachment_index
+        return nil if index.nil? || index.empty?
+
+        receiver_type = scope.type_of(call_node.receiver)
+        return nil unless receiver_type.is_a?(Rigor::Type::Nominal)
+
+        attachments = index.attachments_for(receiver_type.class_name) ||
+                      index.attachments_for("::#{receiver_type.class_name}")
+        return nil if attachments.nil?
+
+        attachment = attachments.find { |a| a[:name] == call_node.name.to_s }
+        return nil if attachment.nil?
+
+        target = case attachment[:kind]
+                 when :singular then "ActiveStorage::Attached::One"
+                 when :collection then "ActiveStorage::Attached::Many"
+                 end
+        return nil if target.nil?
+
+        Rigor::FlowContribution.new(
+          return_type: Rigor::Type::Combinator.nominal_of(target),
+          provenance: Rigor::FlowContribution::Provenance.new(
+            source_family: "plugin.#{manifest.id}",
+            plugin_id: manifest.id,
+            node: call_node,
+            descriptor: nil
+          )
+        )
+      end
+
+      # @!visibility private
+      def attachment_index_for_spec
+        attachment_index
+      end
+
+      private
+
+      def attachment_index
+        return @attachment_index if @attachment_index
+
+        # Walk first so the IoBoundary's digest list captures
+        # the model file digests before cache_for snapshots.
+        AttachmentDiscoverer.new(
+          io_boundary: io_boundary,
+          search_paths: @model_search_paths
+        ).discover
+        @attachment_index = cache_for(:attachment_index, params: {}).call
+      rescue Plugin::AccessDeniedError => e
+        @load_errors << "rigor-activestorage: #{e.message}"
+        nil
+      rescue StandardError => e
+        @load_errors << "rigor-activestorage: discovery failed: #{e.class}: #{e.message}"
+        nil
+      end
+
+      def load_error_diagnostics(path)
+        @load_errors.uniq.map do |message|
+          Rigor::Analysis::Diagnostic.new(
+            path: path,
+            line: 1,
+            column: 1,
+            message: message,
+            severity: :warning,
+            rule: "load-error"
+          )
+        end
+      end
+    end
+
+    Rigor::Plugin.register(Activestorage)
+  end
+end

data/plugins/rigor-activestorage/lib/rigor-activestorage.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Entry point matching the `rigor-<id>` gem-name convention.
+# The Plugin::Loader's `require_gem!` step calls
+# `require "rigor-activestorage"`, and this file loads the
+# plugin's actual implementation under the `rigor/plugin/`
+# namespace so the require / register pair fires.
+require "rigor/plugin/activestorage"

data/plugins/rigor-activesupport-core-ext/lib/rigor/plugin/activesupport_core_ext.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+module Rigor
+  module Plugin
+    # ADR-25 — a pure RBS-bundle plugin. It ships NO analyzer code:
+    # no `diagnostics_for_file`, no `flow_contribution_for`. Its
+    # whole contribution is the manifest's `signature_paths: ["sig"]`,
+    # which declares the bundled ActiveSupport `core_ext` RBS
+    # directory. `Plugin::Loader` resolves that directory against
+    # this gem's root and `Environment.for_project` merges it into
+    # the RBS environment, so the ActiveSupport core-extension
+    # selectors (`3.days`, `"x".squish`, `Time.current`, …) resolve.
+    #
+    # Activate it like any plugin — no path, no vendoring:
+    #
+    #   # .rigor.yml
+    #   plugins:
+    #     - rigor-activesupport-core-ext
+    #
+    # Coverage scope and rationale: see `README.md` in this gem.
+    class ActivesupportCoreExt < Rigor::Plugin::Base
+      manifest(
+        id: "activesupport-core-ext",
+        # Bumped 2026-05-28 — added Date#midnight /
+        # at_midnight / beginning_of_day / end_of_day (Rails
+        # aliases that return Time, not Date).
+        version: "0.2.0",
+        description: "RBS bundle for the most-frequently-flagged ActiveSupport core_ext extensions.",
+        signature_paths: ["sig"]
+      )
+    end
+
+    Rigor::Plugin.register(ActivesupportCoreExt)
+  end
+end