mudis-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3bfa9942e1a544cbccc6beccddfef7ebc1cd4a45efcea25169a8dcf8431dbb17
+  data.tar.gz: 8e881b4869355fb3bb80d10ad30498ff4ae86b2ac0fa2e622b4246eabb936b83
+SHA512:
+  metadata.gz: 517ac684b354633e78dc2c5518373cfbe4e7ddf6ae4ba334318f8723c10ca81e1a11209ab51934d36cbbed13230f3e4ea7134cd034095e1d727b256486b969dc
+  data.tar.gz: 6b542052a56b0d3ddedefda58a53756e67c677eb985b6c5b77507856fea69a917f0e7379d93bf516824e6e1a80e8777048da9fb432016076430958ec4f7f3d68

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kiebor81
+
+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,136 @@
+[![RubyMine](https://www.elegantobjects.org/rubymine.svg)](https://www.jetbrains.com/ruby/)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+# Mudis-Rails
+
+A small Rails plugin for [Mudis](https://github.com/kiebor81/mudis) that gives you a one-command install and an optional Rails cache store wrapper.
+
+## Install
+
+Add to your Gemfile:
+
+```ruby
+gem "mudis"
+gem "mudis-rails"
+```
+
+Then install the initializer:
+
+```bash
+bin/rails g mudis:install
+```
+
+## Quickstart
+
+The generator creates `config/initializers/mudis.rb` with sensible defaults:
+
+```ruby
+require "mudis"
+require "mudis-rails"
+
+Mudis::Rails.install(
+  use_as_cache_store: true,
+  cache_store_options: { namespace: "mudis" },
+  mudis_options: {
+    serializer: JSON,
+    compress: true,
+    max_value_bytes: 2_000_000,
+    hard_memory_limit: true,
+    max_bytes: 1_073_741_824,
+    eviction_threshold: 0.9
+  }
+)
+```
+
+This will:
+
+- Configure Mudis using `mudis_options`.
+- Start the expiry thread.
+- Stop the expiry thread at shutdown.
+- Wire `Rails.cache` to a `Mudis::Rails::Store` wrapper if `use_as_cache_store` is true.
+
+## IPC Mode (Puma)
+
+IPC is configured from `config/puma.rb`, not a Rails initializer. The plugin provides helpers that match the Mudis README flow:
+
+```ruby
+# config/puma.rb
+preload_app!
+
+before_fork do
+  require "mudis-rails"
+
+  Mudis::Rails.puma_before_fork!(
+    mudis_options: {
+      serializer: JSON,
+      compress: true,
+      max_value_bytes: 2_000_000,
+      hard_memory_limit: true,
+      max_bytes: 1_073_741_824
+    }
+  )
+end
+
+on_worker_boot do
+  require "mudis-rails"
+
+  Mudis::Rails.puma_on_worker_boot!(proxy: true)
+end
+```
+
+Notes:
+
+- `puma_before_fork!` starts the expiry thread and `MudisServer`.
+- `puma_on_worker_boot!` creates `$mudis` and optionally requires `mudis_proxy`.
+
+## Persistence
+
+If you enable Mudis persistence, you can auto-load the snapshot on boot:
+
+```ruby
+Mudis::Rails.install(
+  persistence_load_on_boot: true,
+  mudis_options: {
+    persistence_enabled: true,
+    persistence_path: "tmp/mudis_snapshot.dump",
+    persistence_format: :marshal,
+    persistence_safe_write: true
+  }
+)
+```
+
+## Manual Install
+
+If you prefer to control configuration in your own initializer:
+
+```ruby
+Mudis::Rails.configure do |c|
+  c.enabled = true
+  c.use_as_cache_store = true
+  c.override_cache_store = false
+  c.cache_store_options = { namespace: "mudis" }
+  c.mudis_options = {
+    serializer: JSON,
+    compress: true,
+    max_bytes: 512 * 1024 * 1024
+  }
+  c.persistence_load_on_boot = false
+end
+
+Mudis::Rails.install
+```
+
+## Compatibility
+
+Mudis Core   Plugin Version   Status
+>= 0.9       0.1.x            Supported
+
+## Notes
+
+- The plugin does not auto-install on `require`. Use the generator or call `Mudis::Rails.install` explicitly.
+- If you already set `config.cache_store`, `Mudis::Rails.install` will not override it unless `override_cache_store` is true.
+
+## License
+
+MIT

data/lib/generators/mudis/install/templates/mudis.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "mudis"
+require "mudis-rails"
+
+Mudis::Rails.install(
+  use_as_cache_store: true,
+  cache_store_options: {
+    namespace: "mudis"
+  },
+  # persistence_load_on_boot: true,
+  mudis_options: {
+    serializer: JSON,
+    compress: true,
+    max_value_bytes: 2_000_000,
+    hard_memory_limit: true,
+    max_bytes: 1_073_741_824,
+    eviction_threshold: 0.9
+  }
+)

data/lib/generators/mudis/install_generator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module Mudis
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("install/templates", __dir__)
+      desc "Creates a Mudis initializer."
+
+      def copy_initializer
+        template "mudis.rb", "config/initializers/mudis.rb"
+      end
+    end
+  end
+end

data/lib/mudis/rails/config.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Mudis
+  module Rails
+    class Config
+      attr_accessor :enabled,
+                    :auto_install,
+                    :auto_start_expiry_thread,
+                    :expiry_thread_interval,
+                    :auto_stop_expiry_thread,
+                    :use_as_cache_store,
+                    :override_cache_store,
+                    :cache_store_options,
+                    :mudis_options,
+                    :ipc_proxy,
+                    :persistence_load_on_boot
+
+      def initialize
+        @enabled = true
+        @auto_install = false
+        @auto_start_expiry_thread = true
+        @expiry_thread_interval = 60
+        @auto_stop_expiry_thread = true
+        @use_as_cache_store = false
+        @override_cache_store = false
+        @cache_store_options = {}
+        @mudis_options = {}
+        @ipc_proxy = true
+        @persistence_load_on_boot = false
+      end
+    end
+  end
+end

data/lib/mudis/rails/railtie.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+class Mudis
+  module Rails
+    class Railtie < ::Rails::Railtie
+      initializer "mudis-rails.install", after: :load_config_initializers do
+        next unless Mudis::Rails.config.auto_install
+
+        Mudis::Rails.install
+      end
+    end
+  end
+end

data/lib/mudis/rails/store.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "active_support/cache"
+
+class Mudis
+  module Rails
+    class Store < ::ActiveSupport::Cache::Store
+      def initialize(options = nil)
+        options ||= {}
+        @mudis = options.delete(:mudis) || ::Mudis
+        super(options)
+      end
+
+      def read_entry(key, **options)
+        ns = options[:namespace]
+        key = denamespaced_key(key, ns)
+        value = @mudis.read(key, namespace: ns)
+        return if value.nil?
+
+        ::ActiveSupport::Cache::Entry.new(value, expires_in: options[:expires_in], version: options[:version])
+      end
+
+      def write_entry(key, entry, **options)
+        ns = options[:namespace]
+        key = denamespaced_key(key, ns)
+        @mudis.write(key, entry.value, expires_in: options[:expires_in], namespace: ns)
+        true
+      end
+
+      def delete_entry(key, **options)
+        ns = options[:namespace]
+        key = denamespaced_key(key, ns)
+        @mudis.delete(key, namespace: ns)
+        true
+      end
+
+      def clear(options = nil)
+        options ||= {}
+        namespace = options[:namespace]
+        if namespace
+          @mudis.clear_namespace(namespace: namespace)
+          return true
+        end
+
+        @mudis.all_keys.each { |key| @mudis.delete(key) }
+        true
+      end
+
+      def fetch_multi(*names)
+        return super if names.empty?
+
+        options = names.extract_options!
+        results = {}
+
+        names.each do |name|
+          value = read(name, **options)
+          results[name] = value if value
+        end
+
+        if block_given?
+          names.each do |name|
+            next if results.key?(name)
+
+            results[name] = yield(name)
+            write(name, results[name], **options)
+          end
+        end
+
+        results
+      end
+
+      private
+
+      def denamespaced_key(key, namespace)
+        return key if namespace.nil?
+        return key unless key.is_a?(String)
+
+        prefix = "#{namespace}:"
+        key.start_with?(prefix) ? key.delete_prefix(prefix) : key
+      end
+    end
+  end
+end

data/lib/mudis/rails/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Mudis
+  module Rails
+    VERSION = "0.1.0"
+  end
+end

data/lib/mudis/rails.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative "rails/version"
+require_relative "rails/config"
+
+class Mudis
+  module Rails
+    class << self
+      def configure
+        yield(config)
+      end
+
+      def config
+        @config ||= Config.new
+      end
+
+      def install(mudis: ::Mudis, **options)
+        apply_options!(options)
+        return unless config.enabled
+
+        ensure_rails!
+        apply_mudis_options!(mudis)
+        install_cache_store!(mudis)
+        load_persistence!(mudis)
+        start_expiry_thread!(mudis)
+        install_shutdown_hook!(mudis)
+      end
+
+      def puma_before_fork!(mudis: ::Mudis, **options)
+        apply_options!(options)
+        return unless config.enabled
+
+        apply_mudis_options!(mudis)
+        load_persistence!(mudis)
+        start_expiry_thread!(mudis)
+        require "mudis_server" unless defined?(MudisServer)
+        MudisServer.start!
+      end
+
+      def puma_on_worker_boot!(proxy: nil)
+        proxy = config.ipc_proxy if proxy.nil?
+
+        require "mudis_client" unless defined?(MudisClient)
+        $mudis = MudisClient.new
+        require "mudis_proxy" if proxy
+      end
+
+      def uninstall(mudis: ::Mudis)
+        return unless defined?(::Rails)
+
+        if config.use_as_cache_store && config.override_cache_store
+          ::Rails.application.config.cache_store = nil
+        end
+
+        mudis.stop_expiry_thread if config.auto_stop_expiry_thread
+      end
+
+      private
+
+      def apply_options!(options)
+        options.each do |key, value|
+          next unless config.respond_to?("#{key}=")
+
+          config.public_send("#{key}=", value)
+        end
+      end
+
+      def ensure_rails!
+        return if defined?(::Rails)
+
+        raise "Mudis::Rails.install requires Rails to be loaded"
+      end
+
+      def apply_mudis_options!(mudis)
+        return if config.mudis_options.empty?
+
+        mudis.configure do |c|
+          config.mudis_options.each do |key, value|
+            setter = "#{key}="
+            c.public_send(setter, value) if c.respond_to?(setter)
+          end
+        end
+      end
+
+      def install_cache_store!(mudis)
+        return unless config.use_as_cache_store
+
+        require_relative "rails/store"
+        cache_store = ::Rails.application.config.cache_store
+        return if cache_store && !config.override_cache_store
+
+        options = { mudis: mudis }.merge(config.cache_store_options)
+        ::Rails.application.config.cache_store = [Mudis::Rails::Store, options]
+      end
+
+      def start_expiry_thread!(mudis)
+        return unless config.auto_start_expiry_thread
+
+        mudis.start_expiry_thread(interval: config.expiry_thread_interval)
+      end
+
+      def load_persistence!(mudis)
+        return unless config.persistence_load_on_boot
+
+        mudis.load_snapshot!
+      end
+
+      def install_shutdown_hook!(mudis)
+        return unless config.auto_stop_expiry_thread
+
+        at_exit { mudis.stop_expiry_thread }
+      end
+    end
+  end
+end
+
+require_relative "rails/railtie" if defined?(::Rails::Railtie)

data/lib/mudis-rails.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "mudis"
+require_relative "mudis/rails"

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: mudis-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- kiebor81
+bindir: bin
+cert_chain: []
+date: 2026-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mudis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !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: railties
+  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: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+description: Rails plugin for Mudis with an installer, generator, and cache store
+  wrapper.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/generators/mudis/install/templates/mudis.rb
+- lib/generators/mudis/install_generator.rb
+- lib/mudis-rails.rb
+- lib/mudis/rails.rb
+- lib/mudis/rails/config.rb
+- lib/mudis/rails/railtie.rb
+- lib/mudis/rails/store.rb
+- lib/mudis/rails/version.rb
+homepage: https://github.com/kiebor81/mudis
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Rails integration helpers for Mudis.
+test_files: []