Module: Vident::StimulusAttributes

Extended by:
ActiveSupport::Concern
Included in:
StimulusComponent
Defined in:
lib/vident/stimulus_attributes.rb

Instance Method Summary collapse

Instance Method Details

#add_stimulus_actions(actions) ⇒ Object 



190
191
192
193
194
195
196
197
 
# File 'lib/vident/stimulus_attributes.rb', line 190

def add_stimulus_actions(actions)
  s_actions = stimulus_actions(*Array.wrap(actions))
  @stimulus_actions_collection = if @stimulus_actions_collection
    @stimulus_actions_collection.merge(s_actions)
  else
    s_actions
  end
end

#add_stimulus_classes(named_classes) ⇒ Object 



226
227
228
229
230
231
232
233
 
# File 'lib/vident/stimulus_attributes.rb', line 226

def add_stimulus_classes(named_classes)
  classes = stimulus_classes(named_classes)
  @stimulus_classes_collection = if @stimulus_classes_collection
    @stimulus_classes_collection.merge(classes)
  else
    classes
  end
end

#add_stimulus_controllers(controllers) ⇒ Object

Methods to add to the stimulus collections



181
182
183
184
185
186
187
188
 
# File 'lib/vident/stimulus_attributes.rb', line 181

def add_stimulus_controllers(controllers)
  s_controllers = stimulus_controllers(*Array.wrap(controllers))
  @stimulus_controllers_collection = if @stimulus_controllers_collection
    @stimulus_controllers_collection.merge(s_controllers)
  else
    s_controllers
  end
end

#add_stimulus_outlets(outlets) ⇒ Object 



208
209
210
211
212
213
214
215
 
# File 'lib/vident/stimulus_attributes.rb', line 208

def add_stimulus_outlets(outlets)
  s_outlets = stimulus_outlets(*Array.wrap(outlets))
  @stimulus_outlets_collection = if @stimulus_outlets_collection
    @stimulus_outlets_collection.merge(s_outlets)
  else
    s_outlets
  end
end

#add_stimulus_targets(targets) ⇒ Object 



199
200
201
202
203
204
205
206
 
# File 'lib/vident/stimulus_attributes.rb', line 199

def add_stimulus_targets(targets)
  s_targets = stimulus_targets(*Array.wrap(targets))
  @stimulus_targets_collection = if @stimulus_targets_collection
    @stimulus_targets_collection.merge(s_targets)
  else
    s_targets
  end
end

#add_stimulus_values(values) ⇒ Object 



217
218
219
220
221
222
223
224
 
# File 'lib/vident/stimulus_attributes.rb', line 217

def add_stimulus_values(values)
  s_values = stimulus_values(values)
  @stimulus_values_collection = if @stimulus_values_collection
    @stimulus_values_collection.merge(s_values)
  else
    s_values
  end
end

#stimulus_action(*args) ⇒ Object

Parse inputs to create a StimulusAction instance representing a Stimulus action attribute

examples:
stimulus_action(:my_thing) => StimulusAction that converts to "current_controller#myThing"
stimulus_action(:click, :my_thing) => StimulusAction that converts to "click->current_controller#myThing"
stimulus_action("click->current_controller#myThing") => StimulusAction that converts to "click->current_controller#myThing"
stimulus_action("path/to/current", :my_thing) => StimulusAction that converts to "path--to--current_controller#myThing"
stimulus_action(:click, "path/to/current", :my_thing) => StimulusAction that converts to "click->path--to--current_controller#myThing"



55
56
57
58
 
# File 'lib/vident/stimulus_attributes.rb', line 55

def stimulus_action(*args)
  return args.first if args.length == 1 && args.first.is_a?(StimulusAction)
  StimulusAction.new(*args, implied_controller:)
end

#stimulus_actions(*actions) ⇒ Object

Parse inputs to create a StimulusActionCollection instance representing multiple Stimulus actions



61
62
63
64
65
66
67
68
 
# File 'lib/vident/stimulus_attributes.rb', line 61

def stimulus_actions(*actions)
  return StimulusActionCollection.new if actions.empty? || actions.all?(&:blank?)

  converted_actions = actions.map do |action|
    action.is_a?(Array) ? stimulus_action(*action) : stimulus_action(action)
  end
  StimulusActionCollection.new(converted_actions)
end

#stimulus_class(*args) ⇒ Object

Parse inputs to create a StimulusClass instance representing a Stimulus class attribute

examples:
stimulus_class(:loading, "spinner active") => StimulusClass that converts to {"current_controller-loading-class" => "spinner active"}
stimulus_class("path/to/current", :loading, ["spinner", "active"]) => StimulusClass that converts to {"path--to--current-loading-class" => "spinner active"}



153
154
155
156
 
# File 'lib/vident/stimulus_attributes.rb', line 153

def stimulus_class(*args)
  return args.first if args.length == 1 && args.first.is_a?(StimulusClass)
  StimulusClass.new(*args, implied_controller:)
end

#stimulus_classes(*classes) ⇒ Object

Parse inputs to create a StimulusClassCollection instance representing multiple Stimulus classes



159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
 
# File 'lib/vident/stimulus_attributes.rb', line 159

def stimulus_classes(*classes)
  return StimulusClassCollection.new if classes.empty? || classes.all?(&:blank?)

  converted_classes = []

  classes.each do |cls|
    if cls.is_a?(Hash)
      # Hash format: {loading: "spinner active", error: "text-red-500"} - expands to multiple classes
      cls.each { |name, class_list| converted_classes << stimulus_class(name, class_list) }
    elsif cls.is_a?(Array)
      # Array format: [controller, name, classes] or [name, classes] - splat into stimulus_class
      converted_classes << stimulus_class(*cls)
    else
      converted_classes << stimulus_class(cls)
    end
  end

  StimulusClassCollection.new(converted_classes)
end

#stimulus_controller(*args) ⇒ Object

Parse inputs to create a StimulusController instance representing a Stimulus controller attribute

examples:
stimulus_controller("my_controller") => StimulusController that converts to {"controller" => "my-controller"}
stimulus_controller("path/to/controller") => StimulusController that converts to {"controller" => "path--to--controller"}
stimulus_controller() => StimulusController that uses implied controller name



30
31
32
33
 
# File 'lib/vident/stimulus_attributes.rb', line 30

def stimulus_controller(*args)
  return args.first if args.length == 1 && args.first.is_a?(StimulusController)
  StimulusController.new(*args, implied_controller: implied_controller_path)
end

#stimulus_controllers(*controllers) ⇒ Object

Parse inputs to create a StimulusControllerCollection instance representing multiple Stimulus controllers

examples:
stimulus_controllers(:my_controller) => StimulusControllerCollection with one controller that converts to {"controller" => "my-controller"}
stimulus_controllers(:my_controller, "path/to/another") => StimulusControllerCollection with two controllers that converts to {"controller" => "my-controller path--to--another"}



39
40
41
42
43
44
45
46
 
# File 'lib/vident/stimulus_attributes.rb', line 39

def stimulus_controllers(*controllers)
  return StimulusControllerCollection.new if controllers.empty? || controllers.all?(&:blank?)

  converted_controllers = controllers.map do |controller|
    controller.is_a?(Array) ? stimulus_controller(*controller) : stimulus_controller(controller)
  end
  StimulusControllerCollection.new(converted_controllers)
end

#stimulus_outlet(*args) ⇒ Object

Parse inputs to create a StimulusOutlet instance representing a Stimulus outlet attribute

examples:
stimulus_outlet(:user_status, ".online-user") => StimulusOutlet that converts to {"current_controller-user-status-outlet" => ".online-user"}
stimulus_outlet("path/to/current", :user_status, ".online-user") => StimulusOutlet that converts to {"path--to--current-user-status-outlet" => ".online-user"}
stimulus_outlet(:user_status) => StimulusOutlet with auto-generated selector
stimulus_outlet(component_instance) => StimulusOutlet from component



95
96
97
98
 
# File 'lib/vident/stimulus_attributes.rb', line 95

def stimulus_outlet(*args)
  return args.first if args.length == 1 && args.first.is_a?(StimulusOutlet)
  StimulusOutlet.new(*args, implied_controller:, component_id: @id)
