tailmix 0.4.7 → 0.4.8

data/lib/tailmix/html/attributes.rb

@@ -3,16 +3,15 @@
 require "erb"
 require_relative "class_list"
 require_relative "data_map"
-require_relative "selector"
 
 module Tailmix
   module HTML
     class Attributes < Hash
-      attr_reader :element_name, :variant_string
+      attr_reader :element_name
 
-      def initialize(initial_hash = {}, element_name: nil, variant_string: "")
+      def initialize(initial_hash = {}, element_name: nil, context: nil)
         @element_name = element_name
-        @variant_string = variant_string
+        @context = context
         super()
 
         attrs_to_merge = initial_hash.dup
@@ -24,24 +23,27 @@ module Tailmix
         self[:class] = ClassList.new(initial_classes)
         self[:data]  = DataMap.new("data", initial_data || {})
         self[:aria]  = DataMap.new("aria", initial_aria || {})
-        self[:tailmix] = Selector.new(element_name, variant_string)
 
         merge!(attrs_to_merge)
       end
 
+
       def each(&block)
         to_h.each(&block)
       end
+      alias_method :each_pair, :each
 
       def to_h
-        final_attrs = select { |k, _| !%i[class data aria tailmix].include?(k.to_sym) }
+        final_attrs = select { |k, _| !%i[class data aria].include?(k.to_sym) }
 
         class_string = self[:class].to_s
         final_attrs[:class] = class_string unless class_string.empty?
 
         final_attrs.merge!(self[:data].to_h)
         final_attrs.merge!(self[:aria].to_h)
-        final_attrs.merge!(self[:tailmix].to_h)
+
+        final_attrs["data-tailmix-element"] = @element_name if @element_name
+        final_attrs["data-tailmix-id"] = @context.id if @context.id
 
         final_attrs
       end
@@ -67,10 +69,6 @@ module Tailmix
         data.stimulus
       end
 
-      def tailmix
-        self[:tailmix]
-      end
-
       def toggle(class_names)
         classes.toggle(class_names)
         self
@@ -87,8 +85,20 @@ module Tailmix
       end
 
       def each_attribute(&block)
-        [ classes: classes, data: data.to_h, aria: aria.to_h, tailmix: tailmix.to_h ].each(&block)
+        [ classes: classes, data: data.to_h, aria: aria.to_h ].each(&block)
+      end
+
+      def component
+        raise "No context available to build component root" unless @context
+
+        root_attrs = {
+          "data-tailmix-component" => @context.component_name,
+          "data-tailmix-state" => @context.state_payload,
+        }
+
+        self.class.new(self.to_h.merge(root_attrs), element_name: @element_name, context: @context)
       end
+      alias_method :root, :component
     end
   end
 end

data/lib/tailmix/middleware/registry_cleaner.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Tailmix
+  module Middleware
+    class RegistryCleaner
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      ensure
+        Tailmix::Registry.instance.clear!
+      end
+    end
+  end
+end

data/lib/tailmix/registry.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+require "singleton"
+require "set"
+
+module Tailmix
+  # A per-request registry to store unique component classes rendered
+  # during a request-response cycle.
+  class Registry
+    include Singleton
+
+    def initialize
+      @component_classes = Set.new
+    end
+
+    # Registers a component class.
+    # @param component_class [Class] The component class to register.
+    def register(component_class)
+      @component_classes.add(component_class)
+    end
+
+    # Gathers definitions from all registered classes.
+    # @return [Hash] A hash mapping component names to their definitions.
+    def definitions
+      @component_classes.each_with_object({}) do |klass, hash|
+        component_name = klass.name
+        if component_name && klass.respond_to?(:tailmix_definition)
+          hash[component_name] = klass.tailmix_definition.to_h
+        end
+      end
+    end
+
+    # Clears the registry. Must be called after each request.
+    def clear!
+      @component_classes.clear
+    end
+  end
+end

data/lib/tailmix/runtime/action_proxy.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Tailmix
+  module Runtime
+    # Proxy for convenient calling of actions (ui.action).
+    class ActionProxy
+      def initialize(context)
+        @context = context
+      end
+
+      def method_missing(method_name, *args, &block)
+        action_name = method_name.to_sym
+        action_def = @context.definition.actions[action_name]
+
+        unless action_def
+          raise NoMethodError, "undefined action `#{action_name}` for #{@context.component_name}"
+        end
+
+        # We return an object that can be called using .call.
+        # This allows you to write ui.action.save.call(payload)
+        ->(payload = {}) { @context.run_action(action_def, payload) }
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @context.definition.actions.key?(method_name.to_sym) || super
+      end
+    end
+  end
+end

data/lib/tailmix/runtime/attribute_builder.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Tailmix
+  module Runtime
+    class AttributeBuilder
+      def initialize(element_def, state, context)
+        @element_def = element_def
+        @state = state
+        @context = context
+      end
+
+      def build
+        attributes = create_base_attributes
+
+        apply_dimensions(attributes)
+        apply_compound_variants(attributes)
+        apply_attribute_bindings(attributes)
+        apply_model_bindings(attributes)
+        apply_event_bindings(attributes)
+
+        attributes
+      end
+
+      private
+
+      def create_base_attributes
+        base_attrs = @element_def.default_attributes.merge(
+          class: @element_def.attributes.classes
+        )
+        HTML::Attributes.new(base_attrs, element_name: @element_def.name, context: @context)
+      end
+
+      # Applies classes and data/aria attributes from `dimension`.
+      def apply_dimensions(attributes)
+        @element_def.dimensions.each do |name, dim_def|
+          value = @state[name] || dim_def[:default]
+          next if value.nil?
+
+          variant_def = dim_def.fetch(:variants, {}).fetch(value, nil)
+
+          next unless variant_def
+          attributes.classes.add(variant_def.classes)
+          attributes.data.merge!(variant_def.data)
+          attributes.aria.merge!(variant_def.aria)
+          attributes.merge!(variant_def.attributes)
+        end
+      end
+
+      # Applies classes and data/aria attributes from `compound_variant`.
+      def apply_compound_variants(attributes)
+        @element_def.compound_variants.each do |cv|
+          next unless cv[:on].all? { |key, value| @state[key] == value }
+
+          modifications = cv[:modifications]
+          attributes.classes.add(modifications.classes)
+          attributes.data.merge!(modifications.data) if modifications.data
+          attributes.aria.merge!(modifications.aria) if modifications.aria
+        end
+      end
+
+      # Applies one-way attribute bindings (`bind :src, to: :url`).
+      def apply_attribute_bindings(attributes)
+        @element_def.attribute_bindings&.each do |attr_name, state_key_or_proc|
+          next if %i[text html].include?(attr_name)
+
+          value = if state_key_or_proc.is_a?(Proc)
+            state_key_or_proc.call(@state)
+          else
+            @state[state_key_or_proc]
+          end
+          attributes[attr_name] = value if value
+        end
+      end
+
+      # Applies two-way bindings (`model :value, to: :query`).
+      def apply_model_bindings(attributes)
+        @element_def.model_bindings&.each do |attr_name, binding_def|
+          state_key = binding_def[:state]
+          value = @state[state_key]
+          attributes[attr_name] = value if value
+
+          # We are adding data attributes that will "bring to life" the client-side JS.
+          attributes.data.add("tailmix-model-attr": attr_name)
+          attributes.data.add("tailmix-model-state": state_key)
+          attributes.data.add("tailmix-model-event": binding_def[:event])
+          attributes.data.add("tailmix-model-action": binding_def[:action]) if binding_def[:action]
+        end
+      end
+
+      # Applies event handlers (`on :click, :save`).
+      def apply_event_bindings(attributes)
+        return unless @element_def.event_bindings&.any?
+
+        action_string = @element_def.event_bindings.map { |b| "#{b[:event]}->#{b[:action]}" }.join(" ")
+        with_map = @element_def.event_bindings.map { |b| b[:with] }.compact.reduce({}, :merge)
+
+        attributes.data.add(tailmix_action: action_string)
+        attributes.data.add(tailmix_action_with: with_map.to_json) unless with_map.empty?
+      end
+    end
+  end
+end

data/lib/tailmix/runtime/attribute_cache.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Tailmix
+  module Runtime
+    class AttributeCache
+      def initialize
+        @cache = {}
+      end
+
+      def get(element_name)
+        @cache[element_name.to_sym]
+      end
+
+      def set(element_name, attributes)
+        @cache[element_name.to_sym] = attributes
+      end
+
+      def clear!
+        @cache.clear
+      end
+    end
+  end
+end

data/lib/tailmix/runtime/context.rb

@@ -1,88 +1,77 @@
 # frozen_string_literal: true
+require "json"
+require_relative "../registry"
+require_relative "state"
+require_relative "state_proxy"
+require_relative "action_proxy"
+require_relative "attribute_cache"
+require_relative "attribute_builder"
 
 module Tailmix
   module Runtime
     class Context
-      attr_reader :component_instance, :definition, :dimensions
+      attr_reader :component_instance, :definition, :id, :state
 
-      def initialize(component_instance, definition, dimensions)
+      def initialize(component_instance, definition, initial_state = {}, id: nil)
         @component_instance = component_instance
         @definition = definition
-        @dimensions = dimensions
-        @attributes_cache = {}
-      end
+        @id = id
 
-      def initialize_copy(source)
-        super
-        @attributes_cache = source.instance_variable_get(:@attributes_cache).transform_values(&:dup)
-      end
+        @cache = AttributeCache.new
+        @state = State.new(definition.states, initial_state, cache: @cache)
 
-      def live_attributes_for(element_name)
-        @attributes_cache[element_name] ||= build_attributes_for(element_name, @dimensions)
+        Registry.instance.register(component_instance.class)
       end
 
-      def attributes_for(element_name, runtime_dimensions = {})
-        merged_dimensions = @dimensions.merge(runtime_dimensions)
-        return @attributes_cache[element_name] if merged_dimensions == @dimensions && @attributes_cache[element_name]
+      def state_proxy
+        @state_proxy ||= StateProxy.new(self)
+      end
 
-        attributes_object = build_attributes_for(element_name, merged_dimensions)
-        @attributes_cache[element_name] = attributes_object if merged_dimensions == @dimensions
-        attributes_object
+      def action_proxy
+        @action_proxy ||= ActionProxy.new(self)
       end
 
-      def action(name)
-        Action.new(self, name)
+      def run_action(action_def, payload)
+        action_def.transitions.each do |transition|
+          # Here we simulate what JS does on the client.
+          case transition[:type]
+          when :set
+            # Processing PayloadProxy, if it exists.
+            value = transition[:payload][:value]
+            if value.is_a?(Hash) && value[:__type] == 'payload_value'
+              set_state(transition[:payload][:key], payload[value[:key]])
+            else
+              set_state(transition[:payload][:key], value)
+            end
+          when :toggle
+            key = transition[:payload][:key]
+            set_state(key, !get_state(key))
+            # `refresh` and `dispatch` are purely client-side operations; we ignore them on the server.
+          end
+        end
       end
 
-      private
+      def attributes_for(element_name)
+        cached = @cache.get(element_name)
+        return cached if cached
 
-      def build_attributes_for(element_name, dimensions)
         element_def = @definition.elements.fetch(element_name)
 
-        active_dimensions = dimensions.slice(*element_def.dimensions.keys)
-        variant_string = active_dimensions.map { |k, v| "#{k}:#{v}" }.join(",")
-
-        attributes = HTML::Attributes.new(
-          { class: element_def.attributes.classes },
-          element_name: element_def.name,
-          variant_string: variant_string,
-          )
-
-        element_def.dimensions.each do |name, dim_def|
-          value = dimensions.fetch(name, dim_def[:default])
-          next if value.nil?
-
-          variant_def = dim_def.fetch(:variants, {}).fetch(value, nil)
-          next unless variant_def
-
-          attributes.classes.add(variant_def.classes)
-          attributes.data.merge!(variant_def.data)
-          attributes.aria.merge!(variant_def.aria)
-        end
-
-        element_def.compound_variants.each do |cv|
-          conditions = cv[:on]
-          modifications = cv[:modifications]
-
-          match = conditions.all? do |key, value|
-            dimensions[key] == value
-          end
+        attributes = AttributeBuilder.new(element_def, @state, self).build
+        @cache.set(element_name, attributes)
+        attributes
+      end
 
-          if match
-            attributes.classes.add(modifications.classes)
-            attributes.data.merge!(modifications.data)
-            attributes.aria.merge!(modifications.aria)
-          end
-        end
+      def component_name
+        @component_instance.class.name
+      end
 
-        Stimulus::Compiler.call(
-          definition: element_def.stimulus,
-          data_map: attributes.data,
-          root_definition: @definition,
-          component: @component_instance
-        )
+      def state_payload
+        @state.to_h.to_json
+      end
 
-        attributes
+      def definition_payload
+        @definition.to_h.to_json
       end
     end
   end

data/lib/tailmix/runtime/facade_builder.rb

@@ -6,15 +6,18 @@ module Tailmix
       def self.build(definition)
         Class.new(Tailmix::Runtime::Context) do
           definition.elements.each_key do |element_name|
-            define_method(element_name) do |runtime_dimensions = {}|
-              attributes_for(element_name, runtime_dimensions)
+            define_method(element_name) do
+              attributes_for(element_name)
             end
           end
 
+          alias_method :state, :state_proxy
+          alias_method :action, :action_proxy
+
           def inspect
-            component_name = @component_instance.class.name || "AnonymousComponent"
-            elements_list = @definition.elements.keys.join(", ")
-            "#<Tailmix::UI for #{component_name} elements=[#{elements_list}] dimensions=#{@dimensions.inspect}>"
+            # elements_list = @definition.elements.keys.join(", ")
+            #  "#<Tailmix::UI for #{component_name} elements=[#{elements_list}] dimensions=#{@dimensions.inspect}>"
+            "#<Tailmix::UI for #{component_name} state=#{get_state.inspect}>"
           end
         end
       end

data/lib/tailmix/runtime/state.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Tailmix
+  module Runtime
+    class State
+      def initialize(state_definition, initial_values, cache:)
+        @definition = state_definition
+        @cache = cache
+        @data = initialize_data(initial_values)
+      end
+
+      def [](key)
+        @data[key.to_sym]
+      end
+
+      def []=(key, value)
+        return if @data[key.to_sym] == value
+
+        @data[key.to_sym] = value
+        # Main reactive trigger: when the state changes – we clear the cache!
+        @cache.clear!
+      end
+
+      def to_h
+        @data
+      end
+
+      private
+
+      def initialize_data(initial_values)
+        defaults = @definition.transform_values { |v| v[:default] }
+        defaults.merge(initial_values.transform_keys(&:to_sym))
+      end
+    end
+  end
+end

data/lib/tailmix/runtime/state_proxy.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Tailmix
+  module Runtime
+    # Proxy for convenient access to the component state (ui.state).
+    class StateProxy
+      def initialize(context)
+        @context = context
+      end
+
+      def method_missing(method_name, *args, &block)
+        state_key = method_name.to_s.chomp("=").to_sym
+
+        # We are checking if this state is defined in the DSL.
+        unless @context.definition.states.key?(state_key)
+          raise NoMethodError, "undefined state `#{state_key}` for #{@context.component_name}"
+        end
+
+        if method_name.end_with?("=")
+          # This is a setter: ui.state.open = true
+          @context.set_state(state_key, args.first)
+        else
+          # This is a getter: ui.state.open
+          @context.get_state(state_key)
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        state_key = method_name.to_s.chomp("=").to_sym
+        @context.definition.states.key?(state_key) || super
+      end
+    end
+  end
+end

data/lib/tailmix/runtime.rb

@@ -3,7 +3,6 @@
 require "set"
 require_relative "runtime/context"
 require_relative "runtime/facade_builder"
-require_relative "runtime/stimulus/compiler"
 require_relative "html/attributes"
 require_relative "runtime/action"
 

data/lib/tailmix/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tailmix
-  VERSION = "0.4.7"
+  VERSION = "0.4.8"
 end

data/lib/tailmix/view_helpers.rb

@@ -0,0 +1,49 @@
+require "json"
+
+module Tailmix
+  ##
+  # Provides helper methods for rendering Tailmix component definitions and managing
+  # Tailmix-related data attributes in view templates.
+  module ViewHelpers
+    # Renders a script tag containing the definitions for all unique
+    # Tailmix components used on the current page.
+    def tailmix_definitions_tag
+      definitions = Tailmix::Registry.instance.definitions
+      return if definitions.empty?
+
+      json_payload = definitions.to_json
+
+      tag.script(
+        type: "application/json",
+        "data-tailmix-definitions": "true"
+      ) do
+        json_payload.html_safe
+      end
+    end
+
+    # Generates a hash of attributes for an external trigger that will control a named component instance.
+    #
+    # @param target_id [String, Symbol] Target component ID.
+    # @param action_name [String, Symbol] The name of the action to be called.
+    # @param options [Hash]
+    # @return [Hash]
+    def tailmix_trigger_for(target_id, action_name, options = {})
+      # target_id = options.fetch(:target_id)
+      # action_name = options.fetch(:action_name)
+
+      event_name = options.fetch(:event_name, :click)
+      with = options.fetch(:with, nil)
+
+      attributes = {
+        "data-tailmix-trigger-for" => target_id.to_s,
+        "data-tailmix-action" => "#{event_name}->#{action_name}"
+      }
+
+      if with
+        attributes["data-tailmix-action-payload"] = with.to_json
+      end
+
+      attributes
+    end
+  end
+end

data/lib/tailmix.rb

@@ -5,6 +5,8 @@ require_relative "tailmix/configuration"
 require_relative "tailmix/dsl"
 require_relative "tailmix/definition"
 require_relative "tailmix/runtime"
+require_relative "tailmix/middleware/registry_cleaner"
+require_relative "tailmix/view_helpers"
 
 module Tailmix
   class Error < StandardError; end
@@ -25,8 +27,8 @@ module Tailmix
     base.extend(DSL)
   end
 
-  def tailmix(dimensions = {})
-    self.class.tailmix_facade_class.new(self, self.class.tailmix_definition, dimensions)
+  def tailmix(id: nil, **initial_state)
+    self.class.tailmix_facade_class.new(self, self.class.tailmix_definition, initial_state, id: id)
   end
 end