view_component_reflex 0.6.2 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f994d68e2d141a7ddb6f256d64fb55350e85011b0cbea0bcb9184fda24b35df6
-  data.tar.gz: bb4f268de2b510782c60ab164e76f79322cc478f8b100a7711742e50ee2f3f4c
+  metadata.gz: 163bc65c20bb1ac85bb9e15ee2ce4fbf7039a9d90cbe7c4cb1591d03699edc71
+  data.tar.gz: fb80faac53511b705e0170da3cfae4c7c82c1a59c6bf773e8b86eea30463b9f5
 SHA512:
-  metadata.gz: a69bcd9c9b98a994d1ac00b81bfdc3993e6564d2ae3fc8bcd0559e07c663a2beefa7b3b6efff118279e88560954cb6cbd7413ea0ce7936463570ccaaaf0051b5
-  data.tar.gz: 02b12f819add7a693360fd211a5d591d723f1569f880cd781472e89187187743908c64056ec8a1b098838e007a2b9a2340a52631b8a9a5794469b3d8e23181a3
+  metadata.gz: 9936a4885f9b8e625eca11ac78af316f475764688a5fd2aca9f098aabd802c5e578bdca12266b7176c52c3ff6302dcf7c703e1dd902194bc2dd8c20a1071ab14
+  data.tar.gz: e5fca59e3e33091ee7b53df0d0cf40007b476835f141cd3f717d7b86e14fde3cec8ffce960a4f23b7ffe5f12a48d10a6917843a9e33c67d911b76485187796c7

data/README.md

@@ -6,51 +6,51 @@ ViewComponentReflex allows you to write reflexes right in your view component co
 
 You can add reflexes to your component by adding inheriting from `ViewComponentReflex::Component`.
 
-To add a reflex to your component, use the `reflex` method.
-
-```ruby
-    reflex :my_cool_reflex do
-      # do stuff
-      refresh!
-    end
-```
-
 This will act as if you created a reflex with the method `my_cool_stuff`. To call this reflex, add `data-reflex="click->MyComponentReflex#my_cool_reflex"`, just like you're
 using stimulus reflex.
 
-#####note: A reflex will not automatically re-render the component upon its completion. A component will re-render whenever the `set_state` or `refresh!` method is called.
-
-In addition to calling reflexes, there is a rudimentary state system. You can initialize component-local state with `initialize_state(obj)`, where `obj` is a hash.
-
-You can access state with the `state` helper. See the code below for an example. Calling `set_state` will set the state, 
-and also re-render your component.
-
-If you're using state add `data-key="<%= key %>"` to any html element using a reflex. This 
-lets ViewComponentReflex keep track of which state belongs to which component.
-
+ViewComponentReflex will maintain your component's instance variables between renders. You need to include `data-key=<%= key %>` on your root element, as well 
+as any element that stimulates a reflex. ViewComponent is inherently state-less, so the key is used to reconcile state to its respective component.
 
+### Example
 ```ruby
-    # counter_component.rb
-    class CounterComponent < ViewComponentReflex::Component
-   
-      def initialize
-        initialize_state({
-          count: 0
-        })
-      end
-    
-      reflex :increment do
-        set_state(count: state[:count] + 1)
-      end
-    end
+# counter_component.rb
+class CounterComponent < ViewComponentReflex::Component
+  def initialize
+    @count = 0
+  end
+
+  def increment
+    @count += 1
+  end
+end
 ```
 
 ```erb
 # counter_component.html.erb
-<div data-controller="counter">
-    <p><%= state[:count] %></p>
+<%= component_controller do %>
+    <p><%= @count %></p>
     <button type="button" data-reflex="click->CounterComponentReflex#increment" data-key="<%= key %>">Click</button>
-</div>
+<% end %>
+```
+
+## Collections
+
+In order to reconcile state to components in collections, you can specify a `collection_key` method that returns some
+value unique to that component.
+
+```
+class TodoComponent < ViewComponentReflex::Component
+  def initialize(todo:)
+    @todo = todo
+  end
+
+  def collection_key
+    @todo.id
+  end
+end
+#
+<%= render(TodoComponent.with_collection(Todo.all)) %>
 ```
 
 ## Custom State Adapters
@@ -76,36 +76,27 @@ class YourAdapter
   end
 
   ##
