view_component_reflex 3.1.14.pre9 → 3.2.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92c0d1350e67ae8b1ae796fc57f4ce22f7cddebb0bce2559ba25df5e81dc191a
-  data.tar.gz: 39c96a9635ce1d217a6a1bf772743c7e9103ebf30b748cf22756614ea13030d3
+  metadata.gz: '076282b09956e12df3434c1be972995da10bdc2a094598f71da922bef7f84f6e'
+  data.tar.gz: c250e5e4de40beafa81110a32e9d4ef03b0321d3a1674f2ba4811b56bdffe68a
 SHA512:
-  metadata.gz: ceb51a750f14878ecab26760e2c3951259ff9f3c7da3b503f504b7197d7d2163d5faf95b063b55a77bdfc662467422b22a987f3b7adb4f5ae364cfdeb4aee16c
-  data.tar.gz: c8e96efd021ad1c46deee61537e60a364dc6b5636a54985389deb5de3094774f7b3d941de07cf2a17616aec16b96d161d9ee2f2c619c8dd1fec95f1e2fa180f4
+  metadata.gz: 9dd881a3cb9a890f771a5ed21df13dc15eb73db2ed6beb290f43d9fa3967d58a0631833a653ebf0e49eb2e44e3a5651e0855174df42e7bdf093e876959af75fd
+  data.tar.gz: 2f801a13e7e1b081b205b7def36cf0f7ef42b44fe4f81f0c55781202252c2eb8548ab4d84895577eab727262e70c0e4377dc54584b9cff656d01c9dfb41dabaa

data/README.md

@@ -248,6 +248,27 @@ class MyComponent < ViewComponentReflex::Component
 end
 ```
 
+## Per-component state adapters
+You can override the default state adapter for a component by using the `state_adapter` helper.
+
+```ruby
+class MyComponent < ViewComponentReflex::Component
+  state_adapter :dom # or :session, or :memory
+end
+```
+
+This will also accept a fully qualified constant 
+
+```ruby
+class MyComponent < ViewComponentReflex::Component
+  state_adapter ViewComponentReflex::StateAdapter::Redis.new(
+    redis_opts: {
+      url: "redis://localhost:6379/1", driver: :hiredis
+    },
+    ttl: 3600)
+end
+```
+
 ## Common patterns
 A lot of the time, you only need to update specific components when changing instance variables. For example, changing `@loading` might only need
 to display a spinner somewhere on the page. You can define setters to implicitly render the appropriate pieces of dom whenever that variable is set
@@ -288,6 +309,9 @@ end
 By default (since version `2.3.2`), view_component_reflex stores component state in session. You can optionally set the state adapter
 to use the memory by changing `config.state_adapter` to `ViewComponentReflex::StateAdapter::Memory`.
 
+Optionally, you can also store state right in the dom with `ViewComponentReflex::StateAdapter::Dom`. Not that the DOM
+adapter requires the `data-reflex-dataset="*"` property to be set on anything firing the reflex. 
+
 ## Custom State Adapters
 
 ViewComponentReflex uses session for its state by default. To change this, add
@@ -299,7 +323,6 @@ ViewComponentReflex::Engine.configure do |config|
 end
 ```
 
-
 ## Existing Fast Redis based State Adapter
 
 This adapter uses hmset and hgetall to reduce the number of operations. 

data/Rakefile

@@ -14,8 +14,8 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
-load 'rails/tasks/engine.rake'
+# APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+# load 'rails/tasks/engine.rake'
 
 load 'rails/tasks/statistics.rake'
 

data/{app/components → lib}/view_component_reflex/component.rb

@@ -4,6 +4,8 @@ module ViewComponentReflex
     attr_reader :key
 
     class << self
+      attr_reader :_state_adapter
+
       def init_stimulus_reflex
         factory = ViewComponentReflex::ReflexFactory.new(self)
         @stimulus_reflex ||= factory.reflex
@@ -57,6 +59,15 @@ module ViewComponentReflex
         register_callbacks(:after)
         register_callbacks(:around)
       end
+
+      def state_adapter(what)
+        if what.is_a?(Symbol) || what.is_a?(String)
+          class_name = what.to_s.camelize
+          @_state_adapter = StateAdapter.const_get class_name
+        else
+          @_state_adapter = what
+        end
+      end
     end
 
     def self.stimulus_controller
@@ -67,6 +78,10 @@ module ViewComponentReflex
       helpers.controller.instance_variable_get(:@stimulus_reflex)
     end
 
+    def before_render
+      adapter.extend_component(self)
+    end
+
     def component_controller(opts_or_tag = :div, opts = {}, &blk)
       initialize_component
 
@@ -91,10 +106,10 @@ module ViewComponentReflex
     end
 
     # We can't truly initialize the component without the view_context,
-    # which isn't available in the `initialize` method. We require the 
+    # which isn't available in the `initialize` method. We require the
     # developer to wrap components in `component_controller`, so this is where
     # we truly initialize the component.
-    # This method is overridden in reflex.rb when the component is re-rendered. The 
+    # This method is overridden in reflex.rb when the component is re-rendered. The
     # override simply sets @key to element.dataset[:key]
     # We don't want it to initialize the state again, and since we're rendering the component
     # outside of the view, we need to skip the initialize_key method as well
@@ -109,30 +124,31 @@ module ViewComponentReflex
     # so we can't rely on the component created by the reflex
     def initialize_state
       return if state_initialized?
-      adapter = ViewComponentReflex::Engine.state_adapter
-      
+
+      adapter.extend_component(self)
+
       # newly mounted
-      if !stimulus_reflex? || adapter.state(request, @key).empty?
+      if !stimulus_reflex? || state(@key).empty?
 
         new_state = create_safe_state
 
-        adapter.wrap_write_async do
-          adapter.store_state(request, @key, new_state)
-          adapter.store_state(request, "#{@key}_initial", new_state)
+        wrap_write_async do
+          store_state(@key, new_state)
+          store_state("#{@key}_initial", new_state)
         end
 
       # updating a mounted component
       else
-        initial_state = adapter.state(request, "#{@key}_initial")
+        initial_state = state("#{@key}_initial")
 
         parameters_changed = []
-        adapter.state(request, @key).each do |k, v|
+        state(@key).each do |k, v|
           instance_value = instance_variable_get(k)
           if permit_parameter?(initial_state[k], instance_value)
             parameters_changed << k
-            adapter.wrap_write_async do
-              adapter.set_state(request, controller, "#{@key}_initial", {k => instance_value})
-              adapter.set_state(request, controller, @key, {k => instance_value})
+            wrap_write_async do
+              set_state("#{@key}_initial", { k => instance_value })
+              set_state(@key, { k => instance_value })
             end
           else
             instance_variable_set(k, v)
@@ -143,6 +159,26 @@ module ViewComponentReflex
       @state_initialized = true
     end
 
+    def adapter
+      self.class._state_adapter || ViewComponentReflex::Engine.state_adapter
+    end
+
+    def wrap_write_async(&blk)
+      adapter.wrap_write_async(&blk)
+    end
+
+    def set_state(key, new_state)
+      adapter.set_state(request, controller, key, new_state)
+    end
+
+    def state(key)
+      adapter.state(request, key)
+    end
+
+    def store_state(key, new_state = {})
+      adapter.store_state(request, key, new_state)
+    end
+
     def state_initialized?
       @state_initialized
     end
@@ -152,10 +188,10 @@ module ViewComponentReflex
       # and line number, which should be unique. We hash it to make it a nice number
       erb_file = caller.select { |p| p.match? /.\.html\.(haml|erb|slim)/ }[1]
       key = if erb_file
-        Digest::SHA2.hexdigest(erb_file.split(":in")[0])
-      else
-        ""
-      end
+              Digest::SHA2.hexdigest(erb_file.split(":in")[0])
+            else
+              ""
+            end
       key += collection_key.to_s if collection_key
       @key = key
     end

data/lib/view_component_reflex/dom/component.rb

@@ -0,0 +1,40 @@
+module ViewComponentReflex
+  module Dom
+    module Component
+
+      def component_controller(opts_or_tag = :div, opts = {}, &blk)
+        initialize_component
+
+        tag = :div
+        options = if opts_or_tag.is_a? Hash
+          opts_or_tag
+        else
+          tag = opts_or_tag
+          opts
+        end
+
+        data = {
+          "#{key}_state" => Verifier.generate(state(key)),
+          "#{key}_initial" => Verifier.generate(state("#{key}_initial")),
+        }
+
+        options[:data] = {
+          controller: self.class.stimulus_controller,
+          key: key,
+          **(options[:data] || {})
+        }
+
+        content_tag tag, options do
+          concat(content_tag(:span, nil, { data: data, style: "display: none;" }))
+          concat(capture(&blk))
+        end
+      end
+
+      def reflex_data_attributes(reflex)
+        super(reflex).tap do |attr|
+          attr["reflex-dataset"] = "*"
+        end
+      end
+    end
+  end
+end

