tailmix 0.4.7 → 0.4.8

data/lib/tailmix/definition/builders/action_builder.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require_relative "../payload_proxy"
+
+module Tailmix
+  module Definition
+    module Builders
+      class ActionBuilder
+        def initialize
+          @transitions = []
+        end
+
+        def set(state_key, value)
+          processed_value = if value.is_a?(PayloadValue)
+            { __type: 'payload_value', key: value.key }
+          else
+            value
+          end
+          @transitions << { type: :set, payload: { key: state_key.to_sym, value: processed_value } }
+        end
+
+        def toggle(state_key)
+          @transitions << { type: :toggle, payload: { key: state_key.to_sym } }
+        end
+
+        def refresh(state_key, params: {})
+          @transitions << { type: :refresh, payload: { key: state_key.to_sym, params: params } }
+        end
+
+        def dispatch(event_name, detail: {})
+          @transitions << { type: :dispatch, payload: { name: event_name, detail: detail } }
+        end
+
+        def build_definition
+          Result::Action.new(transitions: @transitions.freeze)
+        end
+      end
+    end
+  end
+end

data/lib/tailmix/definition/{contexts → builders}/actions/element_builder.rb

@@ -2,7 +2,7 @@
 
 module Tailmix
   module Definition
-    module Contexts
+    module Builders
       module Actions
         class ElementBuilder
           def initialize(default_method)

data/lib/tailmix/definition/{contexts → builders}/attribute_builder.rb

@@ -2,7 +2,7 @@
 
 module Tailmix
   module Definition
-    module Contexts
+    module Builders
       class AttributeBuilder
         def initialize
           @classes = []

data/lib/tailmix/definition/builders/component_builder.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "action_builder"
+require_relative "element_builder"
+require_relative "reactor_builder"
+require_relative "../payload_proxy"
+
+module Tailmix
+  module Definition
+    module Builders
+      class ComponentBuilder
+        attr_reader :component_name
+
+        def initialize(component_name:)
+          @states = {}
+          @actions = {}
+          @elements = {}
+          @component_name = component_name
+          @plugins = {}
+          @reactions = {}
+        end
+
+        def state(name, default: nil, endpoint: nil, toggle: false)
+          @states[name.to_sym] = { default: default, endpoint: endpoint }.compact
+          if toggle
+            action_name = :"toggle_#{name}"
+            action(action_name) { toggle name }
+          end
+        end
+
+        def action(name, &block)
+          builder = ActionBuilder.new
+          builder.instance_exec(PayloadProxy.new, &block)
+          @actions[name.to_sym] = builder
+        end
+
+        def element(name, classes = "", &block)
+          builder = ElementBuilder.new(name)
+          builder.attributes.classes(classes.split)
+          builder.instance_eval(&block) if block
+          @elements[name.to_sym] = builder
+        end
+
+        def plugin(name, options = {})
+          plugin_name = name.to_s.gsub(/_([a-z])/) { $1.upcase }
+          @plugins[plugin_name] = options
+        end
+
+        def react(on:, run: nil, **options, &block)
+          watched_states = Array(on)
+
+          # Processing the short form: `react on: :query, run: :search`
+          if run
+            builder = ReactorBuilder.new(watched_states.first)
+            builder.run(run, **options)
+            watched_states.each { |state| (@reactions[state] ||= []).concat(builder.build_rules) }
+            return
+          end
+
+          # Processing the full form with the block.
+          if block
+            builder = ReactorBuilder.new(watched_states.first)
+            builder.instance_eval(&block) # `instance_eval` чтобы не писать `r.`
+            watched_states.each { |state| (@reactions[state] ||= []).concat(builder.build_rules) }
+          end
+        end
+
+        def build_definition
+          Result::Context.new(
+            name: component_name,
+            states: @states.freeze,
+            actions: @actions.transform_values(&:build_definition).freeze,
+            elements: @elements.transform_values(&:build_definition).freeze,
+            reactions: @reactions.freeze,
+            plugins: @plugins.freeze
+          )
+        end
+      end
+    end
+  end
+end

data/lib/tailmix/definition/{contexts → builders}/dimension_builder.rb

@@ -4,7 +4,7 @@ require_relative "variant_builder"
 
 module Tailmix
   module Definition
-    module Contexts
+    module Builders
       class DimensionBuilder
         def initialize(default: nil)
           @variants = {}
