Module: SimpleCrudController

Extended by:
SimpleCrud::ControllerHelpers
Defined in:
lib/simple_crud/simple_crud_controller.rb

Overview

Extended onto a controller for CRUD actions.

Instance Method Summary collapse

Methods included from SimpleCrud::ControllerHelpers

build_record, call_scope, find_record, index_records, index_relation, lookup_record, maybe_authorize, persist_and_render, redirect_target, render_index, render_new, render_persisted, render_show, save_and_render

Instance Method Details

#check_policies(parameters) ⇒ Object

Raises:

  • (ArgumentError) 


123
124
125
126
127
128
129
130
 
# File 'lib/simple_crud/simple_crud_controller.rb', line 123

def check_policies(parameters)
  return if !parameters.key?(:authorize) || !parameters[:authorize]

  model = simple_crud_controller_model
  return if SimpleCrud::Config.authorization_adapter.policy_defined?(model)

  raise ArgumentError, "no authorization policy configured for #{model}"
end

#check_serializer(parameters) ⇒ Object

Raises:

  • (ArgumentError) 


132
133
134
135
136
137
138
139
 
# File 'lib/simple_crud/simple_crud_controller.rb', line 132

def check_serializer(parameters)
  return if parameters[:serializer].blank?

  serializer_name = parameters[:serializer].to_s
  return if Kernel.const_defined?(serializer_name)

  raise ArgumentError, "create a valid serializer with name #{serializer_name}"
end

#check_valid_method(method) ⇒ Object

Raises:

  • (ArgumentError) 


119
120
121
 
# File 'lib/simple_crud/simple_crud_controller.rb', line 119

def check_valid_method(method)
  raise ArgumentError, 'invalid method' unless i[show index create update destroy new].include? method
end

#crud_lambda_for_create(klass, parameters = {}, &block) ⇒ Object 



79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/simple_crud/simple_crud_controller.rb', line 79

def crud_lambda_for_create(klass, parameters = {}, &block)
  lambda do
    authenticate_user! if parameters[:authenticate]
    permitted_params = send("#{self.class.simple_crud_controller_model.to_s.underscore}_params")
    record = SimpleCrudController.build_record(self, klass, parameters)
    record.assign_attributes(permitted_params)
    SimpleCrudController.maybe_authorize(self, record, parameters)
    persist = ->(bang:) { bang ? record.save! : record.save }
    options = { status: :created, failure_template: :new }
    SimpleCrudController.save_and_render(self, record, parameters, options, persist, &block)
  end
end

#crud_lambda_for_destroy(klass, parameters = {}, &block) ⇒ Object 



104
105
106
107
108
109
110
111
112
113
 
# File 'lib/simple_crud/simple_crud_controller.rb', line 104

def crud_lambda_for_destroy(klass, parameters = {}, &block)
  lambda do
    authenticate_user! if parameters[:authenticate]
    requested = SimpleCrudController.find_record(klass, self, parameters)
    SimpleCrudController.maybe_authorize(self, requested, parameters)
    options = { status: :ok, failure_template: :show, redirect: parameters[:redirect] || klass }
    persist = ->(bang:) { bang ? requested.destroy! : requested.destroy }
    SimpleCrudController.persist_and_render(self, requested, parameters, options, persist, &block)
  end
end

#crud_lambda_for_index(klass, parameters = {}, &block) ⇒ Object 



70
71
72
73
74
75
76
77
 
# File 'lib/simple_crud/simple_crud_controller.rb', line 70

def crud_lambda_for_index(klass, parameters = {}, &block)
  lambda do
    authenticate_user! if parameters[:authenticate]
    SimpleCrudController.maybe_authorize(self, klass.new, parameters)
    options = {}.merge(each_serializer: parameters[:serializer]).compact
    SimpleCrudController.render_index(self, klass, options, parameters, &block)
  end
end

#crud_lambda_for_new(klass, parameters = {}, &block) ⇒ Object 



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