data/lib/view_component_reflex/dom/reflex.rb

@@ -0,0 +1,37 @@
+##
+# State adapters assume that the data lives outside of the rendering pipeline
+# By moving the state to the DOM, we need to "hydrate" the state when the reflex comes in with the data
+# We're overriding `inject_key_into_component` for this purpose, since it's run once during a reflex,
+# and _just_ after the component is initialized, but before it actually does anything.
+# This ensures that any actions that the component is taking is going to be operating on the correct
+# state
+
+module ViewComponentReflex
+  module Dom
+    module Reflex
+      def state
+        if element.dataset[:"#{key}_state"]
+          Verifier.verify(element.dataset[:"#{key}_state"])
+        else
+          {}
+        end
+      end
+
+      def inject_key_into_component
+        super
+
+        p initial_state[:@count]
+        state_adapter.store_state(request, key, state)
+        state_adapter.store_state(request, "#{key}_initial", initial_state)
+      end
+
+      def initial_state
+        if element.dataset[:"#{key}_initial"]
+          Verifier.verify(element.dataset[:"#{key}_initial"])
+        else
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/view_component_reflex/dom/verifier.rb

@@ -0,0 +1,15 @@
+module ViewComponentReflex
+  module Dom
+    class Verifier
+      class << self
+        attr_reader :verifier
+
+        delegate :generate, :verified, :verify, :valid_message?, to: :verifier
+
+        def verifier
+          Rails.application.message_verifier(:view_component_reflex)
+        end
+      end
+    end
+  end
+end

data/lib/view_component_reflex/reflex.rb

@@ -1,6 +1,5 @@
 module ViewComponentReflex
   class Reflex < StimulusReflex::Reflex
-
     class << self
       attr_accessor :component_class
     end
@@ -48,21 +47,23 @@ module ViewComponentReflex
       @stream = channel
     end
 
-    def component_document
+    def inject_key_into_component
       component.tap do |k|
         k.define_singleton_method(:initialize_component) do
           @key = element.dataset[:key]
         end
       end
+    end
 
-      document = Nokogiri::HTML(component.render_in(controller.view_context))
+    def component_document
+      Nokogiri::HTML(component.render_in(controller.view_context))
     end
 
     def refresh_component!
       CableReady::Channels.instance[stream].morph(
         selector: selector,
         children_only: true,
-        html: component_document.css(selector).inner_html,
+        html: component_document.css(selector).to_html,
         permanent_attribute_name: "data-reflex-permanent",
         reflex_id: reflex_id
       )
@@ -109,6 +110,7 @@ module ViewComponentReflex
     # uses method to gather the method parameters, but since we're abusing
     # method_missing here, that'll always fail
     def method(name)
+      component.adapter.extend_reflex(self)
       component.method(name.to_sym)
     end
 
@@ -124,11 +126,11 @@ module ViewComponentReflex
       end
 
       component.send(name, *args, &blk)
-      
+
       if @prevent_refresh
         morph :nothing
       else
-        default_morph      
+        default_morph
       end
     end
 
@@ -196,6 +198,8 @@ module ViewComponentReflex
         reflex
       end
 
+      inject_key_into_component
+
       @component
     end
 
@@ -208,7 +212,7 @@ module ViewComponentReflex
     end
 
     def state_adapter
-      ViewComponentReflex::Engine.state_adapter
+      component.adapter
     end
 
     def state

data/lib/view_component_reflex/state_adapter/base.rb

@@ -2,6 +2,30 @@ module ViewComponentReflex
   module StateAdapter
     class Base
 
+      def self.state(request, key)
+        # stub
+      end
+
+      def self.set_state(request, controller, key, new_state)
+        # stub
+      end
+
+      def self.store_state(request, key, new_state = {})
+        # stub
+      end
+
+      def self.wrap_write_async
+        yield
+      end
+
+      def self.extend_component(component)
+        # stub
+      end
+
+      def self.extend_reflex(component)
+        # stub
+      end
+
       private
 
       def self.extract_id(request)

data/lib/view_component_reflex/state_adapter/dom.rb

@@ -0,0 +1,56 @@
+##
+# This adapter exists solely to allow switching to dom-based state storage, even
+# though dom-based state storage doesn't abide by the same standards as the other adapters
+#
+# The dom-based state storage is handled by the Dom::Component and Dom::Reflex modules that are prepended
+# to Component and Reflex in Engine, if the dom adapter is selected
+#
+# These modules override various methods to inject state into the dom, as well as encoding/decoding the state from the dom
+
+class CurrentState < ActiveSupport::CurrentAttributes
+  attribute :state
+end
+
+module ViewComponentReflex
+  module StateAdapter
+    class Dom < Base
+      def self.state(request, key)
+        id = extract_id(request)
+
+        CurrentState.state ||= {}
+        CurrentState.state[id] ||= {}
+        CurrentState.state[id][key] ||= {}
+      end
+
+      def self.set_state(request, _, key, new_state)
+        new_state.each do |k, v|
+          state(request, key)[k] = v
+        end
+      end
+
+      def self.store_state(request, key, new_state = {})
+        id = extract_id(request)
+
+        CurrentState.state ||= {}
+        CurrentState.state[id] ||= {}
+        CurrentState.state[id][key] = {}
+
+        new_state.each do |k, v|
+          CurrentState.state[id][key][k] = v
+        end
+      end
+
+      def self.extend_component(component)
+        component.extend ViewComponentReflex::Dom::Component
+      end
+
+      def self.extend_reflex(reflex)
+        reflex.extend ViewComponentReflex::Dom::Reflex
+      end
+
+      def self.wrap_write_async
+        yield
+      end
+    end
+  end
+end

data/lib/view_component_reflex/state_adapter/redis.rb

@@ -11,7 +11,8 @@
 module ViewComponentReflex
   module StateAdapter
     class Redis < Base
-      attr_reader :client, :ttl
+      attr_reader :ttl
+      attr_accessor :client
 
       def initialize(redis_opts:, ttl: 3600)
         @client = ::Redis.new(redis_opts)
@@ -40,11 +41,22 @@ module ViewComponentReflex
       end
 
       def wrap_write_async
-        client.pipelined do
+        client.pipelined  do |pipeline|
+          original_client = client
+          @client = pipeline
           yield
+          @client = original_client
         end
       end
 
+      def extend_component(_)
+        #stub
+      end
+
+      def extend_reflex(_)
+        #stub
+      end
+
       private
 
       # Reduce number of calls coming from #store_state to save Redis

data/lib/view_component_reflex/version.rb

@@ -1,3 +1,3 @@
 module ViewComponentReflex
-  VERSION = '3.1.14.pre9'
+  VERSION = '3.2.0.pre'
 end

data/lib/view_component_reflex.rb

@@ -3,9 +3,14 @@ require 'view_component_reflex/reflex_factory'
 require "view_component_reflex/state_adapter/base"
 require "view_component_reflex/state_adapter/session"
 require "view_component_reflex/state_adapter/memory"
+require "view_component_reflex/state_adapter/dom"
 require "view_component_reflex/state_adapter/redis"
-require "view_component_reflex/reflex"
+require "view_component_reflex/dom/verifier"
+require "view_component_reflex/dom/reflex"
+require "view_component_reflex/dom/component"
 require "view_component_reflex/engine"
+require "view_component_reflex/reflex"
+require "view_component_reflex/component"
 
 module ViewComponentReflex
   # Your code goes here...

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: view_component_reflex
 version: !ruby/object:Gem::Version
-  version: 3.1.14.pre9
+  version: 3.2.0.pre
 platform: ruby
 authors:
 - Joshua LeBlanc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-10 00:00:00.000000000 Z
+date: 2022-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -82,12 +82,16 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
-- app/components/view_component_reflex/component.rb
 - lib/view_component_reflex.rb
+- lib/view_component_reflex/component.rb
+- lib/view_component_reflex/dom/component.rb
+- lib/view_component_reflex/dom/reflex.rb
+- lib/view_component_reflex/dom/verifier.rb
 - lib/view_component_reflex/engine.rb
 - lib/view_component_reflex/reflex.rb
 - lib/view_component_reflex/reflex_factory.rb
 - lib/view_component_reflex/state_adapter/base.rb
+- lib/view_component_reflex/state_adapter/dom.rb
 - lib/view_component_reflex/state_adapter/memory.rb
 - lib/view_component_reflex/state_adapter/redis.rb
 - lib/view_component_reflex/state_adapter/session.rb
@@ -112,7 +116,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.2.9
+rubygems_version: 3.3.3
 signing_key: 
 specification_version: 4
 summary: Allow stimulus reflexes in a view component