sticky_params 1.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44455740df636d34ee63027b34b7733b24fe241a70313533d0c698ddfa38ba87
-  data.tar.gz: cab9e1b6c9bf1a728f147abd475fba7f4aeef9c8988c990ab906e213b8fc822b
+  metadata.gz: 95f2ebe1001e88bac518483e27d299e187c09e5f5002516bee8ce2e259222a75
+  data.tar.gz: df3e8ea4586ddd41cc7b759051f51077910d4a6629637e0d0b9586d8cb92f26e
 SHA512:
-  metadata.gz: d2cee252c15971b0acb0891c5169f595896f8e047f5792fa3bef29dbd7fcf58b2b06fa0afd470a9cb4fd06facc67ac61e2b8044d18e7aff2c387a6236b67d0ec
-  data.tar.gz: '05283ece5a2a758f24b150b5f6bc0a38394a65902d04434a3b866bf188eeb1d72b357af2614eeaf0c2a14f6cb9bc891b05554bb39375b0ce3b870c8d64a358c7'
+  metadata.gz: cbe4b35d6555c246096d4a90fe404eb2f340336646e30d4e5dde718e3ddfaf17488387f2246775f7a1f4dba2efd5737223a97e68ce3eb18ecc5df5f63374ed69
+  data.tar.gz: 1e3d546c073fd3e29ca6578ab6c6776d80d905efcf68a6a45092fed579b16053dc61ee7ad899c43e79eda135d6e85f5d3774edcd86f1dd514c358253054c6608

data/README.md

@@ -1,7 +1,7 @@
 # StickyParams
 
 A little gem that automaticly remembers the request parameters between requests without hassle.
-For example for remembering the filtering and sorting of a list,  when switching to a detail screen and back.
+For example for remembering the filtering and sorting of a list, when switching to a detail screen and back.
 
 ```ruby
 class MyController < ApplicationController
@@ -12,6 +12,25 @@ class MyController < ApplicationController
 end
 ```
 
+## Release Notes 2.1
+
+
+Release 2.1, Sticky Params doesn't put ActionController::Parameters in a sesssion anymore.
+ActionController::Parameters were put directly into a session in 2.0. Which worked in rails < 7.
+In rails 7 this results in a `TypeError (can't dump IO)` when the session data is serialized.
+
+Release 2.0, uses ActionController::Parameters instead of hashes.
+This enable the usage of the strong parameter permit construct.
+(In other words, sticky_params will work just like normal params)
+
+To get the 1.0 behaviour, you can add the following to your ApplicationController.
+
+```ruby
+  def sticky_params
+    @sticky_params ||= ::StickyParams::SessionParams.new(self)
+  end
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -23,7 +42,7 @@ gem 'sticky_params'
 And then execute:
 
 ```bash
-    $ bundle
+bundle
 ```
 
 ## Usage
@@ -75,16 +94,14 @@ This session variable is a hash and it uses a prefix for storing the variables.
 By default the prefix is "controller_action_"
 
 When retrieving a parameter from sticky_params it first tries to retrieve it from
-the normal params hash. When it's in the params hash, it stores the result in the
-sticky_params hash.
-If the parameter isn't in the normal params hash it does a lookup in the session hash.
+the normal parameters. When it's found in the parameters, it stores the result in the sticky_params storage.
+If the parameter isn't in the normal aparameters it does a lookup in the session hash.
 Pretty simple.
 
 ## Common Pattern
 
 A pattern I used often with sticky_params, is using a request parameter 'reset' .
 
-
 For example for a basic rest controller, I have an index action which shows all users.
 The list of users is sortable, searchable and paged. When selecting a user in this table
 I goto the user screen. When going back I want my selection to persist.
@@ -116,12 +133,12 @@ class UsersController < ApplicationController
 end
 ```
 
