tailmix 0.4.6 → 0.4.8

data/lib/tailmix/definition/contexts/stimulus_builder.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module Tailmix
-  module Definition
-    module Contexts
-      class StimulusBuilder
-        attr_reader :definitions
-
-        def initialize
-          @definitions = []
-          @current_context = nil
-        end
-
-        def controller(name)
-          @definitions << { type: :controller, name: name }
-          context(name)
-        end
-        alias_method :ctr, :controller
-
-        def context(name)
-          @current_context = name.to_s
-          self
-        end
-        alias_method :ctx, :context
-
-        def target(target_name)
-          raise "A controller context must be set..." unless @current_context
-          @definitions << { type: :target, controller: @current_context, name: target_name }
-          self
-        end
-
-        def action(*args)
-          ensure_context!
-
-          action_data = case args.first
-          when String
-            { type: :raw, content: args.first }
-          when Hash
-            { type: :hash, content: args.first }
-          else
-            { type: :tuple, content: args }
-          end
-
-          @definitions << { type: :action, controller: @current_context, data: action_data }
-          self
-        end
-
-        def value(value_name, value: nil, call: nil, method: nil)
-          ensure_context!
-
-          source = if !value.nil?
-            { type: :literal, content: value }
-          elsif call.is_a?(Proc)
-            { type: :proc, content: call }
-          elsif method.is_a?(Symbol) || method.is_a?(String)
-            { type: :method, content: method.to_sym }
-          else
-            raise ArgumentError, "You must provide one of value:, call:, or method: keyword arguments."
-          end
-
-          @definitions << {
-            type: :value,
-            controller: @current_context,
-            name: value_name,
-            source: source
-          }
-          self
-        end
-
-        def action_payload(action_name, as: nil)
-          ensure_context!
-          value_name = as || "#{action_name}_action"
-
-          @definitions << {
-            type: :action_payload,
-            controller: @current_context,
-            action_name: action_name.to_sym,
-            value_name: value_name.to_sym
-          }
-          self
-        end
-
-        def param(params_hash)
-          ensure_context!
-          @definitions << { type: :param, controller: @current_context, params: params_hash }
-          self
-        end
-
-        def build_definition
-          Definition::Result::Stimulus.new(definitions: @definitions.freeze)
-        end
-
-        private
-
-        def ensure_context!
-          raise "A controller context must be set via .controller() or .context() before this call." unless @current_context
-        end
-      end
-    end
-  end
-end