+  # set_state is used to modify the state. It accepts a reflex, which gives you
+  # access to the request, as well as the controller and other useful objects. 
+  #
   # reflex - The reflex instance that's trying to set the state
   # key - a unique string that identifies the component
   # new_state - the new state to set
   def self.set_state(reflex, key, new_state)
+    # update the state
   end
 
 
   ##
+  # store_state is used to replace the state entirely. It only accepts
+  # a request object, rather than a reflex because it's called from the component's 
+  # side with the component's instance variables.
+  #
   # request - a rails request object
   # key - a unique string that identifies the component instance
   # new_state - a hash containing the component state
   def self.store_state(request, key, new_state = {})
-    # store the state 
-    # this will be called twice, once with key, once with key_initial
-    # key_initial contains the initial, unmodified state.
-    # it should be used in reconcile_state to decide whether or not
-    # to re-initialize the state
-  end
-  
-  ##
-  # request - a rails request object
-  # key - a unique string that identifies the component instance
-  # new_state - a hash containing the component state
-  def self.reconcile_state(request, key, new_state)
-  # The passed state should always match the initial state of the component
-  # if it doesn't, we need to reset the state to the passed value.
-  #
-  # This handles cases where your initialize_state param computes some value that changes
-  # initialize_state({ transaction: @customer.transactions.first })
-  # if you delete the first transaction, that ^ is no longer valid. We need to update the state.
+    # replace the state
   end
 end
 ```

data/app/components/view_component_reflex/component.rb

@@ -1,87 +1,151 @@
 module ViewComponentReflex
   class Component < ViewComponent::Base
     class << self
-      def reflex(name, &blk)
-        stimulus_reflex.reflex(name, &blk)
-      end
-
-      def stimulus_reflex
+      def init_stimulus_reflex
         klass = self
         @stimulus_reflex ||= Object.const_set(name + "Reflex", Class.new(StimulusReflex::Reflex) {
-          def state
-            ViewComponentReflex::Engine.state_adapter.state(request, element.dataset[:key])
-          end
-
-          def refresh!(primary_selector = "[data-controller=\"#{stimulus_controller}\"]", *selectors)
+          def refresh!(primary_selector = "[data-controller~=\"#{stimulus_controller}\"][data-key=\"#{element.dataset[:key]}\"]", *selectors)
+            save_state
             @channel.send :render_page_and_broadcast_morph, self, [primary_selector, *selectors], {
-              dataset: element.dataset.to_h,
-              args: [],
-              attrs: element.attributes.to_h,
-              selectors: ['body'],
-              target: "#{self.class.name}##{method_name}",
-              url: request.url,
-              permanentAttributeName: "data-reflex-permanent"
+              "dataset" => element.dataset.to_h,
+              "args" => [],
+              "attrs" => element.attributes.to_h,
+              "selectors" => ["body"],
+              "target" => "#{self.class.name}##{method_name}",
+              "url" => request.url,
+              "permanent_attribute_name" => "data-reflex-permanent"
             }
           end
 
           def refresh_all!
-            refresh!('body')
+            refresh!("body")
           end
 
-          def set_state(new_state = {}, primary_selector = nil, *selectors)
-            ViewComponentReflex::Engine.state_adapter.set_state(self, element.dataset[:key], new_state)
-            refresh!(primary_selector, *selectors)
+          # SR's delegate_call_to_reflex in channel.rb
+          # uses method to gather the method parameters, but since we're abusing
+          # method_missing here, that'll always fail
+          def method(name)
+            name.to_sym.to_proc
+          end
+
+          def respond_to_missing?(name, _ = false)
+            !!name.to_proc
           end
 
-          before_reflex do |reflex, *args|
-            instance_exec(*args, &self.class.callbacks[self.method_name.to_sym]) if self.class.callbacks.include?(self.method_name.to_sym)
+          before_reflex do |a|
+            a.send a.method_name
             throw :abort
           end
 
-          def self.callbacks
-            @callbacks ||= {}
+          def method_missing(name, *args)
+            super unless respond_to_missing?(name)
+            state.each do |k, v|
+              component.instance_variable_set(k, v)
+            end
+            name.to_proc.call(component, *args)
+            refresh!
+          end
+
+          define_method :component_class do
+            @component_class ||= klass
+          end
+
+          private :component_class
+
+          private
+
+          def stimulus_controller
+            component_class.stimulus_controller
+          end
+
+          def component
+            return @component if @component
+            @component = component_class.allocate
+            reflex = self
+            exposed_methods = [:params, :request, :element, :refresh!, :refresh_all!, :stimulus_controller]
+            exposed_methods.each do |meth|
+              @component.define_singleton_method(meth) do |*a|
+                reflex.send(meth, *a)
+              end
+            end
+            @component
           end
 
-          define_method :stimulus_controller do
-            klass.name.chomp("Component").underscore.dasherize
+          def set_state(new_state = {})
+            ViewComponentReflex::Engine.state_adapter.set_state(self, element.dataset[:key], new_state)
           end
 
-          define_singleton_method(:reflex) do |name, &blk|
-            callbacks[name] = blk
-            define_method(name) do |*args|
+          def state
+            ViewComponentReflex::Engine.state_adapter.state(request, element.dataset[:key])
+          end
+
+          def save_state
+            new_state = {}
+            component.instance_variables.each do |k|
+              new_state[k] = component.instance_variable_get(k)
             end
+            set_state(new_state)
           end
         })
       end
     end
 
-    def initialize_state(obj)
-      @state = obj
+    def self.stimulus_controller
+      name.chomp("Component").underscore.dasherize
     end
 
     def stimulus_reflex?
       helpers.controller.instance_variable_get(:@stimulus_reflex)
     end
 
+    def component_controller(opts = {}, &blk)
+      self.class.init_stimulus_reflex
+      init_key
+      opts[:data] = {
+        controller: self.class.stimulus_controller,
+        key: key,
+        **(opts[:data] || {})
+      }
+      content_tag :div, capture(&blk), opts
+    end
+
     # key is required if you're using state
     # We can't initialize the session state in the initial method
     # because it doesn't have a view_context yet
     # This is the next best place to do it
-    def key
-      @key ||= caller.find { |p| p.include? ".html.erb" }&.hash.to_s
+    def init_key
+      # we want the erb file that renders the component. `caller` gives the file name,
+      # and line number, which should be unique. We hash it to make it a nice number
+      key = caller.select { |p| p.include? ".html.erb" }[1]&.hash.to_s
+      key += collection_key.to_s if collection_key
+      @key = key
+    end
+
+    def collection_key
+      nil
+    end
 
+    def key
       # initialize session state
       if !stimulus_reflex? || session[@key].nil?
-        ViewComponentReflex::Engine.state_adapter.store_state(request, @key, @state)
-        ViewComponentReflex::Engine.state_adapter.store_state(request, "#{@key}_initial", @state)
+        new_state = {}
+
+        # this will almost certainly break
+        blacklist = [
+          :@view_context, :@lookup_context, :@view_renderer, :@view_flow,
+          :@virtual_path, :@variant, :@current_template, :@output_buffer, :@key,
+          :@helpers, :@controller, :@request, :@content
+        ]
+        instance_variables.reject { |k| blacklist.include?(k) }.each do |k|
+          new_state[k] = instance_variable_get(k)
+        end
+        ViewComponentReflex::Engine.state_adapter.store_state(request, @key, new_state)
       else
-        # ViewComponentReflex::Engine.state_adapter.reconcile_state(request, @key, @state)
+        ViewComponentReflex::Engine.state_adapter.state(request, @key).each do |k, v|
+          instance_variable_set(k, v)
+        end
       end
       @key
     end
-
-    def state
-      ViewComponentReflex::Engine.state_adapter.state(request, key)
-    end
   end
 end

data/lib/view_component_reflex/state_adapter/session.rb

@@ -19,20 +19,6 @@ module ViewComponentReflex
           request.session[key][k] = v
         end
       end
-
-      # The passed state should always match the initial state of the component
-      # if it doesn't, we need to reset the state to the passed value.
-      #
-      # This handles cases where your initialize_state param computes some value that changes
-      # initialize_state({ transaction: @customer.transactions.first })
-      # if you delete the first transaction, that ^ is no longer valid. We need to update the state.
-      def self.reconcile_state(request, key, new_state)
-        request.session["#{key}_initial"].each do |k, v|
-          if new_state[k] != v
-            request.session[key][k] = new_state[k]
-          end
-        end
-      end
     end
   end
 end

data/lib/view_component_reflex/version.rb

@@ -1,3 +1,3 @@
 module ViewComponentReflex
-  VERSION = '0.6.2'
+  VERSION = '1.1.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: view_component_reflex
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 1.1.1
 platform: ruby
 authors:
 - Joshua LeBlanc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-13 00:00:00.000000000 Z
+date: 2020-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails