stimulus_tag_helper 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a65ec6e3ca5fbdb0773a81dd380c4ca366e3de6dc30f5e00d45c8d7371c03a25
-  data.tar.gz: d0593dc01c202aa3de8364b7e48eb97d6cb27a8cd5b1435442756fa7e46683ce
+  metadata.gz: 8ff2c2c234e2e424625b92771a01e0d91a0e9022f197c95a2db0f567fa030b40
+  data.tar.gz: 346032a31e1beb29637638ebac298294b06e5ff8e6e0e82df1245a3da1c73036
 SHA512:
-  metadata.gz: 5e15a8b9cbc3f422577d967807f7b22fe1c4f9d9c6b947f26bc0ac678a422e0088b4c584e25bf2c2959ad97e7d549cf235b8c8e54c58a2baf5f445cfd0d7d88b
-  data.tar.gz: b2837afeee0dac24ad6abe6ff12cebae2c3ba1510bb126f447eaf30383317148d42ddeba86ab707dc6823e0fccf40417547d2cdf6cb054fb5a0083752d6721a4
+  metadata.gz: 28d2e85611dafc3d1f2e299f9db2662fa14a178d11a0b8f96930a7e50b037a022c468da97a98ced7320e234f3e129d0a4bdc43de9f741bc93406283f6919f6a4
+  data.tar.gz: 9e213aa8a8789b0dd92f05a6e248500f019c34273b7de5397547b5493c2a9656ca288ab8e5a37608c3e80c49c289deca6af8eb1ab05bef99c58280e0b41ae61b

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2021 Anton Topchii
+Copyright (c) 2022 Anton Topchii
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/lib/stimulus_tag_helper/stimulus_controller_builder.rb

@@ -2,30 +2,56 @@
 
 module StimulusTagHelper
   class StimulusControllerBuilder
-    def initialize(identifier:, template:)
+    class << self
+      delegate :properties, :aliases, :attribute_method_name_for, :property_method_name_for, to: StimulusTagHelper
+    end
+
+    attr_reader :identifier, :template, :tag, :tag_options
+
+    # all the options are tag options of now
+    def initialize(identifier:, template:, tag: nil, **tag_options)
       @identifier = identifier
       @template = template
+      @tag = tag
+      @tag_options = tag_options
     end
 
-    StimulusTagHelper.property_names.each do |name|
-      name = name.to_s
-      attribute, property = name.pluralize == name ? %w[attributes properties] : %w[attribute property]
+    properties.each do |name|
+      attribute_method_name = attribute_method_name_for(name)
+      property_method_name = property_method_name_for(name)
+      alias_name = aliases[name]
 
       class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-        def #{name}_#{attribute}(...)         # def value_attribute(...)
-          { data: #{name}_#{property}(...) }  #   { data: value_property(...) }
-        end                                   # end
+        def #{name}(*args, **kwargs)                                                        # def values(*args, **kwargs)
+          template.stimulus_#{attribute_method_name}(*args.unshift(identifier), **kwargs)   #   template.stimulus_values_attributes(*args.unshift(identifier), **kwargs)
+        end                                                                                 # end
 
-        alias #{name} #{name}_#{attribute} # alias value value_attribute
+        alias_method :#{alias_name}, :#{name}                                               # alias_method :value, :values
+        alias_method :#{attribute_method_name}, :#{name}                                    # alias_method :values_attributes, :values
+        alias_method :#{alias_name}_attribute, :#{name}                                     # alias_method :value_attribute, :values
 
-        def #{name}_#{property}(*args, **kwargs)                                        # def value_property(*args, **kwargs)
-          @template.stimulus_#{name}_#{property}(*args.unshift(@identifier), **kwargs)  #   stimulus_value_property(@identifier, *args, **kwargs)
-        end                                                                             # end
+        def #{property_method_name}(*args, **kwargs)                                        # def values_properties(*args, **kwargs)
+          template.stimulus_#{property_method_name}(*args.unshift(identifier), **kwargs)    #   template.stimulus_values_properties(*args.unshift(identifier), **kwargs)
+        end                                                                                 # end
+
+        alias_method :#{alias_name}_property, :#{property_method_name}                      # alias_method :value_property, :values_properties
       RUBY
     end
 
     def attributes(**attributes)
-      @template.stimulus_attributes(@identifier, **attributes)
+      template.stimulus_attributes(identifier, **attributes)
+    end
+
+    def properties(**properties)
+      template.stimulus_properties(identifier, **properties)
+    end
+
+    def capture(&block)
+      return template.capture(self, &block) unless tag
+
+      template.stimulus_controller_tag(identifier, tag: tag, **tag_options) do
+        template.capture(self, &block)
+      end
     end
   end
 end

data/lib/stimulus_tag_helper/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StimulusTagHelper
-  VERSION = "0.2.0"
+  VERSION = "0.3.1"
 end

data/lib/stimulus_tag_helper.rb

@@ -5,25 +5,34 @@ require "zeitwerk"
 Zeitwerk::Loader.for_gem.setup
 
 module StimulusTagHelper
-  def self.base_properties
-    %i[controller values classes targets target actions].freeze
+  def self.properties
+    %i[controllers values classes targets actions].freeze
   end
 
   def self.aliases
-    {controller: :controllers, value: :values, class: :classes, target: :targets, action: :actions}.freeze
+    @aliases ||=
+      properties.map { |property| [property.to_s.singularize.to_sym, property] }.to_h.tap do |aliases|
+        aliases.dup.each { |key, value| aliases[value] = key }
+      end.freeze
   end
 
-  def self.methods_map
-    {controllers: :stimulus_controllers_property, values: :stimulus_values_properties,
-     classes: :stimulus_classes_properties, targets: :stimulus_targets_properties, actions: :stimulus_actions_property}.freeze
+  def self.all_possible_properties_names
+    @all_possible_properties_names ||= aliases.keys
   end
 
-  def self.alias_properties
-    @alias_properties ||= aliases.keys
+  def self.property_method_name_for(property)
+    property = aliases[property] if properties.exclude?(property)
+    "#{property}_#{rendered_as(property) == :one ? "property" : "properties"}"
   end
 
-  def self.property_names
-    @property_names ||= base_properties + alias_properties
+  def self.attribute_method_name_for(property)
+    property = aliases[property] if properties.exclude?(property)
+    "#{property}_#{rendered_as(property) == :one ? "attribute" : "attributes"}"
+  end
+
+  def self.rendered_as(property)
+    {controllers: :one, values: :many, classes: :many, targets: :many, actions: :one} \
+      [property] || raise(ArgumentError, "Unknown property: #{property.inspect}")
   end
 
   def self.prevent_duplicates(properties_set, name)
@@ -35,16 +44,10 @@ module StimulusTagHelper
     STRING
   end
 
-  def stimulus_controller(identifier, tag: nil, **args, &block)
-    raise(ArgumentError, "Missing block") unless block
-
-    builder = StimulusControllerBuilder.new(identifier: identifier, template: self)
-
-    return capture(builder, &block) unless tag
-
-    stimulus_controller_tag(identifier, tag: tag, **args) do
-      capture(builder, &block)
-    end
+  def stimulus_controller(identifier, tag: nil, **options, &block)
+    builder = StimulusControllerBuilder.new(identifier: identifier, tag: tag, template: self, **options)
+    return builder unless block
+    builder.capture(&block)
   end
 
   # controller arg is used to add additional stimulus controllers to the element
@@ -56,42 +59,41 @@ module StimulusTagHelper
     data.merge!(stimulus_properties(
       identifier,
       controller: data[:controller] || controller, # nil is allowed, because the args will be prepended by the identifier
-      **args.extract!(*StimulusTagHelper.property_names - %i[class])
+      **args.extract!(*StimulusTagHelper.all_possible_properties_names - %i[class])
     ))
     tag_builder.tag_string(tag, **args.merge(data: data), &block)
   end
 
-  # Does not includes the controller attribute
   def stimulus_attributes(...)
     {data: stimulus_properties(...)}
   end
 
   alias_method :stimulus_attribute, :stimulus_attributes
 
-  # Does not includes the controller property
   def stimulus_properties(identifier, **props)
+    props = props.symbolize_keys
     {}.tap do |data|
-      StimulusTagHelper.property_names.each do |name|
+      StimulusTagHelper.all_possible_properties_names.each do |name|
         next unless props.key?(name)
 
         args = Array.wrap(props[name]).unshift(identifier)
         kwargs = args.last.is_a?(Hash) ? args.pop : {}
         StimulusTagHelper.prevent_duplicates(props, name)
         data.merge!(
-          public_send(StimulusTagHelper.methods_map[StimulusTagHelper.aliases[name] || name], *args, **kwargs)
+          public_send("stimulus_#{StimulusTagHelper.property_method_name_for(name)}", *args, **kwargs)
         )
       end
     end
   end
 
   def stimulus_controllers_attribute(...)
-    {data: stimulus_controllers_properties(...)}
+    {data: stimulus_controllers_property(...)}
   end
 
   alias_method :stimulus_controller_attribute, :stimulus_controllers_attribute
 
   def stimulus_controllers_property(*identifiers)
-    {controller: Array.wrap(identifiers).compact.join(" ")}
+    {controller: identifiers.flatten.compact.uniq.join(" ")}
   end
 
   alias_method :stimulus_controller_property, :stimulus_controllers_property
@@ -142,12 +144,18 @@ module StimulusTagHelper
 
   def stimulus_actions_property(identifier, *actions_params)
     {
-      action: actions_params.map { |action_params| stimulus_action_value(identifier, action_params) }.join(" ").html_safe
+      action: actions_params.flatten.map { |action_params| stimulus_action_value(identifier, action_params) }.join(" ").html_safe
     }
   end
 
   alias_method :stimulus_action_property, :stimulus_actions_property
 
+  def stimulus_actions_attribute(...)
+    {data: stimulus_actions_property(...)}
+  end
+
+  alias_method :stimulus_action_attribute, :stimulus_actions_attribute
+
   def stimulus_action_value(identifier, args_or_string) # :nodoc:
     return StimulusAction.parse(args_or_string, identifier: identifier) if args_or_string.is_a?(String)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stimulus_tag_helper
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Anton Topchii
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-11 00:00:00.000000000 Z
+date: 2022-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails