activemodel-caching 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3e5807404927b4493c98793dc6c099499ab0c4debe20508b48f9f901ccb0c6b7
+  data.tar.gz: aba1ed74fe1f01fa24fe90d6783422ca13a3f4b1b94d20efc9374a187afed52b
+SHA512:
+  metadata.gz: f741d748d3f3580af8524554da1f1146d7762f406bba7279332c36fd097cb5d4f40213a54ab8c097e5c281187d54272600f1eab5d45d855a864177be488083d0
+  data.tar.gz: 5ebfb56ecb0debd6b2afa33ced087e7eefbd36bef5ba39705c32ad8eceff9fcc29fdeefa2c22af0eb0039351b55aac727a402dccf6a9fd565bb2bf845b81bb4c

data/.rubocop.yml

@@ -0,0 +1,29 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/LineLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Style/ClassVars:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-11-13
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Emmanuel Cousin
+
+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,162 @@
+# ActiveModel::Caching
+
+A library providing easy-to-use object-level caching methods for various data types in a Ruby on Rails application, allowing you to cache different attribute types directly on your models.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activemodel-caching'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install activemodel-caching
+```
+
+## Usage
+
+To use the caching methods provided by `ActiveModel::Caching`, include the module in your model and set up the cache store.
+
+### Setup
+
+You can set up a cache store globally in an initializer, for example, in `config/initializers/active_model_caching.rb`:
+
+```ruby
+ActiveModel::Caching.setup do |config|
+  config.cache_store = ActiveSupport::Cache::MemoryStore.new # or any other cache store you prefer
+end
+```
+
+If you're using Rails, you can also default to Rails cache if you prefer:
+```ruby
+ActiveModel::Caching.setup do |config|
+  config.cache_store = Rails.cache
+end
+```
+
+### Basic Usage
+
+To enable caching for an attribute, simply call one of the `cache_*` methods in your model class. Here are the methods you can use:
+
+- `cache_string` - Caches a string value.
+- `cache_integer` - Caches an integer value.
+- `cache_decimal` - Caches a decimal value.
+- `cache_datetime` - Caches a datetime value.
+- `cache_flag` - Caches a boolean flag.
+- `cache_float` - Caches a float value.
+- `cache_enum` - Caches an enumerated value.
+- `cache_json` - Caches a JSON object.
+- `cache_list` - Caches an ordered list with an optional limit.
+- `cache_unique_list` - Caches a unique list with an optional limit.
+- `cache_set` - Caches a unique set with an optional limit.
+- `cache_ordered_set` - Caches an ordered set with an optional limit.
+- `cache_slots` - Caches available "slots" (e.g., seats) with helper methods.
+- `cache_slot` - Caches a single-slot availability.
+- `cache_counter` - Caches a counter that can be incremented and reset.
+- `cache_limiter` - Caches a limited counter, enforcing a maximum count.
+- `cache_hash` - Caches a hash structure.
+- `cache_boolean` - Caches a boolean value.
+
+#### Example
+
+Here’s how you might define a model with various cached attributes:
+
+```ruby
+class User
+  include ActiveModel::Caching
+
+  cache_string :session_token
+  cache_integer :view_count
+  cache_decimal :account_balance
+  cache_datetime :last_login
+  cache_flag :is_active
+  cache_enum :status, %w[active inactive suspended]
+  cache_json :preferences
+  cache_list :recent_searches, limit: 10
+  cache_set :tags, limit: 5
+  cache_slots :seats, available: 100
+  cache_counter :login_count
+  cache_boolean :is_verified
+end
+```
+
+With these, you’ll automatically have generated methods for interacting with the cache.
+
+### Detailed Method Descriptions
+
+- **`cache_string(attribute_name, expires_in: nil)`**: Caches a string attribute.
+  - Example: `cache_string :username`
+
+- **`cache_integer(attribute_name, expires_in: nil)`**: Caches an integer attribute.
+  - Example: `cache_integer :view_count`
+
+- **`cache_decimal(attribute_name, expires_in: nil)`**: Caches a decimal attribute.
+  - Example: `cache_decimal :account_balance`
+
+- **`cache_datetime(attribute_name, expires_in: nil)`**: Caches a datetime attribute.
+  - Example: `cache_datetime :last_login`
+
+- **`cache_flag(attribute_name, expires_in: nil)`**: Caches a boolean flag.
+  - Example: `cache_flag :is_active`
+
+- **`cache_enum(attribute_name, options, expires_in: nil)`**: Caches an enumerated value.
+  - Example: `cache_enum :status, %w[active inactive suspended]`
+
+- **`cache_json(attribute_name, expires_in: nil)`**: Caches a JSON object.
+  - Example: `cache_json :user_preferences`
+
+- **`cache_list(attribute_name, limit: nil, expires_in: nil)`**: Caches an ordered list, with an optional limit.
+  - Example: `cache_list :recent_posts, limit: 5`
+
+- **`cache_set(attribute_name, limit: nil, expires_in: nil)`**: Caches a unique set, with an optional limit.
+  - Example: `cache_set :tags, limit: 10`
+
+- **`cache_slots(attribute_name, available:, expires_in: nil)`**: Caches a set number of slots with helper methods.
+  - Example: `cache_slots :seats, available: 100`
+
+- **`cache_counter(attribute_name, expires_in: nil)`**: Caches a counter.
+  - Example: `cache_counter :login_count`
+
+- **`cache_boolean(attribute_name, expires_in: nil)`**: Caches a boolean value.
+  - Example: `cache_boolean :is_verified`
+
+### Example Methods
+
+For each cached attribute, methods are generated for getting and setting values. For example:
+
+```ruby
+user = User.new
+
+# Cache a string
+user.session_token = "abc123"
+puts user.session_token # => "abc123"
+
+# Increment a counter
+user.increment_login_count
+puts user.login_count # => 1
+
+# Reserve a slot
+if user.available_seats?
+  user.reserve_seats!
+end
+
+# Reset a slot
+user.reset_seats!
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/your-username/active_model-caching](https://github.com/your-username/active_model-caching).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/active_model/caching/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Caching
+    VERSION = "0.1.0"
+  end
+end

data/lib/active_model/caching.rb

@@ -0,0 +1,515 @@
+# frozen_string_literal: true
+
+require_relative "caching/version"
+
+require "base64"
+require "bigdecimal/util"
+require "json"
+require "active_support"
+require "active_support/time"
+
+module ActiveModel
+  # Provides with a set of methods allowing to cache data structures at the object level
+  module Caching
+    mattr_accessor :cache_store
+    @@cache_store = ActiveSupport::Cache::MemoryStore.new
+
+    class << self
+      def setup
+        yield self
+      end
+    end
+
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Caches a string value for the given attribute.
+      #
+      # @param attribute_name [Symbol] the name of the string attribute to cache.
+      # @param expires_in [ActiveSupport::Duration, nil] optional expiration time for the cache entry.
+      #
+      # @example
+      #   cache_string :session_token
+      def cache_string(attribute_name, expires_in: nil)
+        define_method(attribute_name) do
+          cache_store.read(cache_key_for(attribute_name))
+        end
+
+        define_method(:"#{attribute_name}=") do |value|
+          cache_store.write(cache_key_for(attribute_name), value, expires_in: expires_in)
+        end
+
+        attribute_name
+      end
+
+      # Caches an integer value for the given attribute.
+      #
+      # @param attribute_name [Symbol] the name of the integer attribute to cache.
+      # @param expires_in [ActiveSupport::Duration, nil] optional expiration time for the cache entry.
+      #
+      # @example
+      #   cache_integer :view_count
+      def cache_integer(attribute_name, expires_in: nil)
+        define_method(attribute_name) do
+          cache_store.read(cache_key_for(attribute_name)).to_i
+        end
+
+        define_method(:"#{attribute_name}=") do |value|
+          cache_store.write(cache_key_for(attribute_name), value.to_i, expires_in: expires_in)
+        end
+
+        attribute_name
+      end
+
+      # Caches a decimal value for the given attribute.
+      #
+      # @param attribute_name [Symbol] the name of the decimal attribute to cache.
+      # @param expires_in [ActiveSupport::Duration, nil] optional expiration time for the cache entry.
+      #
+      # @example
+      #   cache_decimal :account_balance
+      def cache_decimal(attribute_name, expires_in: nil)
+        define_method(attribute_name) do
+          cache_store.read(cache_key_for(attribute_name)).to_d
+        end
+
+        define_method(:"#{attribute_name}=") do |value|
+          cache_store.write(cache_key_for(attribute_name), value.to_d, expires_in: expires_in)
+        end
+
+        attribute_name
+      end
+
+      # Caches a datetime value for the given attribute.
+      #
+      # @param attribute_name [Symbol] the name of the datetime attribute to cache.
+      # @param expires_in [ActiveSupport::Duration, nil] optional expiration time for the cache entry.
+      #
+      # @example
+      #   cache_datetime :last_login
+      def cache_datetime(attribute_name, expires_in: nil)
+        define_method(attribute_name) do
+          cache_store.read(cache_key_for(attribute_name))&.to_time
+        end
+
+        define_method(:"#{attribute_name}=") do |value|
+          cache_store.write(cache_key_for(attribute_name), value&.to_time, expires_in: expires_in)
+        end
+
+        attribute_name
+      end
+
+      # Caches a flag (boolean) value for the given attribute.
+      #
+      # @param attribute_name [Symbol] the name of the flag attribute to cache.
+      # @param expires_in [ActiveSupport::Duration, nil] optional expiration time for the cache entry.
+      #
+      # @example
+      #   cache_flag :is_active
+      def cache_flag(attribute_name, expires_in: nil)
+        define_method(attribute_name) do
+          cache_store.read(cache_key_for(attribute_name)).present?
+        end
+
+        define_method(:"#{attribute_name}=") do |value|
+          cache_store.write(cache_key_for(attribute_name), !!value, expires_in: expires_in)
+        end
+
+        attribute_name
+      end
+
+      # Caches a float value for the given attribute.
+      #
+      # @param attribute_name [Symbol] the name of the float attribute to cache.
+      # @param expires_in [ActiveSupport::Duration, nil] optional expiration time for the cache entry.
+      #
+      # @example
+      #   cache_float :average_rating
+      def cache_float(attribute_name, expires_in: nil)
+        define_method(attribute_name) do
+          cache_store.read(cache_key_for(attribute_name)).to_f
+        end
+
+        define_method(:"#{attribute_name}=") do |value|
+          cache_store.write(cache_key_for(attribute_name), value.to_f, expires_in: expires_in)
+        end
+
+        attribute_name
+      end
+
+      # Caches an enum value for the given attribute, storing the value among defined options.
+      #
+      # @param attribute_name [Symbol] the name of the enum attribute to cache.
+      # @param options [Array] the list of acceptable values for the enum.
+      # @param expires_in [ActiveSupport::Duration, nil] optional expiration time for the cache entry.
+      #
+      # @example
+      #   cache_enum :status, %w[active inactive suspended]
+      def cache_enum(attribute_name, options, expires_in: nil)
+        define_method(attribute_name) do
+          value = cache_store.read(cache_key_for(attribute_name))
+          options.include?(value) ? value : options.first # Default to first option if invalid
+        end
+
+        define_method(:"#{attribute_name}=") do |value|
+          raise ArgumentError, "Invalid value for #{attribute_name}" unless options.include?(value)
+
+          cache_store.write(cache_key_for(attribute_name), value, expires_in: expires_in)
+        end
+
+        attribute_name
+      end
+
+      # Caches a JSON value for the given attribute.
+      #
+      # @param attribute_name [Symbol] the name of the JSON attribute to cache.
+      # @param expires_in [ActiveSupport::Duration, nil] optional expiration time for the cache entry.
+      #
+      # @example
+      #   cache_json :user_preferences
+      def cache_json(attribute_name, expires_in: nil)
+        define_method(attribute_name) do
+          JSON.parse(cache_store.read(cache_key_for(attribute_name)) || nil.to_json, symbolize_names: true)
+        end
+
+        define_method(:"#{attribute_name}=") do |value|
+          cache_store.write(cache_key_for(attribute_name), value.to_json, expires_in: expires_in)
+        end
+
+        attribute_name
+      end
+
+      # Caches a list of values for the given attribute, maintaining order and enforcing a limit.
+      #
+      # @param attribute_name [Symbol] the name of the list attribute to cache.
+      # @param limit [Integer, nil] optional maximum number of items in the list.
+      # @param expires_in [ActiveSupport::Duration, nil] optional expiration time for the cache entry.
+      #
+      # @example
+      #   cache_list :recent_posts, limit: 5
+      def cache_list(attribute_name, limit: nil, expires_in: nil)
+        define_method(attribute_name) do
+          cache_store.read(cache_key_for(attribute_name)) || []
+        end
+
+        define_method(:"add_to_#{attribute_name}") do |*values|
+          list = send(attribute_name)
+          values.each do |value|
+            list << value
+          end
+          list.shift if limit && list.size > limit # Remove oldest item if limit is exceeded
+          cache_store.write(cache_key_for(attribute_name), list, expires_in: expires_in)
+        end
+
+        define_method(:"remove_from_#{attribute_name}") do |*values|
+          list = send(attribute_name)
+          values.each do |value|
+            list.delete(value)
+          end
+          cache_store.write(cache_key_for(attribute_name), list, expires_in: expires_in)
+        end
+
+        attribute_name
+      end
+
+      # Caches a unique list of values for the given attribute, maintaining uniqueness and enforcing a limit.
+      #
+      # @param attribute_name [Symbol] the name of the unique list attribute to cache.
+      # @param limit [Integer, nil] optional maximum number of items in the list.
+      # @param expires_in [ActiveSupport::Duration, nil] optional expiration time for the cache entry.
+      #
+      # @example
+      #   cache_unique_list :favorite_articles, limit: 10
+      def cache_unique_list(attribute_name, limit: nil, expires_in: nil)
+        define_method(attribute_name) do
+          cache_store.read(cache_key_for(attribute_name)) || []
+        end
+
+        define_method(:"add_to_#{attribute_name}") do |*values|
+          unique_list = Set.new(send(attribute_name))
+          values.each do |value|
+            unique_list.add(value)
+            if limit && unique_list.size > limit
+              oldest_value = unique_list.to_a.shift # Remove the oldest item
+              unique_list.delete(oldest_value)
+            end
+          end
+          cache_store.write(cache_key_for(attribute_name), unique_list.to_a, expires_in: expires_in)
+        end
+
+        define_method(:"remove_from_#{attribute_name}") do |*values|
+          unique_list = send(attribute_name)
+          values.each do |value|
+            unique_list.delete(value)
+          end
+          cache_store.write(cache_key_for(attribute_name), unique_list.to_a, expires_in: expires_in)
+        end
+
+        attribute_name
+      end
+
+      # Caches a set of unique values for the given attribute, maintaining uniqueness and enforcing a limit.
+      #
+      # @param attribute_name [Symbol] the name of the set attribute to cache.
+      # @param limit [Integer, nil] optional maximum number of items in the set.
+      # @param expires_in [ActiveSupport::Duration, nil] optional expiration time for the cache entry.
+      #
+      # @example
+      #   cache_set :tags, limit: 5
+      def cache_set(attribute_name, limit: nil, expires_in: nil)
+        define_method(attribute_name) do
+          Set.new(cache_store.read(cache_key_for(attribute_name)) || [])
+        end
+
+        define_method(:"add_to_#{attribute_name}") do |*values|
+          set = send(attribute_name)
+          values.each do |value|
+            set.add(value)
+            if limit && set.size > limit
+              oldest_value = set.to_a.shift # Remove the oldest item
+              set.delete(oldest_value)
+            end
+          end
+          cache_store.write(cache_key_for(attribute_name), set.to_a, expires_in: expires_in)
+        end
+
+        define_method(:"remove_from_#{attribute_name}") do |*values|
+          set = send(attribute_name)
+          values.each do |value|
+            set.delete(value)
+          end
+          cache_store.write(cache_key_for(attribute_name), set.to_a, expires_in: expires_in)
+        end
+
+        attribute_name
+      end
+
+      # Caches an ordered set of values for the given attribute, maintaining order and enforcing a limit.
+      #
+      # @param attribute_name [Symbol] the name of the ordered set attribute to cache.
+      # @param limit [Integer, nil] optional maximum number of items in the ordered set.
+      # @param expires_in [ActiveSupport::Duration, nil] optional expiration time for the cache entry.
+      #
+      # @example
+      #   cache_ordered_set :recent_views, limit: 10
+      def cache_ordered_set(attribute_name, limit: nil, expires_in: nil)
+        define_method(attribute_name) do
+          Set.new(cache_store.read(cache_key_for(attribute_name)) || [])
+        end
+
+        define_method(:"add_to_#{attribute_name}") do |*values|
+          ordered_set = send(attribute_name)
+          values.each do |value|
+            ordered_set.delete(value)
+            ordered_set.add(value)
+            if limit && ordered_set.size > limit
+              oldest_value = ordered_set.to_a.shift # Remove the oldest item
+              ordered_set.delete(oldest_value)
+            end
+          end
+          cache_store.write(cache_key_for(attribute_name), ordered_set, expires_in: expires_in)
+        end
+
+        define_method(:"remove_from_#{attribute_name}") do |*values|
+          ordered_set = send(attribute_name)
+          values.each do |value|
+            ordered_set.delete(value)
+          end
+          cache_store.write(cache_key_for(attribute_name), ordered_set, expires_in: expires_in)
+        end
+
+        attribute_name
+      end
+
+      ##
+      # Caches a limited number of available "slots" for the given attribute.
+      # Slots represent a count of available resources, such as seats or reservations,
+      # which can be reserved and released. This method generates several helper
+      # methods to manage the slots, including checking availability, reserving a slot,
+      # releasing a slot, and resetting the slots.
+      #
+      # @param attribute_name [Symbol] the name of the slot attribute to cache.
+      # @param available [Integer] the maximum number of available slots.
+      # @param expires_in [ActiveSupport::Duration, nil] optional expiration time for the cache entry.
+      #
+      # @example
+      #   cache_slots :seats, available: 10
+      #
+      # This will generate the following methods:
+      # - `seats`: retrieves the current number of taken slots.
+      # - `available_seats?`: checks if there are any available slots left.
+      # - `reserve_seats!`: reserves a slot if available, incrementing the taken count.
+      # - `release_seats!`: releases a slot, decrementing the taken count.
+      # - `reset_seats!`: resets the count of taken slots to zero.
+      #
+      # @return [Symbol] the name of the attribute.
+      def cache_slots(attribute_name, available:, expires_in: nil)
+        define_method(attribute_name) do
+          cache_store.read(cache_key_for(attribute_name)).to_i
+        end
+
+        define_method(:"available_#{attribute_name}?") do
+          taken = send(attribute_name)
+          taken < available
+        end
+
+        define_method(:"reserve_#{attribute_name}!") do
+          taken = send(attribute_name)
+          if send(:"available_#{attribute_name}?")
+            cache_store.write(cache_key_for(attribute_name), taken + 1, expires_in: expires_in)
+            taken + 1
+          else
+            taken
+          end
+        end
+
+        define_method(:"release_#{attribute_name}!") do
+          taken = send(attribute_name)
+          if taken.positive?
+            cache_store.write(cache_key_for(attribute_name), taken - 1, expires_in: expires_in)
+            taken - 1
+          else
+            taken
+          end
+        end
+
+        define_method(:"reset_#{attribute_name}!") do
+          taken = send(attribute_name)
+          if taken.positive?
+            cache_store.write(cache_key_for(attribute_name), 0, expires_in: expires_in)
+          else
+            taken
+          end
+        end
+
+        attribute_name
+      end
+
+      ##
+      # Caches a single slot for the given attribute.
+      # A single slot represents a binary (available/taken) resource that can be reserved
+      # or released, functioning similarly to {#cache_slots} with a fixed availability of 1.
+      #
+      # @param attribute_name [Symbol] the name of the slot attribute to cache.
+      # @param expires_in [ActiveSupport::Duration, nil] optional expiration time for the cache entry.
+      #
+      # @example
+      #   cache_slot :parking_space
+      #
+      # This will generate the following methods:
+      # - `parking_space`: retrieves the current state (0 or 1).
+      # - `available_parking_space?`: checks if the slot is available.
+      # - `reserve_parking_space!`: reserves the slot if available.
+      # - `release_parking_space!`: releases the slot.
+      # - `reset_parking_space!`: resets the slot to zero (unreserved).
+      #
+      # @return [Symbol] the name of the attribute.
+      def cache_slot(attribute_name, expires_in: nil)
+        cache_slots(attribute_name, available: 1, expires_in: expires_in)
+        attribute_name
+      end
+
+      # Caches a counter value for the given attribute.
+      #
+      # @param attribute_name [Symbol] the name of the counter attribute to cache.
+      # @param expires_in [ActiveSupport::Duration, nil] optional expiration time for the cache entry.
+      #
+      # @example
+      #   cache_counter :login_count
+      def cache_counter(attribute_name, expires_in: nil)
+        define_method(attribute_name) do
+          cache_store.read(cache_key_for(attribute_name)).to_i
+        end
+
+        define_method(:"increment_#{attribute_name}") do
+          new_value = send(attribute_name) + 1
+          cache_store.write(cache_key_for(attribute_name), new_value, expires_in: expires_in)
+        end
+
+        define_method(:"reset_#{attribute_name}") do
+          cache_store.write(cache_key_for(attribute_name), 0, expires_in: expires_in)
+        end
+
+        attribute_name
+      end
+
+      # Caches a limiter value for the given attribute, enforcing a limit.
+      #
+      # @param attribute_name [Symbol] the name of the limiter attribute to cache.
+      # @param limit [Integer] the maximum allowed count.
+      # @param expires_in [ActiveSupport::Duration, nil] optional expiration time for the cache entry.
+      #
+      # @example
+      #   cache_limiter :api_requests, limit: 100
+      def cache_limiter(attribute_name, limit:, expires_in: nil)
+        define_method(attribute_name) do
+          cache_store.read(cache_key_for(attribute_name)).to_i
+        end
+
+        define_method(:"increment_#{attribute_name}") do
+          current_value = send(attribute_name)
+          new_value = current_value + 1
+
+          if new_value <= limit
+            cache_store.write(cache_key_for(attribute_name), new_value, expires_in: expires_in)
+            true # Increment successful
+          else
+            false # Increment failed due to limit
+          end
+        end
+
+        define_method(:"reset_#{attribute_name}") do
+          cache_store.write(cache_key_for(attribute_name), 0, expires_in: expires_in)
+        end
+
+        attribute_name
+      end
+
+      # Caches a hash for the given attribute.
+      #
+      # @param attribute_name [Symbol] the name of the hash attribute to cache.
+      # @param expires_in [ActiveSupport::Duration, nil] optional expiration time for the cache entry.
+      #
+      # @example
+      #   cache_hash :user_settings
+      def cache_hash(attribute_name, expires_in: nil)
+        define_method(attribute_name) do
+          JSON.parse(cache_store.read(cache_key_for(attribute_name)) || "{}", symbolize_names: true)
+        end
+
+        define_method(:"#{attribute_name}=") do |value|
+          cache_store.write(cache_key_for(attribute_name), value.to_json, expires_in: expires_in)
+        end
+
+        attribute_name
+      end
+
+      # Caches a boolean value for the given attribute.
+      #
+      # @param attribute_name [Symbol] the name of the boolean attribute to cache.
+      # @param expires_in [ActiveSupport::Duration, nil] optional expiration time for the cache entry.
+      #
+      # @example
+      #   cache_boolean :is_verified
+      def cache_boolean(attribute_name, expires_in: nil)
+        define_method(attribute_name) do
+          cache_store.read(cache_key_for(attribute_name)).present?
+        end
+
+        define_method(:"#{attribute_name}=") do |value|
+          cache_store.write(cache_key_for(attribute_name), !!value, expires_in: expires_in)
+        end
+      end
+    end
+
+    private
+
+    # Generates a cache key for the given attribute.
+    #
+    # @param attribute_name [Symbol] the name of the attribute.
+    # @return [String] the generated cache key.
+    def cache_key_for(attribute_name)
+      to_global_id(attribute_name: attribute_name)
+    end
+  end
+end

data/lib/activemodel/caching.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "active_model/caching"

data/sig/activemodel/caching.rbs

@@ -0,0 +1,6 @@
+module ActiveModel
+  module Caching
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: activemodel-caching
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Emmanuel Cousin
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-11-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.2
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: globalid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: ActiveModel::Caching is a versatile gem for managing structured, temporary
+  data using a caching backend, typically Rails cache for Rails applications. This
+  gem provides an easy-to-use API for storing, retrieving, and manipulating data structures
+  like scalars, lists, and JSON, making it simple to handle transient data without
+  adding extra dependencies.
+email:
+- emmanuel@hey.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/active_model/caching.rb
+- lib/active_model/caching/version.rb
+- lib/activemodel/caching.rb
+- sig/activemodel/caching.rbs
+homepage: https://github.com/EmCousin/activemodel-caching
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/EmCousin/activemodel-caching
+  source_code_uri: https://github.com/EmCousin/activemodel-caching
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.20
+signing_key:
+specification_version: 4
+summary: ActiveModel::Caching is a flexible gem for managing temporary data structures
+  (scalars, lists, JSON) using a caching backend, typically Rails cache but adaptable
+  to other solutions. It offers a simple, Rails-friendly API for efficient, transient
+  data handling.
+test_files: []