Class: Compony::Component

Inherits:
Object
  • Object
show all
Defined in:
lib/compony/component.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(parent_comp = nil, index: 0, **comp_opts) ⇒ Component

Returns a new instance of Component.



22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/compony/component.rb', line 22

def initialize(parent_comp = nil, index: 0, **comp_opts)
  @parent_comp = parent_comp
  @sub_comps = []
  @index = index
  @comp_opts = comp_opts
  @before_render_block = nil
  @content_blocks = []
  @actions = []
  @skipped_actions = Set.new

  init_standalone
  init_labelling

  fail "#{inspect} is missing a call to `setup`." unless setup_blocks&.any?

  setup_blocks.each do |setup_block|
    instance_exec(&setup_block)
  end
  check_config!
end

Instance Attribute Details

#comp_opts ⇒ Object (readonly) 



9
10
11
 
# File 'lib/compony/component.rb', line 9

def comp_opts
  @comp_opts
end

#parent_comp ⇒ Object (readonly) 



8
9
10
 
# File 'lib/compony/component.rb', line 8

def parent_comp
  @parent_comp
end

Class Method Details

.setup(&block) ⇒ Object

DSL method



15
16
17
18
19
20
 
# File 'lib/compony/component.rb', line 15

def self.setup(&block)
  fail("`setup` expects a block in #{inspect}.") unless block_given?
  self.setup_blocks ||= []
  self.setup_blocks = setup_blocks.dup # This is required to prevent the parent class to see children's setup blocks.
  setup_blocks << block
end

Instance Method Details

#action(action_name, before: nil, &block) ⇒ Object

DSL method Adds or replaces an action (for action buttons) If before: is specified, will insert the action before the named action. When replacing, an element keeps its position unless before: is specified.



174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
 
# File 'lib/compony/component.rb', line 174

def action(action_name, before: nil, &block)
  action_name = action_name.to_sym
  before_name = before&.to_sym
  action = MethodAccessibleHash.new(name: action_name, block:)

  existing_index = @actions.find_index { |el| el.name == action_name }
  if existing_index.present? && before_name.present?
    @actions.delete_at(existing_index) # Replacing an existing element with a before: directive - must delete before calculating indices
  end
  if before_name.present?
    before_index = @actions.find_index { |el| el.name == before_name } || fail("Action #{before_name} for :before not found in #{inspect}.")
  end

  if before_index.present?
    @actions.insert(before_index, action)
  elsif existing_index.present?
    @actions[existing_index] = action
  else
    @actions << action
  end
end

#add_content(index = -1,, &block) ⇒ Object

DSL method Adds a content block that will be executed after all previous ones. It is safe to use this method even if content has never been called You can use dyny here.



142
143
144
145
146
 
# File 'lib/compony/component.rb', line 142

def add_content(index = -1, &block)
  fail("`content` expects a block in #{inspect}.") unless block_given?
  @content_blocks ||= []
  @content_blocks.insert(index, block)
end

#before_render(&block) ⇒ Object

DSL method



126
127
128
 
# File 'lib/compony/component.rb', line 126

def before_render(&block)
  @before_render_block = block
end

#check_config! ⇒ Object (protected) 



225
 
# File 'lib/compony/component.rb', line 225

def check_config!; end

#comp_class_for ⇒ Object

TODO:

deprecate (check for usages beforehand)



116
117
118
 
# File 'lib/compony/component.rb', line 116

def comp_class_for(...)
  Compony.comp_class_for(...)
end

#comp_class_for! ⇒ Object

TODO:

deprecate (check for usages beforehand)



121
122
123
 
# File 'lib/compony/component.rb', line 121

def comp_class_for!(...)
  Compony.comp_class_for!(...)
end

#comp_cst ⇒ Object

Returns the name of the class constant of this component. Do not override.



106
107
108
 
# File 'lib/compony/component.rb', line 106

def comp_cst
  self.class.name.demodulize.to_sym
end

#comp_name ⇒ Object

Returns the component name



111
112
113
 
# File 'lib/compony/component.rb', line 111

def comp_name
  comp_cst.to_s.underscore
end

#content(&block) ⇒ Object

DSL method Overrides previous content (also from superclasses). Will be the first content block to run. You can use dyny here.



133
134
135
136
 
# File 'lib/compony/component.rb', line 133

def content(&block)
  fail("`content` expects a block in #{inspect}.") unless block_given?
  @content_blocks = [block]
end

#family_cst ⇒ Object

Returns the name of the module constant (=family) of this component. Do not override.



96
97
98
 
# File 'lib/compony/component.rb', line 96

