Module: ActiveScaffold::Core::ClassMethods

Defined in:
lib/active_scaffold/core.rb

Defined Under Namespace

Modules: Prefixes

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#active_scaffold_config_block ⇒ Object (readonly)

Returns the value of attribute active_scaffold_config_block.



203
204
205
 
# File 'lib/active_scaffold/core.rb', line 203

def active_scaffold_config_block
  @active_scaffold_config_block
end

Instance Method Details

#_add_sti_create_links ⇒ Object

To be called after include action modules



115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/active_scaffold/core.rb', line 115

def _add_sti_create_links
  new_action_link = active_scaffold_config.action_links.collection['new']
  return if new_action_link.nil? || active_scaffold_config.sti_children.empty?

  active_scaffold_config.action_links.collection.delete('new')
  active_scaffold_config.sti_children.each do |child|
    new_sti_link = new_action_link.deep_dup
    new_sti_link.label = as_(:create_model, model: child.to_s.camelize.constantize.model_name.human)
    new_sti_link.parameters = {parent_sti: controller_path}
    new_sti_link.controller = proc { active_scaffold_controller_for(child.to_s.camelize.constantize).controller_path }
    active_scaffold_config.action_links.collection.create.add(new_sti_link)
  end
end

#active_scaffold(model_id = nil, &block) ⇒ Object 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/active_scaffold/core.rb', line 40

def active_scaffold(model_id = nil, &block)
  extend Prefixes

  # initialize bridges here
  ActiveScaffold::Bridges.run_all

  # converts Foo::BarController to 'bar' and FooBarsController to 'foo_bar' and AddressController to 'address'
  model_id ||= to_s.split('::').last.sub(/Controller$/, '').pluralize.singularize.underscore

  # run the configuration
  @active_scaffold_config = ActiveScaffold::Config::Core.new(model_id)
  @active_scaffold_config_block = block
  links_for_associations

  active_scaffold_superclasses_blocks.each { |superblock| active_scaffold_config.configure(&superblock) }
  active_scaffold_config.sti_children = nil # reset sti_children if set in parent block
  active_scaffold_config.configure(&block) if block_given?
  active_scaffold_config.class.after_config_callbacks.each do |callback|
    if callback.is_a?(Proc)
      instance_eval(&callback)
    elsif active_scaffold_config.respond_to?(callback)
      active_scaffold_config.send(callback)
    elsif respond_to?(callback)
      send(callback)
    end
  end

  # defines the attribute read methods on the model, so record.send() doesn't find protected/private methods instead
  # define_attribute_methods is safe to call multiple times since rails 4.0.4
  active_scaffold_config.model.define_attribute_methods if active_scaffold_config.active_record?
  # include the rest of the code into the controller: the action core and the included actions
  module_eval do
    unless self < ActiveScaffold::Actions::Core
      include ActiveScaffold::Finder
      include ActiveScaffold::Constraints
      include ActiveScaffold::AttributeParams
      include ActiveScaffold::Actions::Core
    end
    active_scaffold_config.actions.each do |mod|
      include "ActiveScaffold::Actions::#{mod.to_s.camelize}".constantize

      mod_conf = active_scaffold_config.send(mod)
      active_scaffold_config._setup_action(mod)
      next unless mod_conf.respond_to?(:link) && (link = mod_conf.link)

      # sneak the action links from the actions into the main set
      if link.is_a? Array
        link.each do |current_link|
          active_scaffold_config.action_links.add_to_group(current_link, active_scaffold_config.send(mod).action_group)
        end
      elsif link.is_a? ActiveScaffold::DataStructures::ActionLink
        active_scaffold_config.action_links.add_to_group(link, active_scaffold_config.send(mod).action_group)
      end
    end
  end
  _add_sti_create_links if active_scaffold_config.add_sti_create_links?
  ActiveScaffold::Config::Core.custom_modules.each { |mod| include mod }
  active_scaffold_config.custom_modules.each { |mod| include mod }
  active_scaffold_config._cache_lazy_values
  active_scaffold_config.deep_freeze!
end

#active_scaffold_config ⇒ Object 



195
196
197
198
199
200
201
 
# File 'lib/active_scaffold/core.rb', line 195

def active_scaffold_config
  if @active_scaffold_config.nil?
    superclass.active_scaffold_config if superclass.respond_to? :active_scaffold_config
  else
    @active_scaffold_config
  end
end

#active_scaffold_config_for(klass) ⇒ Object 



215
216
217
218
219
 
# File 'lib/active_scaffold/core.rb', line 215

def active_scaffold_config_for(klass)
  active_scaffold_controller_for(klass).active_scaffold_config
rescue ActiveScaffold::ControllerNotFound
  ActiveScaffold::Config::Core.new(klass)
end

#active_scaffold_controller_for(klass) ⇒ Object 



221
222
223
224
225
226
227
228
 
# File 'lib/active_scaffold/core.rb', line 221

def active_scaffold_controller_for(klass)
  return self if uses_active_scaffold? && klass == active_scaffold_config.model

  # noinspection RubyArgCount
  ActiveScaffold::Registry.cache :as_controller, klass do
    ActiveScaffold::Core.active_scaffold_controller_for(klass, "#{to_s.deconstantize}::")
  end
end

#active_scaffold_controller_for_column(column, options = {}) ⇒ Object 



144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/active_scaffold/core.rb', line 144

def active_scaffold_controller_for_column(column, options = {})
  if column.association.polymorphic?
    :polymorph
  elsif options.include?(:controller)
    "#{options[:controller].to_s.camelize}Controller".constantize
  else
    active_scaffold_controller_for(column.association.klass)
  end
rescue ActiveScaffold::ControllerNotFound
  nil
end

#active_scaffold_superclasses_blocks ⇒ Object 



205
206
207
208
209
210
211
212
213
 
# File 'lib/active_scaffold/core.rb', line 205

def active_scaffold_superclasses_blocks
  blocks = []
  klass = superclass
  while klass.respond_to? :active_scaffold_superclasses_blocks
    blocks << klass.active_scaffold_config_block
    klass = klass.superclass
  end
  blocks.compact.reverse
end

#add_active_scaffold_path(path) ⇒ Object 



185
186
187
188
189
190
191
192
193
 
# File 'lib/active_scaffold/core.rb', line 185

def add_active_scaffold_path(path)
  as_path = File.realpath File.join(ActiveScaffold::Config::Core.plugin_directory, 'app', 'views')
  index = view_paths.find_index { |p| p.to_s == as_path }
  if index
    self.view_paths = view_paths[0..(index - 1)] + Array(path) + view_paths[index..]
  else
    append_view_path path
  end
end

#link_for_association(column, options = {}) ⇒ Object 



156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/active_scaffold/core.rb', line 156

def link_for_association(column, options = {})
  return if (controller = active_scaffold_controller_for_column(column, options)).nil?

  options.reverse_merge! position: :after, type: :member, column: column,
                         controller: (controller == :polymorph ? controller : "/#{controller.controller_path}")
  options[:parameters] ||= {}
  options[:parameters].reverse_merge! association: column.association.name
  if column.association.collection?
    ActiveScaffold::DataStructures::ActionLink.new('index', options.reverse_merge(refresh_on_close: true))
  else
    actions = controller.active_scaffold_config.actions unless controller == :polymorph
    actions ||= i[create update show]
    controller_actions = column.actions_for_association_links
    controller_actions = controller_actions.dup if controller_actions.frozen?
    controller_actions.delete :new unless actions.include? :create
    controller_actions.delete :edit unless actions.include? :update
    controller_actions.delete :show unless actions.include? :show
    options.merge!(html_options: {class: column.name}, controller_actions: Set.new(controller_actions))
    ActiveScaffold::DataStructures::ActionLink.new(nil, options)
  end
end

#link_for_association_as_scope(scope, options = {}) ⇒ Object 



178
179
180
181
182
183
 
# File 'lib/active_scaffold/core.rb', line 178

def link_for_association_as_scope(scope, options = {})
  options.reverse_merge! label: scope, position: :after, type: :member, controller: controller_path
  options[:parameters] ||= {}
  options[:parameters].reverse_merge! named_scope: scope
  ActiveScaffold::DataStructures::ActionLink.new('index', options)
end

#links_for_associations ⇒ Object

Create the automatic column links. Note that this has to happen when configuration is done, because otherwise the Nested module could be disabled. Actually, it could still be disabled later, couldn’t it?



131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/active_scaffold/core.rb', line 131

def links_for_associations
  return unless active_scaffold_config.actions.include?(:list) && active_scaffold_config.actions.include?(:nested)

  active_scaffold_config.columns.each do |column|
    next unless column.link.nil? && column.autolink?

    # lazy load of action_link, cause it was really slowing down app in dev mode
    # and might lead to trouble cause of cyclic constantization of controllers
    # and might be unnecessary cause it is done before columns are configured
    column.set_link(proc { |col| link_for_association(col) })
  end
end

#uses_active_scaffold? ⇒ Boolean

Returns:

  • (Boolean) 


230
231
232
 
# File 'lib/active_scaffold/core.rb', line 230

def uses_active_scaffold?
  !active_scaffold_config.nil?
end