-For the lazy developer:
+For the lazy developers.
 you could force the reset parameter to always work in your application.
 
 ```ruby
 class ApplicationController < ActionController::Base
-  before_filter :sticky_params_reset
+  before_action :sticky_params_reset
 
 protected:
   def sticky_params_reset

data/lib/sticky_params/strong_session_params.rb

@@ -0,0 +1,61 @@
+module StickyParams
+  class StrongSessionParams
+    attr_reader :controller
+    attr_accessor :prefix
+
+    def initialize(controller)
+      @controller = controller
+      @prefix = "#{controller.controller_name}_#{controller.action_name}_"
+    end
+
+    def fetch_from_params(name, session_param_name)
+      if controller.params[name].present?
+        if controller.params[name].is_a?(ActionController::Parameters)
+          controller.session['sticky_params'][session_param_name] = controller.params[name].to_unsafe_hash
+        else
+          controller.session['sticky_params'][session_param_name] = controller.params[name]
+        end
+        controller.params[name]
+      else
+        controller.session['sticky_params'].delete session_param_name
+        nil
+      end
+    end
+
+    def fetch_from_session(session_param_name)
+      result = controller.session['sticky_params'][session_param_name]
+      # covert hash to action parameters for simulating a normal param
+      result.is_a?(Hash) ? ActionController::Parameters.new(result) : result
+    end
+
+    def [](name)
+      session_param_name = "#{prefix}#{name}"
+      controller.session['sticky_params'] ||= {}
+      if controller.params[name]
+        fetch_from_params(name, session_param_name)
+      elsif controller.session['sticky_params'][session_param_name]
+        fetch_from_session(session_param_name)
+      end
+    end
+
+    def []=(name, value)
+      session_param_name = "#{prefix}#{name}"
+      controller.session['sticky_params'] ||= {}
+      controller.session['sticky_params'][session_param_name] = controller.params[name] = value
+    end
+
+    # clears all sticky params for the current controller/action name
+    def clear!
+      if controller.session['sticky_params'].present?
+        controller.session['sticky_params'].reject! do |key, _value|
+          key.index(prefix) == 0
+        end
+      end
+    end
+
+    # clears all sticky parameters
+    def clear_all!
+      controller.session.delete('sticky_params')
+    end
+  end
+end

data/lib/sticky_params/version.rb

@@ -1,3 +1,3 @@
 module StickyParams
-  VERSION = "1.0.1"
+  VERSION = "2.1.0"
 end

data/lib/sticky_params.rb

@@ -1,6 +1,7 @@
 require "sticky_params/version"
 require "sticky_params/railtie" if defined?(Rails)
 require "sticky_params/session_params"
+require "sticky_params/strong_session_params"
 
 # Sticky Parameters is a nice hack that allows the 'remembering' a given param
 # between page requests. When a param is supplied it is stored in a session.
@@ -18,6 +19,6 @@ module StickyParams
   # A sicky parameter is a parameter that 'keeps' it state between pages,
   # by storing the data in a session
   def sticky_params
-    @sticky_params ||= ::StickyParams::SessionParams.new(self)
+    @sticky_params ||= ::StickyParams::StrongSessionParams.new(self)
   end
 end

data/sticky_params.gemspec

@@ -1,23 +1,21 @@
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'sticky_params/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = 'sticky_params'
-  spec.version       = StickyParams::VERSION
+  spec.name    = 'sticky_params'
+  spec.version = StickyParams::VERSION
 
-  spec.authors       = ['Rick Blommers']
-  spec.email         = ['rick@blommersit.nl']
-  spec.summary       = 'A rails gem that automaticly remembers request parameters between requests'
-  spec.description   = spec.summary
-  spec.homepage      = "https://github.com/gamecreature/sticky_params"
-  spec.license       = 'MIT'
+  spec.authors     = ['Rick Blommers']
+  spec.email       = ['rick@blommersit.nl']
+  spec.summary     = 'A rails gem that automaticly remembers request parameters between requests'
+  spec.description = spec.summary
+  spec.homepage    = "https://github.com/gamecreature/sticky_params"
+  spec.license     = 'MIT'
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ['lib']
-
-  # spec.add_development_dependency "bundler", "~> 1.7"
-  # spec.add_development_dependency "rake", "~> 10.0"
+  spec.files                 = `git ls-files -z`.split("\x0")
+  spec.executables           = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files            = spec.files.grep(%r{^(test|spec|features)/})
+  spec.required_ruby_version = ">= 2.0"
+  spec.require_paths         = ['lib']
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sticky_params
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Rick Blommers
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-04-29 00:00:00.000000000 Z
+date: 2022-11-09 00:00:00.000000000 Z
 dependencies: []
 description: A rails gem that automaticly remembers request parameters between requests
 email:
@@ -25,13 +25,14 @@ files:
 - lib/sticky_params.rb
 - lib/sticky_params/railtie.rb
 - lib/sticky_params/session_params.rb
+- lib/sticky_params/strong_session_params.rb
 - lib/sticky_params/version.rb
 - sticky_params.gemspec
 homepage: https://github.com/gamecreature/sticky_params
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -39,15 +40,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: A rails gem that automaticly remembers request parameters between requests
 test_files: []