tailmix 0.4.6 → 0.4.8

data/lib/tailmix/definition/context_builder.rb

@@ -1,39 +1,45 @@
 # frozen_string_literal: true
 
-require_relative "contexts/action_builder"
-require_relative "contexts/element_builder"
+require_relative "builders/action_builder"
+require_relative "builders/element_builder"
+require_relative "builders/variant_builder"
+require_relative "payload_proxy"
 
 module Tailmix
   module Definition
     class ContextBuilder
-      attr_reader :elements, :actions
+      attr_reader :elements, :actions, :component_name
 
-      def initialize
+      def initialize(component_name:)
         @elements = {}
         @actions = {}
+        @component_name = component_name
       end
 
-      def element(name, base_classes = "", &block)
-        builder = Contexts::ElementBuilder.new(name)
-        builder.attributes.classes(base_classes.split)
+      def element(name, classes = "", &block)
+        builder = Builders::ElementBuilder.new(name)
+        builder.attributes.classes(classes.split)
 
         builder.instance_eval(&block) if block
-
         @elements[name.to_sym] = builder
+
+        @actions.merge!(builder.auto_actions)
       end
 
-      def action(name, method:, &block)
-        builder = Contexts::ActionBuilder.new(method)
-        builder.instance_eval(&block) if block
+      def action(name, &block)
+        builder = Builders::ActionBuilder.new
+        proxy = Builders::PayloadProxy.new
+        builder.instance_exec(proxy, &block)
         @actions[name.to_sym] = builder
       end
 
       def build_definition
         Definition::Result::Context.new(
+          name: component_name,
           elements: @elements.transform_values(&:build_definition).freeze,
-          actions: @actions.transform_values(&:build_definition).freeze
+          actions: @actions.transform_values(&:build_definition).freeze,
         )
       end
     end
   end
-end
+end

data/lib/tailmix/definition/merger.rb

@@ -47,7 +47,8 @@ module Tailmix
           name: parent_el.name,
           attributes: merge_attributes(parent_el.attributes, child_el.attributes),
           dimensions: merge_dimensions(parent_el.dimensions, child_el.dimensions),
-          stimulus: merge_stimulus(parent_el.stimulus, child_el.stimulus)
+          stimulus: merge_stimulus(parent_el.stimulus, child_el.stimulus),
+          compound_variants: parent_el.compound_variants + child_el.compound_variants
         )
       end
 

data/lib/tailmix/definition/payload_proxy.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Tailmix
+  module Definition
+    # A marker indicating that the value should be taken from the runtime payload.
+    PayloadValue = Struct.new(:key)
+
+    # A proxy object that is passed to the `action do |payload|` block.
+    # It creates PayloadValue markers instead of containing the actual data.
+    class PayloadProxy
+      def [](key)
+        PayloadValue.new(key.to_sym)
+      end
+    end
+  end
+end

data/lib/tailmix/definition/result.rb

@@ -3,20 +3,25 @@
 module Tailmix
   module Definition
     module Result
-      Context = Struct.new(:elements, :actions, keyword_init: true) do
+      Context = Struct.new(:name, :states, :actions, :elements, :plugins, :reactions, keyword_init: true) do
         def to_h
           {
+            name: name,
+            states: states,
+            actions: actions.transform_values(&:to_h),
             elements: elements.transform_values(&:to_h),
-            actions: actions.transform_values(&:to_h)
+            plugins: plugins,
+            reactions: reactions
           }
         end
       end
 
-      Element = Struct.new(:name, :attributes, :dimensions, :stimulus, keyword_init: true) do
+      Element = Struct.new(:name, :attributes, :dimensions, :compound_variants, :event_bindings, :attribute_bindings, :model_bindings, :default_attributes, keyword_init: true) do
         def to_h
           {
             name: name,
             attributes: attributes.to_h,
+            default_attributes: default_attributes,
             dimensions: dimensions.transform_values do |dimension|
               dimension.transform_values do |value|
                 case value
@@ -29,12 +34,14 @@ module Tailmix
                 end
               end
             end,
-            stimulus: stimulus.to_h
+            compound_variants: compound_variants,
+            attribute_bindings: attribute_bindings,
+            model_bindings: model_bindings,
           }
         end
       end
 
-      Variant = Struct.new(:class_groups, :data, :aria, keyword_init: true) do
+      Variant = Struct.new(:class_groups, :data, :aria, :attributes, keyword_init: true) do
         def classes
           class_groups.flat_map { |group| group[:classes] }
         end
@@ -44,7 +51,8 @@ module Tailmix
             classes: classes,
             class_groups: class_groups,
             data: data,
