Module: SimpleCrud::ControllerHelpers

Included in:
SimpleCrudController
Defined in:
lib/simple_crud/controller_helpers.rb

Overview

Class-level helpers shared by the CRUD lambdas defined in SimpleCrudController.

Instance Method Summary collapse

Instance Method Details

#build_record(controller, klass, parameters) ⇒ Object 



53
54
55
 
# File 'lib/simple_crud/controller_helpers.rb', line 53

def build_record(controller, klass, parameters)
  parameters[:build] ? controller.instance_exec(&parameters[:build]) : klass.new
end

#call_scope(scope, controller) ⇒ Object 



67
68
69
70
71
72
73
 
# File 'lib/simple_crud/controller_helpers.rb', line 67

def call_scope(scope, controller)
  user_method = SimpleCrud::Config.user_method
  user = controller.respond_to?(user_method) ? controller.public_send(user_method) : nil
  return scope.call(user) if scope.arity == 1

  scope.call(user, controller.params)
end

#find_record(klass, controller, parameters) ⇒ Object

Raises:

  • (ActiveRecord::RecordNotFound) 


81
82
83
84
85
86
87
88
89
 
# File 'lib/simple_crud/controller_helpers.rb', line 81

def find_record(klass, controller, parameters)
  record = lookup_record(klass, controller, parameters)
  raise ActiveRecord::RecordNotFound, "couldn't find #{klass}" if record.nil?
  unless record.is_a?(ActiveRecord::Base)
    raise ActiveRecord::RecordNotFound, "#{klass} finder must return a single record"
  end

  record
end

#index_records(controller, relation, options, parameters) ⇒ Object 



75
76
77
78
79
 
# File 'lib/simple_crud/controller_helpers.rb', line 75

def index_records(controller, relation, options, parameters)
  return relation unless parameters[:paginate]

  SimpleCrud::Config.pagination_adapter.paginated_records(controller, relation, options)
end

#index_relation(controller, klass, parameters) ⇒ Object 



57
58
59
60
61
62
63
64
65
 
# File 'lib/simple_crud/controller_helpers.rb', line 57

def index_relation(controller, klass, parameters)
  if parameters[:scope]
    call_scope(parameters[:scope], controller)
  elsif parameters[:authorize]
    SimpleCrud::Config.authorization_adapter.policy_scope(controller, klass)
  else
    klass.all
  end
end

#lookup_record(klass, controller, parameters) ⇒ Object 



91
92
93
94
95
96
97
 
# File 'lib/simple_crud/controller_helpers.rb', line 91

def lookup_record(klass, controller, parameters)
  finder = parameters[:finder]
  return klass.find(controller.params[:id]) if finder.nil?
  return klass.send(finder, controller.params) unless finder.respond_to?(:call)

  finder.call(controller.params)
end

#maybe_authorize(controller, record, parameters) ⇒ Object 



6
7
8
9
10
 
# File 'lib/simple_crud/controller_helpers.rb', line 6

def maybe_authorize(controller, record, parameters)
  return unless parameters[:authorize]

  SimpleCrud::Config.authorization_adapter.authorize(controller, record)
end

#persist_and_render(controller, record, parameters, options, persist, &block) ⇒ Object 



99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/simple_crud/controller_helpers.rb', line 99

def persist_and_render(controller, record, parameters, options, persist, &block)
  saved = parameters[:raise_on_invalid] ? persist.call(bang: true) : persist.call(bang: false)
  return render_persisted(controller, record, saved, options) unless block || parameters[:html]

  controller.instance_variable_set(:@record, record)
  return controller.instance_exec(record, saved, &block) if block

  if saved
    controller.redirect_to(redirect_target(controller, record, options[:redirect]))
  else
    controller.render(options[:failure_template])
  end
end

#redirect_target(controller, record, target) ⇒ Object 



118
119
120
 
# File 'lib/simple_crud/controller_helpers.rb', line 118

def redirect_target(controller, record, target)
  target.is_a?(Proc) ? controller.instance_exec(record, &target) : target
end

#render_edit(controller, record, parameters, &block) ⇒ Object 



39
40
41
 
# File 'lib/simple_crud/controller_helpers.rb', line 39

def render_edit(controller, record, parameters, &block)
  render_form(controller, record, :edit, parameters, &block)
end

#render_form(controller, record, template, parameters, &block) ⇒ Object 



43
44
45
46
47
48
49
50
51
 
# File 'lib/simple_crud/controller_helpers.rb', line 43

def render_form(controller, record, template, parameters, &block)
  if parameters[:html] || block
    controller.instance_variable_set(:@record, record)
    block ? controller.instance_exec(record, &block) : controller.render(template)
  else
    options = {}.merge(serializer: parameters[:serializer]).compact
    controller.render({ json: record }.merge(options))
  end
end

#render_index(controller, klass, options, parameters, &block) ⇒ Object 



12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/simple_crud/controller_helpers.rb', line 12

def render_index(controller, klass, options, parameters, &block)
  relation = index_relation(controller, klass, parameters)

  if parameters[:html] || block
    records = index_records(controller, relation, options, parameters)
    controller.instance_variable_set(:@records, records)
    block ? controller.instance_exec(records, &block) : controller.render(:index)
  elsif parameters[:paginate]
    SimpleCrud::Config.pagination_adapter.paginate(controller, relation, options)
  else
    controller.render({ json: relation }.merge(options))
  end
end

#render_new(controller, record, parameters, &block) ⇒ Object 



35
36
37
 
# File 'lib/simple_crud/controller_helpers.rb', line 35

def render_new(controller, record, parameters, &block)
  render_form(controller, record, :new, parameters, &block)
end

#render_persisted(controller, record, saved, options) ⇒ Object 



122
123
124
125
126
 
# File 'lib/simple_crud/controller_helpers.rb', line 122

def render_persisted(controller, record, saved, options)
  return controller.render(json: record, status: options[:status]) if saved

  controller.render json: { errors: record.errors.full_messages }, status: 422
end

#render_show(controller, record, options, parameters, &block) ⇒ Object 



26
27
28
29
30
31
32
33
 
# File 'lib/simple_crud/controller_helpers.rb', line 26

def render_show(controller, record, options, parameters, &block)
  if parameters[:html] || block
    controller.instance_variable_set(:@record, record)
    block ? controller.instance_exec(record, &block) : controller.render(:show)
  else
    controller.render({ json: record }.merge(options))
  end
end

#save_and_render(controller, record, parameters, options, persist, &block) ⇒ Object 



113
114
115
116
 
# File 'lib/simple_crud/controller_helpers.rb', line 113

def save_and_render(controller, record, parameters, options, persist, &block)
  persist_and_render(controller, record, parameters,
                     options.merge(redirect: parameters[:redirect] || record), persist, &block)
end