muninn 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dfeee41c42813ad108e5e2611e2a392f01959f64bcbebd4ba25c7502749a2723
+  data.tar.gz: 91f9a92ac38d099c573548537c61a45cd3691bba4f4b3c3566fa2af818ff5184
+SHA512:
+  metadata.gz: c09a47e4e863d379b6cded5c0d1b7073a69ebdc23ade2627a122e0a320b8f9bf26f3543f7160fe63ca7f6f7ef62b09630d206929631311135109e47cd027ed42
+  data.tar.gz: 86b13369400bc89676f14c9a70409444378fa0502bb1293c2929ccc5bf0135c84565445e7de31b08cac815b5325b8468cab2d0a4cf7fe5f40eeba6c31e86e5f5

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 0.1.0 (2026-06-23)
+
+- Initial release
+- VersionCounter: Redis-based version counters (get/bump)
+- KeyBuilder: SHA256 cache key construction with fingerprint, deps, mode
+- Invalidation: Declarative model concern for automatic cache invalidation
+- Caching: Controller concern for HTTP response caching
+- GlobalInvalidationJob: Async job for cross-tenant invalidation
+- Railtie: Automatic inclusion in ActiveRecord and ActionController

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,171 @@
+<p align="center">
+  <img src="logo.png" alt="Muninn" width="200">
+</p>
+
+<h1 align="center">Muninn</h1>
+
+<p align="center">
+  <em>Versioned cache invalidation for Rails via Redis counters.</em><br>
+  No TTL guessing — cache is invalidated automatically when data changes.
+</p>
+
+## How it works
+
+Muninn maintains monotonically incrementing version counters in Redis. Each cache key includes the current version number. When a record is created/updated/deleted, the relevant counter is bumped, the cache key changes, and stale data is never served.
+
+## Installation
+
+```ruby
+gem "muninn"
+```
+
+## Configuration
+
+```ruby
+# config/initializers/muninn.rb
+Muninn.configure do |config|
+  config.redis = Redis.new(url: ENV["REDIS_URL"])
+
+  # Scope resolver (e.g., Current.tenant, current_corretora)
+  config.current_scope_id = -> { Current.tenant&.id }
+
+  # Optional — user fingerprint to differentiate cache per user
+  config.current_user_id = -> { Current.user&.id }
+
+  # Optional — required only if using invalidates_namespace_globally
+  config.all_scope_ids = -> { Tenant.pluck(:id) }
+
+  # Optional — TTL for Redis version counters (default: nil = no expiry)
+  config.version_ttl = 7.days
+
+  # Optional — race_condition_ttl for cache writes (default: 10 seconds)
+  config.race_condition_ttl = 15
+end
+```
+
+## Railtie (automatic include)
+
+Muninn's Railtie automatically includes `Muninn::Cache::Invalidation` in all `ActiveRecord::Base` models and `Muninn::Cache::Caching` in all `ActionController::Base` controllers. You **do not** need to add `include` statements unless you want to opt in selectively. If you prefer manual control, remove the Railtie or skip auto-include.
+
+## Model Invalidation
+
+```ruby
+class Listing < ApplicationRecord
+  # Invalidation is auto-included via Railtie
+  # If not using Railtie: include Muninn::Cache::Invalidation
+
+  invalidates_namespace "listings"                                           # scope: tenant-wide
+  invalidates_namespace "listings", scope_name: "entity", scope_id: :id      # scope: individual record
+
+  # Cascade invalidation to parent
+  invalidates_namespace "bookings", scope_id: ->(r) { r.booking&.tenant_id }
+
+  # Polymorphic parent
+  invalidates_polymorphic_parent :reviewable
+
+  # Global (across all tenants, async via ActiveJob)
+  invalidates_namespace_globally "amenities"
+end
+```
+
+## Controller Caching
+
+```ruby
+class ListingsController < ApplicationController
+  # Caching is auto-included via Railtie
+  # If not using Railtie: include Muninn::Cache::Caching
+
+  cache_defaults expires_in: 5.minutes
+
+  cache_action :index,
+    allowed_params: %i[city_id checkin guests page]
+
+  cache_action :show, mode: "entity"
+
+  cache_action :search,
+    allowed_params: %i[query city_id page],
+    deps_extractor: ->(params) {
+      params[:city_id].present? ? { "search_results" => params[:city_id] } : {}
+    }
+
+  # Cache per user (default: false — cache is shared within the scope)
+  cache_action :profile, per_user: true
+end
+```
+
+## Architecture
+
+```
+Request → cache_response (around_action)
+  ├── VersionCounter.get(namespace, scope)       → current version
+  ├── KeyBuilder.fingerprint_from_params(params) → SHA256 fingerprint
+  │     (Rails internal params automatically filtered)
+  ├── KeyBuilder.build(namespace, scope, ...)    → SHA256 cache key
+  ├── Rails.cache.read(key)                      → HIT? render cached
+  └── MISS? yield → Rails.cache.write(key, response) (only on 200)
+
+Model.save → after_commit :bump_cache_namespaces
+  └── VersionCounter.bump(namespace, scope)      → Redis INCR (atomic pipeline)
+```
+
+## DSL Reference
+
+| Method | Description |
+|---|---|
+| `invalidates_namespace` | Bump a version counter on save |
+| `invalidates_polymorphic_parent` | Bump parent's counter via polymorphic association |
+| `invalidates_namespace_globally` | Bump counter across all scopes (async, batched) |
+| `cache_action` | Enable response caching for a controller action |
+| `cache_defaults` | Set default options for all cached actions |
+
+### `cache_action` options
+
+| Option | Default | Description |
+|---|---|---|
+| `expires_in` | `nil` | Cache TTL |
+| `allowed_params` | `[]` | Whitelist of params in fingerprint |
+| `mode` | `"list"` | Cache mode: `"list"`, `"entity"`, or custom |
+| `per_user` | `false` | Include `user_id` in cache key |
+| `version_namespace` | `controller_name` | Version counter namespace |
+| `deps_extractor` | `nil` | Lambda to extract dependency versions |
+| `race_condition_ttl` | `10` | Stale cache serving window |
+
+### Configuration options
+
+| Option | Default | Description |
+|---|---|---|
+| `redis` | required | Redis client instance |
+| `current_scope_id` | `nil` | Current tenant/client scope ID (lambda) |
+| `current_user_id` | `nil` | Current user ID for per-user cache (lambda) |
+| `all_scope_ids` | `[]` | All scope IDs for global invalidation (lambda) |
+| `default_scope_name` | `"default"` | Default scope column name |
+| `version_ttl` | `nil` | TTL for Redis version counters (nil = no expiry) |
+| `race_condition_ttl` | `10` | Seconds to serve stale cache during regeneration |
+
+## Instrumentation
+
+Muninn emits `ActiveSupport::Notifications` events for observability:
+
+| Event | Payload | Fires |
+|---|---|---|
+| `cache_hit.muninn` | `key`, `action` | Cache HIT in controller |
+| `cache_miss.muninn` | `key`, `action` | Cache MISS in controller |
+| `cache_write.muninn` | `key`, `action` | Cache write on 200 response |
+| `version_counter.get.muninn` | `namespace`, `scope_name`, `scope_id` | Version read |
+| `version_counter.bump.muninn` | `namespace`, `scope_name`, `scope_id` | Version increment |
+| `invalidation.bump.muninn` | `namespace`, `scope_name`, `scope_id` | Model invalidation |
+| `invalidation.global.muninn` | `namespaces`, `scope_name` | Global invalidation triggered |
+
+```ruby
+ActiveSupport::Notifications.subscribe(/\.muninn/) do |event|
+  Rails.logger.info "[Muninn] #{event.name}: #{event.payload.inspect}"
+end
+```
+
+## Error handling
+
+If Redis is unavailable, Muninn logs a warning via `Rails.logger` and falls back to uncached behavior (requests pass through normally).
+
+## License
+
+MIT