-            aria: aria
+            aria: aria,
+            attributes: attributes
           }
         end
       end
@@ -57,22 +65,13 @@ module Tailmix
         end
       end
 
-      Stimulus = Struct.new(:definitions, keyword_init: true) do
-        def to_h
-          {
-            definitions: definitions
-          }
-        end
-      end
-
-      Action = Struct.new(:action, :mutations, keyword_init: true) do
+      Action = Struct.new(:transitions, keyword_init: true) do
         def to_h
           {
-            action: action,
-            mutations: mutations
+            transitions: transitions,
           }
         end
       end
     end
   end
-end
+end

data/lib/tailmix/dev/docs.rb

@@ -18,10 +18,8 @@ module Tailmix
         output << ""
 
         output << generate_dimensions_docs
-        output << ""
+        output << generate_compound_variants_docs
         output << generate_actions_docs
-        output << ""
-        output << generate_stimulus_docs
 
         output.join("\n")
       end
@@ -60,6 +58,37 @@ module Tailmix
         output.join("\n")
       end
 
+      def generate_compound_variants_docs
+        output = []
+
+        compound_variants_by_element = @definition.elements.values.select do |el|
+          el.compound_variants.any?
+        end
+
+        if compound_variants_by_element.any?
+          output << ""
+          output << "Compound Variants:"
+          compound_variants_by_element.each do |element|
+            output << "  - on element `:#{element.name}`:"
+            element.compound_variants.each do |cv|
+              conditions = cv[:on].map { |k, v| "#{k}: :#{v}" }.join(", ")
+              output << "    - on: { #{conditions} }"
+
+              modifications = cv[:modifications]
+              modifications.class_groups.each do |group|
+                label = group[:options][:group] ? "(group: :#{group[:options][:group]})" : ""
+                output << "      - classes #{label}: \"#{group[:classes].join(' ')}\""
+              end
+              output << "      - data: #{modifications.data.inspect}" if modifications.data.any?
+              output << "      - aria: #{modifications.aria.inspect}" if modifications.aria.any?
+            end
+          end
+          output << ""
+        end
+
+        output.join("\n")
+      end
+
       def generate_actions_docs
         output = []
         actions = @definition.actions
@@ -76,10 +105,6 @@ module Tailmix
         output.join("\n")
       end
 
-      def generate_stimulus_docs
-        @tools.stimulus.scaffold(show_docs: true)
-      end
-
       def all_dimensions
         @_all_dimensions ||= @definition.elements.values.flat_map(&:dimensions).reduce({}, :merge)
       end

data/lib/tailmix/dev/tools.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "stimulus_generator"
 require_relative "docs"
 
 module Tailmix
@@ -18,10 +17,6 @@ module Tailmix
       end
       alias_method :help, :docs
 
-      def stimulus
-        StimulusGenerator.new(@definition, @component_class.name)
-      end
-
       def elements
         @definition.elements.values.map(&:name)
       end

data/lib/tailmix/dsl.rb

@@ -1,15 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "definition/context_builder"
+require_relative "definition/builders/component_builder"
 require_relative "definition/merger"
 require_relative "dev/tools"
 
 module Tailmix
-  # The main DSL for defining component styles and behaviors.
-  # This module is extended into any class that includes Tailmix.
   module DSL
     def tailmix(&block)
-      child_context = Definition::ContextBuilder.new
+      child_context = Definition::Builders::ComponentBuilder.new(component_name: self)
       child_context.instance_eval(&block)
       child_definition = child_context.build_definition
 
@@ -32,4 +30,4 @@ module Tailmix
       Dev::Tools.new(self)
     end
   end
-end
+end

data/lib/tailmix/engine.rb

@@ -6,12 +6,22 @@ module Tailmix
       Rails.application.config.assets.paths << Engine.root.join("app/javascript")
     end
 
-    PRECOMPILE_ASSETS = %w[ index.js runner.js finder.js mutator.js stimulus_adapter.js ]
+    PRECOMPILE_ASSETS = %w[ runtime/action_dispatcher.js runtime/component.js runtime/updater.js runtime/index.js runtime/plugins.js ]
 
     initializer "tailmix.assets" do
       if Rails.application.config.respond_to?(:assets)
         Rails.application.config.assets.precompile += PRECOMPILE_ASSETS
       end
     end
+
+    initializer "tailmix.add_middleware" do |app|
+      app.middleware.use Tailmix::Middleware::RegistryCleaner
+    end
+
+    initializer "tailmix.helpers" do
+      ActiveSupport.on_load(:action_controller_base) do
+        helper Tailmix::ViewHelpers
+      end
+    end
   end
 end

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