Module: Api::Scheme

Defined in:
lib/api/scheme/version.rb,
lib/api/scheme.rb

Constant Summary collapse

VERSION = 
"0.1.0"

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.included(klass) ⇒ Object 



4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/api/scheme.rb', line 4

def self.included klass
   klass.class_eval %Q"
      class << self
         def error_map map
            @error_map ||= map
         end

         def model_error_map map
            @model_error_map ||= map
         end

         def param_map map
            @param_map ||= map
         end

         def render_error_with method = nil, &prc
            @error_proc ||= method || prc
         end
      end
   "

   klass.rescue_from StandardError, with: :render_default_error
end

Instance Method Details

#code_parse(code, e) ⇒ Object 



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/api/scheme.rb', line 62

def code_parse code, e
   json = { message: e.message, type: e.class }

   case code
   when Range
      logger.error "#{e.class}: #{e.message}"

      [ code.first, json.merge(error_code: code.last) ]
   when NilClass
      logger.error "#{e.class}: #{e.message}\n\t#{e.backtrace[0...50].join("\n\t")}"

      [ 500, json ]
   else
      logger.error "#{e.class}: #{e.message}"

      [ code, json ]
   end
end

#error_map ⇒ Object 



28
29
30
31
32
33
34
35
36
37
 
# File 'lib/api/scheme.rb', line 28

def error_map
   error_map = self.class.instance_variable_get(:@error_map)

   error_map ||= map
   return error_map if self.class.instance_variable_get(:@error_map_parsed)

   error_map = parse_error_map
   self.class.instance_variable_set(:@error_map_parsed, true)
   self.class.instance_variable_set(:@error_map, error_map)
end

#get_code_of_error_map(e) ⇒ Object 



90
91
92
93
94
 
# File 'lib/api/scheme.rb', line 90

def get_code_of_error_map e
   error_map.find do |errors, codes|
      errors.any? { |error| e.kind_of?(error) }
   end.try(:last)
end

#get_code_of_model_error_map(e) ⇒ Object 



81
82
83
84
85
86
87
88
 
# File 'lib/api/scheme.rb', line 81

def get_code_of_model_error_map e
   error_text = e.record.errors.messages.reduce(nil) {|s, (_, v)| s || v.join }

   model_error_map = self.class.instance_variable_get(:@model_error_map)
   model_error_map.to_a.reverse.reduce(nil) do |code, (re, new_code)|
       re =~ error_text && new_code || code
   end
end

#get_code_text(code) ⇒ Object 



110
111
112
113
114
 
# File 'lib/api/scheme.rb', line 110

def get_code_text code
    path = code.is_a?(Range) && "#{code.begin}.#{code.end}" || code.to_s

    I18n.t("action_controller.#{controller_path}.errors.#{path}")
end

#get_pure_code(code) ⇒ Object 



96
97
98
99
100
101
102
 
# File 'lib/api/scheme.rb', line 96

def get_pure_code code
    if code.is_a?(Range)
         code.begin
    else
         code
    end
end

#get_sub_code(code) ⇒ Object 



104
105
106
107
108
 
# File 'lib/api/scheme.rb', line 104

def get_sub_code code
    if code.is_a?(Range)
         code.end
    end
end

#parse_error_map ⇒ Object 



39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/api/scheme.rb', line 39

def parse_error_map
   error_map = self.class.instance_variable_get(:@error_map)
   error_map.map do |(errors, code)|
      list = errors.map do |e|
         begin
            e.constantize
         rescue NameError
            begin
               "#{self.class}::#{e}".constantize
            rescue NameError
               begin
                  send(:class_eval, e.camelize)
               rescue NameError
                  raise InvalidErrorTypeError, e
               end
            end
         end
      end

      [ list, code ]
   end.to_h
end

#permitted_params ⇒ Object 



154
155
156
157
158
159
160
161
162
 
# File 'lib/api/scheme.rb', line 154

def permitted_params
   param_map = self.class.instance_variable_get(:@param_map)

   if param_map.is_a?(Hash)
      permitted_params_require(param_map.keys.first, param_map.values.first)
   else
      permitted_params_permit([ param_map ].flatten)
   end
end

#permitted_params_permit(keys) ⇒ Object 



145
146
147
148
149
150
151
152
 
# File 'lib/api/scheme.rb', line 145

def permitted_params_permit keys
   default = {}

   keys.reduce(default) do |h, key|
      value = /(?<name>.*)\?$/ =~ key ? params[name] : params.require(key)
      value.nil? && h || h.merge( (name || key).to_sym => value )
   end
end

#permitted_params_require(key, map) ⇒ Object 



141
142
143
 
# File 'lib/api/scheme.rb', line 141

def permitted_params_require key, map
   params.require(key).permit(*map)
end

#render_default_error(e) ⇒ Object 



116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
 
# File 'lib/api/scheme.rb', line 116

def render_default_error e
   code =
   if e.to_s.split('::').last == 'Validations'
      get_code_of_model_error_map(e)
   else
      get_code_of_error_map(e)
   end
rescue => e
ensure
   error_proc = self.class.instance_variable_get(:@error_proc)

   case error_proc
   when Proc, Symbol
      prc = error_proc.is_a?(Symbol) && self.method(error_proc) || error_proc
      args = [get_code_text(code), get_sub_code(code), get_pure_code(code) ]
      prc[*args[0...prc.arity.abs]]
   when Symbol
      send(error_proc, get_pure_code(code), get_sub_code(code), get_code_text(code))
   else
      status, json = code_parse(code, e)

      render data: json, status: status
   end
end

#validate_access_token ⇒ Object

Raises:

  • (InvalidUserError) 


164
165
166
 
# File 'lib/api/scheme.rb', line 164

def validate_access_token
   raise InvalidUserError if not current_user
end