data/lib/muninn/cache/caching.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Muninn
+  module Cache
+    module Caching
+      extend ActiveSupport::Concern
+
+      RAILS_INTERNAL_PARAMS = %w[controller action format _method authenticity_token].freeze
+
+      included do
+        class_attribute :cache_defaults_config, default: {}
+        class_attribute :cacheable_actions, default: {}
+        around_action :cache_response
+      end
+
+      class_methods do
+        def cache_defaults(**opts)
+          self.cache_defaults_config = cache_defaults_config.merge(opts)
+        end
+
+        def cache_action(action_name, **opts)
+          config = cache_defaults_config.merge(opts)
+          self.cacheable_actions = cacheable_actions.merge(action_name.to_s => config)
+        end
+      end
+
+      private
+
+      def cache_response
+        config = self.class.cacheable_actions[action_name]
+        return yield unless config
+
+        version_scope = cache_scope
+        resolved_mode = resolved_mode(config)
+
+        if resolved_mode == "entity" && params[:id].present?
+          version_scope = { scope_name: "entity", scope_id: params[:id] }
+        end
+
+        fingerprint = KeyBuilder.fingerprint_from_params(
+          params: cache_params_payload,
+          allowed_keys: config[:allowed_params] || [],
+          context: fingerprint_context(version_scope)
+        )
+
+        identity_namespace = "#{controller_name}_#{action_name}"
+        version_namespace = config[:version_namespace] || controller_name
+
+        version = VersionCounter.get(
+          namespace: version_namespace,
+          scope_name: version_scope[:scope_name],
+          scope_id: version_scope[:scope_id]
+        )
+
+        entity_id = params[:id] if resolved_mode == "entity" && params[:id].present?
+
+        key = KeyBuilder.build(
+          namespace: identity_namespace,
+          scope: version_scope,
+          version: version,
+          deps: config[:deps_extractor]&.call(cache_params_payload) || {},
+          fingerprint: fingerprint,
+          mode: resolved_mode,
+          entity_id: entity_id
+        )
+
+        cached = Rails.cache.read(key)
+        if cached
+          Muninn.instrument("cache_hit", key: key, action: action_name)
+          render json: cached and return
+        end
+
+        Muninn.instrument("cache_miss", key: key, action: action_name)
+        yield
+
+        return unless response.status == 200
+
+        Muninn.instrument("cache_write", key: key, action: action_name)
+        Rails.cache.write(key, response_body_json, expires_in: config[:expires_in])
+      rescue Redis::BaseError => e
+        Rails.logger.warn "[Muninn] Redis error in cache_response: #{e.message}"
+        yield unless performed?
+      end
+
+      def cache_scope
+        { scope_name: Muninn.configuration.default_scope_name, scope_id: Muninn.current_scope_id }
+      end
+
+      def fingerprint_context(scope)
+        context = { scope_id: scope[:scope_id] }
+        config = self.class.cacheable_actions[action_name] || {}
+        context[:user_id] = Muninn.current_user_id if config[:per_user]
+        context.compact
+      end
+
+      def resolved_mode(config)
+        if config.key?(:mode)
+          config[:mode]
+        elsif action_name == "show"
+          "entity"
+        else
+          "list"
+        end
+      end
+
+      def cache_params_payload
+        payload = if params.respond_to?(:to_unsafe_h)
+                    params.to_unsafe_h
+                  else
+                    request.request_parameters
+                  end
+        payload.except(*RAILS_INTERNAL_PARAMS)
+      end
+
+      def response_body_json
+        JSON.parse(response.body)
+      end
+    end
+  end
+end

data/lib/muninn/cache/global_invalidation_job.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Muninn
+  module Cache
+    class GlobalInvalidationJob < ActiveJob::Base
+      queue_as :default
+
+      BATCH_SIZE = 100
+
+      def perform(namespaces, scope_name)
+        ids = Muninn.all_scope_ids
+        expires_in = Muninn.configuration.version_ttl
+        ids.each_slice(BATCH_SIZE) do |batch|
+          batch.each do |scope_id|
+            namespaces.each do |ns|
+              VersionCounter.bump(
+                namespace: ns,
+                scope_name: scope_name,
+                scope_id: scope_id,
+                expires_in: expires_in
+              )
+            end
+          end
+        end
+      rescue Redis::BaseError => e
+        Rails.logger.warn "[Muninn] Redis error in GlobalInvalidationJob: #{e.message}"
+      end
+    end
+  end
+end

data/lib/muninn/cache/invalidation.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Muninn
+  module Cache
+    module Invalidation
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :cache_namespace_rules, default: []
+        class_attribute :cache_invalidation_callback_set, default: false
+      end
+
+      class_methods do
+        def invalidates_namespace(*names, scope_name: nil, scope_id: nil)
+          scope_name ||= Muninn.configuration.default_scope_name
+          rules = names.map do |namespace|
+            { namespace: namespace.to_s, scope_name: scope_name.to_s, scope_id: scope_id }
+          end
+          self.cache_namespace_rules += rules
+          setup_cache_callback
+        end
+
+        def invalidates_polymorphic_parent(association_name, namespaces: nil, scope_name: nil)
+          scope_name ||= Muninn.configuration.default_scope_name
+          self.cache_namespace_rules += [{
+            polymorphic_parent: association_name.to_s,
+            namespaces: namespaces,
+            scope_name: scope_name.to_s
+          }]
+          setup_cache_callback
+        end
+
+        def invalidates_namespace_globally(*names, scope_name: nil)
+          scope_name ||= Muninn.configuration.default_scope_name
+          self.cache_namespace_rules += [{
+            global: true,
+            namespaces: names.map(&:to_s),
+            scope_name: scope_name.to_s
+          }]
+          setup_cache_callback
+        end
+
+        private
+
+        def setup_cache_callback
+          return if cache_invalidation_callback_set
+          self.cache_invalidation_callback_set = true
+          after_commit :bump_cache_namespaces
+        end
+      end
+
+      private
+
+      def bump_cache_namespaces
+        self.class.cache_namespace_rules.each do |rule|
+          if rule[:polymorphic_parent]
+            bump_polymorphic_parent(rule)
+          elsif rule[:global]
+            bump_global_namespace(rule)
+          else
+            bump_single_namespace(rule)
+          end
+        end
+      rescue Redis::BaseError => e
+        Rails.logger.warn "[Muninn] Redis error in bump_cache_namespaces: #{e.message}"
+      end
+
+      def bump_single_namespace(rule)
+        scope_id = resolve_scope_id(rule[:scope_id], rule[:scope_name])
+        return if scope_id.blank?
+
+        Muninn.instrument("invalidation.bump", namespace: rule[:namespace], scope_name: rule[:scope_name], scope_id: scope_id) do
+          VersionCounter.bump(
+            namespace: rule[:namespace],
+            scope_name: rule[:scope_name],
+            scope_id: scope_id,
+            expires_in: Muninn.configuration.version_ttl
+          )
+        end
+      end
+
+      def bump_polymorphic_parent(rule)
+        parent = send(rule[:polymorphic_parent])
+        return unless parent
+
+        base = parent.class.model_name.route_key
+        namespaces = rule[:namespaces] || [base]
+
+        scope_id_field = "#{rule[:scope_name]}_id"
+        scope_id = parent.respond_to?(scope_id_field) ? parent.send(scope_id_field) : nil
+        return if scope_id.blank?
+
+        namespaces.each do |ns|
+          Muninn.instrument("invalidation.bump", namespace: ns, scope_name: rule[:scope_name], scope_id: scope_id) do
+            VersionCounter.bump(
+              namespace: ns,
+              scope_name: rule[:scope_name],
+              scope_id: scope_id,
+              expires_in: Muninn.configuration.version_ttl
+            )
+          end
+        end
+      end
+
+      def bump_global_namespace(rule)
+        Muninn.instrument("invalidation.global", namespaces: rule[:namespaces], scope_name: rule[:scope_name])
+        GlobalInvalidationJob.perform_later(rule[:namespaces], rule[:scope_name])
+      end
+
+      def resolve_scope_id(scope_id, scope_name = nil)
+        if scope_id.nil?
+          return send("#{scope_name}_id") if scope_name && respond_to?("#{scope_name}_id")
+          return Muninn.current_scope_id if scope_name == Muninn.configuration.default_scope_name
+          return nil
+        end
+        return scope_id.call(self) if scope_id.respond_to?(:call)
+        return send(scope_id) if scope_id.is_a?(Symbol) && respond_to?(scope_id)
+        scope_id
+      end
+    end
+  end
+end

data/lib/muninn/cache/key_builder.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+
+module Muninn
+  module Cache
+    class KeyBuilder
+      def self.build(namespace:, scope:, deps: {}, fingerprint: nil, version: nil, mode: nil, entity_id: nil)
+        scope_name = scope.fetch(:scope_name)
+        scope_id = scope.fetch(:scope_id)
+        version ||= VersionCounter.get(namespace: namespace, scope_name: scope_name, scope_id: scope_id)
+        deps_versioned = build_deps(deps)
+        parts = []
+        parts << "scope:#{scope_name}:#{scope_id}"
+        parts << "namespace:#{namespace}"
+        parts << "entity:#{entity_id}" if entity_id
+        parts << "mode:#{mode}" if mode
+        parts << "deps:#{deps_versioned}" if deps_versioned
+        parts << "fingerprint:#{fingerprint}" if fingerprint
+        parts << "version:#{version}"
+        canonical = parts.join(":")
+        "cache:#{Digest::SHA256.hexdigest(canonical)}"
+      end
+
+      def self.fingerprint_from_params(params:, allowed_keys: [], context: {})
+        payload = normalize_payload(params, allowed_keys: allowed_keys).merge(context)
+        Digest::SHA256.hexdigest(JSON.generate(payload))
+      end
+
+      def self.normalize_payload(params, allowed_keys: [])
+        data = params || {}
+        data = data.to_h if data.respond_to?(:to_h)
+        data = data.deep_symbolize_keys if data.respond_to?(:deep_symbolize_keys)
+        allowed = allowed_keys.map(&:to_sym)
+        data = data.slice(*allowed) if allowed.any?
+        normalize_value(data)
+      end
+
+      def self.normalize_value(value)
+        case value
+        when Hash
+          value.keys.sort.each_with_object({}) do |key, acc|
+            acc[key] = normalize_value(value[key])
+          end
+        when Array
+          value.map { |item| normalize_value(item) }.sort_by { |item| item.to_s }
+        else
+          value
+        end
+      end
+
+      def self.build_deps(deps, scope_name: "entity")
+        return nil if deps.nil? || deps.empty?
+
+        deps.map do |namespace, id|
+          version = VersionCounter.get(namespace: namespace, scope_name: scope_name, scope_id: id)
+          "#{namespace}:#{id}:v#{version}"
+        end.sort.join("|")
+      end
+    end
+  end
+end

data/lib/muninn/cache/version_counter.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Muninn
+  module Cache
+    class VersionCounter
+      KEY_PREFIX = "cache:version".freeze
+
+      def self.get(namespace:, scope_name:, scope_id:)
+        Muninn.instrument("version_counter.get", namespace: namespace, scope_name: scope_name, scope_id: scope_id) do
+          Muninn.redis.get(build_key(namespace: namespace, scope_name: scope_name, scope_id: scope_id))
+        end&.then { |v| v ? v.to_i : 0 }.to_i
+      rescue Redis::BaseError => e
+        Rails.logger.warn "[Muninn] Redis error in VersionCounter.get: #{e.message}"
+        0
+      end
+
+      def self.bump(namespace:, scope_name:, scope_id:, expires_in: nil)
+        Muninn.instrument("version_counter.bump", namespace: namespace, scope_name: scope_name, scope_id: scope_id) do
+          key = build_key(namespace: namespace, scope_name: scope_name, scope_id: scope_id)
+
+          if expires_in
+            results = Muninn.redis.pipelined do |pipe|
+              pipe.incr(key)
+              pipe.expire(key, expires_in)
+            end
+            results.first
+          else
+            Muninn.redis.incr(key)
+          end
+        end
+      rescue Redis::BaseError => e
+        Rails.logger.warn "[Muninn] Redis error in VersionCounter.bump: #{e.message}"
+        nil
+      end
+
+      def self.build_key(namespace:, scope_name:, scope_id:)
+        [KEY_PREFIX, scope_name, scope_id, namespace].join(":")
+      end
+    end
+  end
+end

data/lib/muninn/cache.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Muninn
+  module Cache
+  end
+end
+
+require_relative "cache/version_counter"
+require_relative "cache/key_builder"
+require_relative "cache/invalidation"
+require_relative "cache/caching"
+require_relative "cache/global_invalidation_job"

data/lib/muninn/configuration.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Muninn
+  class Configuration
+    attr_accessor :redis, :version_ttl, :race_condition_ttl
+    attr_writer :current_scope_id, :current_user_id, :all_scope_ids, :default_scope_name
+
+    def default_scope_name
+      @default_scope_name || "default"
+    end
+
+    def current_scope_id
+      @current_scope_id&.call
+    end
+
+    def current_user_id
+      @current_user_id&.call
+    end
+
+    def all_scope_ids
+      @all_scope_ids&.call || []
+    end
+
+    def race_condition_ttl
+      @race_condition_ttl || 10
+    end
+  end
+end

data/lib/muninn/railtie.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Muninn
+  class Railtie < Rails::Railtie
+    initializer "muninn.configure" do |app|
+      ActiveSupport.on_load(:active_record) do
+        include Muninn::Cache::Invalidation
+      end
+
+      ActiveSupport.on_load(:action_controller) do
+        include Muninn::Cache::Caching
+      end
+    end
+  end
+end

data/lib/muninn/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Muninn
+  VERSION = "0.1.0"
+end

data/lib/muninn.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "redis"
+require "active_support"
+require "active_support/concern"
+require "active_support/notifications"
+require "active_job"
+
+module Muninn
+  NAMESPACE = "muninn"
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def redis
+      configuration.redis
+    end
+
+    def current_scope_id
+      configuration.current_scope_id
+    end
+
+    def current_user_id
+      configuration.current_user_id
+    end
+
+    def all_scope_ids
+      configuration.all_scope_ids
+    end
+
+    def instrument(event, payload = {})
+      ActiveSupport::Notifications.instrument("#{event}.#{NAMESPACE}", payload) do
+        yield if block_given?
+      end
+    end
+  end
+end
+
+require_relative "muninn/version"
+require_relative "muninn/configuration"
+require_relative "muninn/cache"
+require_relative "muninn/railtie" if defined?(Rails::Railtie)

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: muninn
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kayky Marcelo
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Declarative cache invalidation for ActiveRecord models and ActionController
+  responses using Redis version counters. No TTL guessing — cache is invalidated automatically
+  when data changes.
+email:
+- kaykymarcelo2411@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/muninn.rb
+- lib/muninn/cache.rb
+- lib/muninn/cache/caching.rb
+- lib/muninn/cache/global_invalidation_job.rb
+- lib/muninn/cache/invalidation.rb
+- lib/muninn/cache/key_builder.rb
+- lib/muninn/cache/version_counter.rb
+- lib/muninn/configuration.rb
+- lib/muninn/railtie.rb
+- lib/muninn/version.rb
+- logo.png
+homepage: https://github.com/KaykyM2411/muninn
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/KaykyM2411/muninn
+  source_code_uri: https://github.com/KaykyM2411/muninn
+  changelog_uri: https://github.com/KaykyM2411/muninn/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Versioned cache invalidation via Redis counters for Rails
+test_files: []