@@ -13,12 +13,12 @@ module Tailmix
 
         def variant(name, classes = "", data: {}, aria: {}, &block)
           builder = VariantBuilder.new
+
           builder.classes(classes) if classes && !classes.empty?
           builder.data(data)
           builder.aria(aria)
 
           builder.instance_eval(&block) if block
-
           @variants[name] = builder.build_variant
         end
 

data/lib/tailmix/definition/builders/element_builder.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "attribute_builder"
+require_relative "dimension_builder"
+require_relative "variant_builder"
+
+module Tailmix
+  module Definition
+    module Builders
+      class ElementBuilder
+        def initialize(name)
+          @name = name
+          @default_attributes = {}
+          @dimensions = {}
+          @compound_variants = []
+          @event_bindings = []
+          @attribute_bindings = {}
+          @model_bindings = {}
+        end
+
+        def attributes
+          @attributes_builder ||= AttributeBuilder.new
+        end
+
+        def method_missing(name, *args, &block)
+          attribute_name = name.to_s.chomp("=").to_sym
+          @default_attributes[attribute_name] = args.first
+        end
+
+        def respond_to_missing?(*_args)
+          true
+        end
+
+        def on(event_name, action_name, with: nil, **options)
+          # `with` mapping: `{ payload_key => state_key }`
+          @event_bindings << { event: event_name, action: action_name, with: with, options: options }
+        end
+
+        def bind(attribute_name, to:)
+          @attribute_bindings[attribute_name.to_sym] = to.to_sym
+        end
+
+        def model(attribute_name, to:, on: :input, action: nil, debounce: nil)
+          @model_bindings[attribute_name.to_sym] = {
+            state: to.to_sym,
+            event: on,
+            action: action,
+            debounce: debounce
+          }.compact
+        end
+
+        def dimension(name, &block)
+          builder = DimensionBuilder.new
+          builder.instance_eval(&block)
+          @dimensions[name.to_sym] = builder.build_dimension
+        end
+
+        def compound_variant(on:, &block)
+          builder = VariantBuilder.new
+          builder.instance_eval(&block)
+
+          @compound_variants << {
+            on: on,
+            modifications: builder.build_variant
+          }
+        end
+
+        def build_definition
+          Result::Element.new(
+            name: @name,
+            attributes: attributes.build_definition,
+            default_attributes: @default_attributes.freeze,
+            dimensions: @dimensions.freeze,
+            compound_variants: @compound_variants.freeze,
+            event_bindings: @event_bindings.freeze,
+            attribute_bindings: @attribute_bindings.freeze,
+            model_bindings: @model_bindings.freeze
+          )
+        end
+      end
+    end
+  end
+end

data/lib/tailmix/definition/builders/reactor_builder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require_relative "rule_builder"
+
+module Tailmix
+  module Definition
+    module Builders
+      class ReactorBuilder
+        def initialize(watched_state)
+          @watched_state = watched_state
+          @rules = []
+        end
+
+        # Start a method for the rule chain: r.value("commercial")
+        def value(expected_value)
+          rule_builder = RuleBuilder.new(@watched_state)
+          rule_builder.value(expected_value)
+          @rules << rule_builder
+          rule_builder
+        end
+
+        # Alternative startup method: r.state(:zip_code)
+        def state(state_key)
+          rule_builder = RuleBuilder.new(state_key)
+          @rules << rule_builder
+          rule_builder
+        end
+
+        # Unconditional effect (always triggers on change)
+        def run(action_name, with: nil)
+          # We create an "empty" rule with a condition that is always true.
+          rule_builder = RuleBuilder.new(nil)
+          rule_builder.instance_variable_set(:@rule, { condition: { type: :always_true } })
+          rule_builder.run(action_name, with: with)
+          @rules << rule_builder
+        end
+
+        def build_rules
+          @rules.map(&:build_rule)
+        end
+      end
+    end
+  end
+end