end

#stimulus_outlets(*outlets) ⇒ Object

Parse inputs to create a StimulusOutletCollection instance representing multiple Stimulus outlets



101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/vident/stimulus_attributes.rb', line 101

def stimulus_outlets(*outlets)
  return StimulusOutletCollection.new if outlets.empty? || outlets.all?(&:blank?)

  converted_outlets = []
  outlets.each do |outlet|
    if outlet.is_a?(Hash)
      # Hash format: {name: selector, other_name: other_selector} - expands to multiple outlets
      outlet.each { |name, selector| converted_outlets << stimulus_outlet(name, selector) }
    elsif outlet.is_a?(Array)
      # Array format: [name, selector] - splat into stimulus_outlet
      converted_outlets << stimulus_outlet(*outlet)
    else
      converted_outlets << stimulus_outlet(outlet)
    end
  end
  StimulusOutletCollection.new(converted_outlets)
end

#stimulus_scoped_event(event) ⇒ Object

Stimulus events name for this component



236
237
238
 
# File 'lib/vident/stimulus_attributes.rb', line 236

def stimulus_scoped_event(event)
  self.class.stimulus_scoped_event(event)
end

#stimulus_scoped_event_on_window(event) ⇒ Object 



240
241
242
 
# File 'lib/vident/stimulus_attributes.rb', line 240

def stimulus_scoped_event_on_window(event)
  self.class.stimulus_scoped_event_on_window(event)
end

#stimulus_target(*args) ⇒ Object

Parse inputs to create a StimulusTarget instance representing a Stimulus target attribute

examples:
stimulus_target(:my_target) => StimulusTarget that converts to {"current_controller-target" => "myTarget"}
stimulus_target("path/to/current", :my_target) => StimulusTarget that converts to {"path--to--current-target" => "myTarget"}



74
75
76
77
 
# File 'lib/vident/stimulus_attributes.rb', line 74

def stimulus_target(*args)
  return args.first if args.length == 1 && args.first.is_a?(StimulusTarget)
  StimulusTarget.new(*args, implied_controller:)
end

#stimulus_targets(*targets) ⇒ Object

Parse inputs to create a StimulusTargetCollection instance representing multiple Stimulus targets



80
81
82
83
84
85
86
87
 
# File 'lib/vident/stimulus_attributes.rb', line 80

def stimulus_targets(*targets)
  return StimulusTargetCollection.new if targets.empty? || targets.all?(&:blank?)

  converted_targets = targets.map do |target|
    target.is_a?(Array) ? stimulus_target(*target) : stimulus_target(target)
  end
  StimulusTargetCollection.new(converted_targets)
end

#stimulus_value(*args) ⇒ Object

Parse inputs to create a StimulusValue instance representing a Stimulus value attribute

examples:
stimulus_value(:url, "https://example.com") => StimulusValue that converts to {"current_controller-url-value" => "https://example.com"}
stimulus_value("path/to/current", :url, "https://example.com") => StimulusValue that converts to {"path--to--current-url-value" => "https://example.com"}



123
124
125
126
 
# File 'lib/vident/stimulus_attributes.rb', line 123

def stimulus_value(*args)
  return args.first if args.length == 1 && args.first.is_a?(StimulusValue)
  StimulusValue.new(*args, implied_controller:)
end

#stimulus_values(*values) ⇒ Object

Parse inputs to create a StimulusValueCollection instance representing multiple Stimulus values



129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/vident/stimulus_attributes.rb', line 129

def stimulus_values(*values)
  return StimulusValueCollection.new if values.empty? || values.all?(&:blank?)

  converted_values = []

  values.each do |value|
    if value.is_a?(Hash)
      # Hash format: {name: value, other_name: other_value} - expands to multiple values
      value.each { |name, val| converted_values << stimulus_value(name, val) }
    elsif value.is_a?(Array)
      # Array format: [controller, name, value] or [name, value] - splat into stimulus_value
      converted_values << stimulus_value(*value)
    else
      converted_values << stimulus_value(value)
    end
  end

  StimulusValueCollection.new(converted_values)
end