def family_cst
  self.class.module_parent.to_s.demodulize.to_sym
end

#family_name ⇒ Object

Returns the family name



101
102
103
 
# File 'lib/compony/component.rb', line 101

def family_name
  family_cst.to_s.underscore
end

#id ⇒ Object

Returns an identifier describing this component. Must be unique among simplings under the same parent_comp. Do not override.



62
63
64
 
# File 'lib/compony/component.rb', line 62

def id
  "#{family_name}_#{comp_name}_#{@index}"
end

#inspect ⇒ Object 



43
44
45
 
# File 'lib/compony/component.rb', line 43

def inspect
  "#<#{self.class.name}:#{hash}>"
end

#param_name(unprefixed_param_name) ⇒ Object

Given an unprefixed name of a param, adds the path hash Do not overwrite.



84
85
86
 
# File 'lib/compony/component.rb', line 84

def param_name(unprefixed_param_name)
  "#{path_hash}_#{unprefixed_param_name}"
end

#path ⇒ Object

Returns the id path from the root_comp. Do not overwrite.



68
69
70
71
72
73
74
 
# File 'lib/compony/component.rb', line 68

def path
  if root_comp?
    id
  else
    "#{parent_comp.path}/#{id}"
  end
end

#path_hash ⇒ Object

Returns a hash for the path. Used for params prefixing. Do not overwrite.



78
79
80
 
# File 'lib/compony/component.rb', line 78

def path_hash
  Digest::SHA1.hexdigest(path)[..4]
end

#render(controller, **locals) ⇒ Object

Renders the component using the controller passsed to it and returns it as a string. Do not overwrite.



150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
 
# File 'lib/compony/component.rb', line 150

def render(controller, **locals)
  # Call before_render hook if any and backfire instance variables back to the component
  RequestContext.new(self, controller, locals:).request_context.evaluate_with_backfire(&@before_render_block) if @before_render_block
  # Render, unless before_render has already issued a body (e.g. through redirecting).
  if controller.response.body.blank?
    fail "#{self.class.inspect} must define `content` or set a response body in `before_render`" if @content_blocks.none?
    return controller.render_to_string(
      type:   :dyny,
      locals: { content_blocks: @content_blocks, component: self, render_locals: locals },
      inline: "        content_blocks.each do |block|\n          # Instanciate and evaluate a fresh RequestContext in order to use the buffer allocated by the ActionView (needed for `concat` calls)\n          Compony::RequestContext.new(component, controller, helpers: self, locals: render_locals).evaluate(&block)\n        end\n      RUBY\n    )\n  else\n    return nil # Prevent double render errors\n  end\nend\n"

#render_actions(controller, wrapper_class: '', action_class: '') ⇒ Object

Used to render all actions of this component, each button wrapped in a div with the specified class



203
204
205
206
207
208
209
210
211
212
213
214
215
216
 
# File 'lib/compony/component.rb', line 203

def render_actions(controller, wrapper_class: '', action_class: '')
  h = controller.helpers
  h.content_tag(:div, class: wrapper_class) do
    button_htmls = @actions.map do |action|
      next if @skipped_actions.include?(action.name)
      Compony.with_button_defaults(feasibility_action: action.name.to_sym) do
        action_button = action.block.call
        next unless action_button
        h.content_tag(:div, action_button.render(controller), class: action_class)
      end
    end
    next h.safe_join button_htmls
  end
end

#resourceful? ⇒ Boolean

Is true for resourceful components

Returns:

  • (Boolean) 


219
220
221
 
# File 'lib/compony/component.rb', line 219

def resourceful?
  return false
end

#root_comp ⇒ Object

Returns the current root comp. Do not overwrite.



49
50
51
52
 
# File 'lib/compony/component.rb', line 49

def root_comp
  return self unless parent_comp
  return parent_comp.root_comp
end

#root_comp? ⇒ Boolean

Returns whether or not this is the root comp. Do not overwrite.

Returns:

  • (Boolean) 


56
57
58
 
# File 'lib/compony/component.rb', line 56

def root_comp?
  parent_comp.nil?
end

#skip_action(action_name) ⇒ Object

DSL method Marks an action for skip



198
199
200
 
# File 'lib/compony/component.rb', line 198

def skip_action(action_name)
  @skipped_actions << action_name.to_sym
end

#sub_comp(component_class, **comp_opts) ⇒ Object

Instanciate a component with self as a parent



89
90
91
92
93
 
# File 'lib/compony/component.rb', line 89

def sub_comp(component_class, **comp_opts)
  sub = component_class.new(self, index: @sub_comps.count, **comp_opts)
  @sub_comps << sub
  return sub
end