data/lib/tailmix/definition/builders/rule_builder.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Tailmix
+  module Definition
+    module Builders
+      class RuleBuilder
+        def initialize(source_state_key)
+          @rule = { condition: { type: :eql, source: { type: :state, key: source_state_key } } }
+        end
+
+        def value(expected_value)
+          @rule[:condition][:value] = expected_value
+          self
+        end
+        alias_method :is, :value
+
+        def is_not(expected_value)
+          @rule[:condition][:type] = :not_eql
+          @rule[:condition][:value] = expected_value
+          self
+        end
+
+        def is_truthy
+          @rule[:condition][:type] = :truthy
+          self
+        end
+
+        def set_state(payload)
+          add_effect(:set_state, payload: payload)
+        end
+
+        def run(action_name, with: nil)
+          add_effect(:run_action, name: action_name, with: with)
+        end
+
+        def dispatch(event_name, detail: {})
+          add_effect(:dispatch_event, name: event_name, detail: detail)
+        end
+
+        def call(element_name, method_name, *args)
+          add_effect(:call_method, element: element_name, method: method_name, args: args)
+        end
+
+        def build_rule
+          @rule
+        end
+
+        private
+
+        def add_effect(type, **payload)
+          @rule[:effects] ||= []
+          @rule[:effects] << { type: type, payload: payload }
+          self
+        end
+      end
+    end
+  end
+end

data/lib/tailmix/definition/builders/state_builder.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Tailmix
+  module Definition
+    module Builders
+      class StateBuilder
+        def initialize
+          @data_source = {}
+        end
+
+        def endpoint(method, url:)
+          @data_source = { method: method, url: url }
+        end
+
+        def build_data_source
+          @data_source.empty? ? nil : @data_source.freeze
+        end
+      end
+    end
+  end
+end

data/lib/tailmix/definition/{contexts → builders}/variant_builder.rb

@@ -2,12 +2,13 @@
 
 module Tailmix
   module Definition
-    module Contexts
+    module Builders
       class VariantBuilder
         def initialize
           @class_groups = []
           @data = {}
           @aria = {}
+          @attributes = {}
         end
 
         def classes(class_string, options = {})
@@ -22,11 +23,25 @@ module Tailmix
           @aria.merge!(hash)
         end
 
+        def method_missing(name, *args, &block)
+          # `disabled true` -> { disabled: true }
+          # `placeholder "text"` -> { placeholder: "text" }
+          # `type "password"` -> { type: "password" }
+          attribute_name = name.to_s.chomp("=").to_sym
+          value = args.first
+          @attributes[attribute_name] = value
+        end
+
+        def respond_to_missing?(*_args)
+          true
+        end
+
         def build_variant
           Definition::Result::Variant.new(
             class_groups: @class_groups.freeze,
             data: @data.freeze,
-            aria: @aria.freeze
+            aria: @aria.freeze,
+            attributes: @attributes.freeze
           )
         end
       end

data/lib/tailmix/definition/context_builder.rb

@@ -1,36 +1,41 @@
 # frozen_string_literal: true
 
-require_relative "contexts/action_builder"
-require_relative "contexts/element_builder"
-require_relative "contexts/variant_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,
         )

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
           {
-            elements: elements.transform_values(&:to_h),
+            name: name,
+            states: states,
             actions: actions.transform_values(&:to_h),
+            elements: elements.transform_values(&:to_h),
+            plugins: plugins,
+            reactions: reactions
           }
         end
       end
 
-      Element = Struct.new(:name, :attributes, :dimensions, :stimulus, :compound_variants, 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,13 +34,14 @@ module Tailmix
                 end
               end
             end,
-            stimulus: stimulus.to_h,
-            compound_variants: compound_variants
+            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
@@ -45,7 +51,8 @@ module Tailmix
             classes: classes,
             class_groups: class_groups,
             data: data,
-            aria: aria
+            aria: aria,
+            attributes: attributes
           }
         end
       end
@@ -58,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,12 +18,8 @@ module Tailmix
         output << ""
 
         output << generate_dimensions_docs
-        output << ""
-        output << generate_compound_variants_docs # <-- Наш новый метод
-        output << ""
+        output << generate_compound_variants_docs
         output << generate_actions_docs
-        output << ""
-        output << generate_stimulus_docs
 
         output.join("\n")
       end
@@ -70,6 +66,7 @@ module Tailmix
         end
 
         if compound_variants_by_element.any?
+          output << ""
           output << "Compound Variants:"
           compound_variants_by_element.each do |element|
             output << "  - on element `:#{element.name}`:"
@@ -86,6 +83,7 @@ module Tailmix
               output << "      - aria: #{modifications.aria.inspect}" if modifications.aria.any?
             end
           end
+          output << ""
         end
 
         output.join("\n")
@@ -107,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