def crud_lambda_for_new(klass, parameters = {}, &block)
  lambda do
    authenticate_user! if parameters[:authenticate]
    record = SimpleCrudController.build_record(self, klass, parameters)
    SimpleCrudController.maybe_authorize(self, record, parameters)
    SimpleCrudController.render_new(self, record, parameters, &block)
  end
end

#crud_lambda_for_show(klass, parameters = {}, &block) ⇒ Object 



50
51
52
53
54
55
56
57
58
59
 
# File 'lib/simple_crud/simple_crud_controller.rb', line 50

def crud_lambda_for_show(klass, parameters = {}, &block)
  lambda do
    authenticate_user! if parameters[:authenticate]
    requested = SimpleCrudController.find_record(klass, self, parameters)

    options = {}.merge(serializer: parameters[:serializer]).compact
    SimpleCrudController.maybe_authorize(self, requested, parameters)
    SimpleCrudController.render_show(self, requested, options, parameters, &block)
  end
end

#crud_lambda_for_update(klass, parameters = {}, &block) ⇒ Object 



92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/simple_crud/simple_crud_controller.rb', line 92

def crud_lambda_for_update(klass, parameters = {}, &block)
  lambda do
    authenticate_user! if parameters[:authenticate]
    requested = SimpleCrudController.find_record(klass, self, parameters)
    SimpleCrudController.maybe_authorize(self, requested, parameters)
    permitted_params = send("#{self.class.simple_crud_controller_model.to_s.underscore}_params")
    persist = ->(bang:) { bang ? requested.update!(permitted_params) : requested.update(permitted_params) }
    options = { status: :ok, failure_template: :edit }
    SimpleCrudController.save_and_render(self, requested, parameters, options, persist, &block)
  end
end

#parameters_with_defaults(parameters) ⇒ Object 



36
37
38
39
40
41
42
43
 
# File 'lib/simple_crud/simple_crud_controller.rb', line 36

def parameters_with_defaults(parameters)
  defaults = {
    authorize: true, paginate: true, authenticate: true, serializer: nil,
    html: false, finder: nil, scope: nil, build: nil, raise_on_invalid: false
  }
  defaults.each { |key, value| parameters[key] = value unless parameters.key?(key) }
  parameters
end

#simple_crud_controller_model ⇒ Object 



115
116
117
 
# File 'lib/simple_crud/simple_crud_controller.rb', line 115

def simple_crud_controller_model
  to_s.split('::').last.sub('Controller', '').singularize.classify.constantize
end

#simple_crud_for(method, parameters = {}, &block) ⇒ Object

Possible options: authorize: check authorization via Config.authorization_adapter (Pundit by default) paginate: paginate the list via Config.pagination_adapter (wor-paginate by default) authenticate: use devise to authenticate serializer: use a particular serializer (both each_serializer and serializer) html: render the action's ERB template instead of JSON (index/show/new/create/update/destroy) finder: custom record lookup (Proc/lambda or Symbol) for :show/:update/:destroy scope: custom index scope (Proc/lambda taking current_user and optional params), overrides policy_scope build: custom record builder (Proc/lambda) for :new/:create, invoked with the controller as self raise_on_invalid: use strict create!/update! semantics instead of returning 422 A block given to simple_crud_for renders explicitly: it receives the records for :index, the record for :show/:new, or the record and a saved flag for :create/:update/:destroy



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

def simple_crud_for(method, parameters = {}, &block)
  parameters[:html] = true if block && !parameters.key?(:html)
  parameters = parameters_with_defaults(parameters)
  klass = simple_crud_controller_model
  check_valid_method(method)
  check_policies(parameters)
  check_serializer(parameters)
  define_method(method, send("crud_lambda_for_#{method}", klass, parameters, &block))
  write_metadata(method, parameters)
end

#write_metadata(method, parameters) ⇒ Object 



45
46
47
48
 
# File 'lib/simple_crud/simple_crud_controller.rb', line 45

def write_metadata(method, parameters)
  @simple_crud_metadata ||= {}
  @simple_crud_metadata[method] = parameters
end