data/lib/tailmix/dev/stimulus_generator.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-module Tailmix
-  module Dev
-    class StimulusGenerator
-      def initialize(definition, component_name)
-        @definition = definition
-        @component_name = component_name
-        @stimulus_defs = definition.elements.values.flat_map(&:stimulus).flat_map(&:definitions)
-      end
-
-      def scaffold(controller_name = nil, show_docs: false)
-        controllers_to_generate = controller_name ? [ controller_name.to_s ] : all_controllers
-
-        output = controllers_to_generate.map do |name|
-          defs = @stimulus_defs.select { |d| d[:controller] == name }
-
-          show_docs ? generate_docs_for(name, defs) + "\n" : generate_js_for(name, defs) + ("-" * 60) + "\n"
-        end
-        output.join("\n")
-      end
-
-      private
-
-      def generate_docs_for(controller_name, defs)
-        output = [ "Stimulus:" ]
-        output << "  - on `#{controller_name}` controller:"
-        targets = defs.select { |d| d[:type] == :target }.map { |d| d[:name] }
-        output << "    - Targets: #{targets.join(', ')}" if targets.any?
-
-        actions = action_methods(defs)
-        output << "    - Actions: #{actions.join(', ')}" if actions.any?
-
-        values = defs.select { |d| d[:type] == :value }.map { |d| d[:name] }
-        output << "    - Values: #{values.join(', ')}" if values.any?
-
-        output.join("\n")
-      end
-
-      def generate_js_for(controller_name, defs)
-        targets = defs.select { |d| d[:type] == :target }.map { |d| "'#{d[:name]}'" }.uniq.join(", ")
-
-        payload_actions = defs.select { |d| d[:type] == :action_payload }
-        simple_values = defs.select { |d| d[:type] == :value }
-
-        value_names = (payload_actions.map { |d| d[:value_name] } + simple_values.map { |d| d[:name] })
-          .uniq.map { |name| "#{snake_to_camel(name.to_s)}: Object" }.join(", ")
-
-        isomorphic_methods = payload_actions.map do |payload_def|
-          action_name_camel = snake_to_camel(payload_def[:action_name].to_s)
-          value_name_camel = snake_to_camel(payload_def[:value_name].to_s)
-
-          "  #{action_name_camel}(event) {\n     if (event) event.preventDefault();\n     Tailmix.run({ config: this.#{value_name_camel}Value, controller: this });\n  }"
-        end.join.strip
-
-        standard_action_names = defs.select { |d| d[:type] == :action }
-                                    .flat_map { |d| extract_action_methods(d[:data]) }
-                                    .uniq
-
-        implemented_action_names = payload_actions.map { |d| d[:action_name].to_s }
-        stub_methods = (standard_action_names - implemented_action_names).map do |method_name|
-          method_name_camel = snake_to_camel(method_name)
-          "  #{method_name_camel}() {\n    console.log('#{controller_name}##{method_name_camel} fired');\n  }"
-        end.join("\n\n")
-
-        js_methods = [isomorphic_methods, stub_methods].reject(&:empty?).join("\n\n")
-
-        <<~JAVASCRIPT
-          // Generated by Tailmix for the "#{controller_name}" controller
-          // Path: app/javascript/controllers/#{controller_name.tr('_', '-')}_controller.js
-          import { Controller } from "@hotwired/stimulus"
-          import Tailmix from "tailmix"
-
-          export default class extends Controller {
-            static targets = [#{targets}]
-            static values = { #{value_names} }
-
-            connect() {
-              console.log("#{controller_name} controller connected to", this.element);
-            }
-            #{js_methods}
-          }
-        JAVASCRIPT
-      end
-
-      def extract_action_methods(action_data)
-        case action_data[:type]
-        when :raw
-          action_data[:content].to_s.scan(/#(\w+)/).flatten
-        when :hash
-          action_data[:content].values.map(&:to_s)
-        when :tuple
-          [action_data[:content][1].to_s]
-        else
-          []
-        end
-      end
-
-      def all_controllers
-        @stimulus_defs.map { |d| d[:controller] }.compact.uniq
-      end
-
-      def action_methods(defs)
-        defs.select { |d| d[:type] == :action }.flat_map do |action_definition|
-          data = action_definition[:data]
-          case data[:type]
-          when :raw
-            data[:content].to_s.scan(/#(\w+)/).flatten
-          when :hash
-            data[:content].values.map(&:to_s)
-          when :tuple
-            [ data[:content][1].to_s ]
-          else
-            []
-          end
-        end.uniq
-      end
-
-      def snake_to_camel(str)
-        str.split("_").map.with_index { |word, i| i.zero? ? word : word.capitalize }.join
-      end
-    end
-  end
-end

data/lib/tailmix/runtime/stimulus/compiler.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Tailmix
-  module Runtime
-    module Stimulus
-      class Compiler
-
-        def self.call(definition:, data_map:, root_definition:, component:)
-          (definition.definitions || []).each do |rule|
-            builder = data_map.stimulus
-
-            case rule[:type]
-            when :controller
-              builder.controller(rule[:name])
-            when :action
-              action_data = rule[:data]
-              controller_name = rule[:controller]
-
-              action_string = case action_data[:type]
-              when :raw
-                action_data[:content]
-              when :hash
-                action_data[:content].map { |event, method| "#{event}->#{controller_name}##{method}" }.join(" ")
-              when :tuple
-                event, method = action_data[:content]
-                "#{event}->#{controller_name}##{method}"
-              end
-
-              builder.context(controller_name).action(action_string)
-            when :target
-              builder.context(rule[:controller]).target(rule[:name])
-            when :value
-              source = rule[:source]
-
-              resolved_value = case source[:type]
-              when :literal
-                source[:content]
-              when :proc
-                source[:content].call
-              when :method
-                component.public_send(source[:content])
-              else
-                # type code here
-              end
-
-              builder.context(rule[:controller]).value(rule[:name], resolved_value)
-
-            when :param
-              builder.context(rule[:controller]).param(rule[:params])
-            when :action_payload
-              action = root_definition.actions.fetch(rule[:action_name])
-              builder.context(rule[:controller]).value(rule[:value_name], action.to_h)
-            end
-          end
-        end
-      end
-    end
-  end
-end