Module: Decanter::Core::ClassMethods

Defined in:
lib/decanter/core.rb

Instance Method Summary collapse

Instance Method Details

#decant(args) ⇒ Object 



54
55
56
57
58
 
# File 'lib/decanter/core.rb', line 54

def decant(args)
  args = args.to_unsafe_h if args.class.name == 'ActionController::Parameters'
  {}.merge( unhandled_keys(args) )
    .merge( handled_keys(args) )
end

#decanter_for_handler(handler) ⇒ Object 



110
111
112
 
# File 'lib/decanter/core.rb', line 110

def decanter_for_handler(handler)
  Decanter::decanter_for(handler[:options][:decanter] || handler[:assoc])
end

#handle(handler, args) ⇒ Object 



87
88
89
90
91
 
# File 'lib/decanter/core.rb', line 87

def handle(handler, args)
  values = args.values_at(*handler[:name])
  values = values.length == 1 ? values.first : values
  self.send("handle_#{handler[:type]}", handler, values)
end

#handle_has_many(handler, values) ⇒ Object 



97
98
99
100
101
102
 
# File 'lib/decanter/core.rb', line 97

def handle_has_many(handler, values)
    decanter = decanter_for_handler(handler)
    {
      handler[:key] => values.compact.map { |value| decanter.decant(value) }
    }
end

#handle_has_one(handler, values) ⇒ Object 



104
105
106
107
108
 
# File 'lib/decanter/core.rb', line 104

def handle_has_one(handler, values)
    {
      handler[:key] => decanter_for_handler(handler).decant(values)
    }
end

#handle_input(handler, values) ⇒ Object 



93
94
95
 
# File 'lib/decanter/core.rb', line 93

def handle_input(handler, values)
   parse(handler[:key], handler[:parser], values, handler[:options])
end

#handled_keys(args) ⇒ Object 



81
82
83
84
85
 
# File 'lib/decanter/core.rb', line 81

def handled_keys(args)
  handlers.values
          .select     { |handler| (args.keys.map(&:to_sym) & handler[:name]).any? }
          .reduce({}) { |memo, handler| memo.merge handle(handler, args) }
end

#handlers ⇒ Object 



122
123
124
 
# File 'lib/decanter/core.rb', line 122

def handlers
  @handlers ||= {}
end

#has_many(assoc, **options) ⇒ Object 



27
28
29
30
31
32
33
34
35
36
 
# File 'lib/decanter/core.rb', line 27

def has_many(assoc, **options)
  name = ["#{assoc}_attributes".to_sym]
  handlers[name] = {
    assoc:   assoc,
    key:     options.fetch(:key, name.first),
    name:    name,
    options: options,
    type:    :has_many
  }
end

#has_one(assoc, **options) ⇒ Object 



38
39
40
41
42
43
44
45
46
47
 
# File 'lib/decanter/core.rb', line 38

def has_one(assoc, **options)
  name = ["#{assoc}_attributes".to_sym]
  handlers[name] = {
    assoc:   assoc,
    key:     options.fetch(:key, name.first),
    name:    name,
    options: options,
    type:    :has_one
  }
end

#input(name, parser = nil, **options) ⇒ Object 



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
# File 'lib/decanter/core.rb', line 10

def input(name, parser=nil, **options)

  _name = [name].flatten

  if _name.length > 1 && parser.blank?
    raise ArgumentError.new("#{self.name} no parser specified for input with multiple values.")
  end

  handlers[_name] = {
    key:     options.fetch(:key, _name.first),
    name:    _name,
    options: options,
    parser:  parser,
    type:    :input
  }
end

#parse(key, parser, values, options) ⇒ Object 



114
115
116
117
118
119
120
 
# File 'lib/decanter/core.rb', line 114

def parse(key, parser, values, options)
  parser ?
    ValueParser.value_parser_for(parser)
               .parse(key, values, options)
    :
    { key => values }
end

#strict(mode) ⇒ Object

Raises:

  • (ArgumentError) 


49
50
51
52
 
# File 'lib/decanter/core.rb', line 49

def strict(mode)
  raise( ArgumentError.new("#{self.name}: Unknown strict value #{mode}")) unless [:with_exception, true, false].include? mode
  @strict_mode = mode
end

#strict_mode ⇒ Object 



126
127
128
 
# File 'lib/decanter/core.rb', line 126

def strict_mode
  @strict_mode ||= {}
end

#unhandled_keys(args) ⇒ Object

protected



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

def unhandled_keys(args)

  unhandled_keys = args.keys - handlers.keys.flatten.uniq

  if unhandled_keys.any?
    case strict_mode
    when true
      p "#{self.name} ignoring unhandled keys: #{unhandled_keys.join(', ')}."
      {}
    when :with_exception
      raise ArgumentError.new("#{self.name} received unhandled keys: #{unhandled_keys.join(', ')}.")
    else
      args.select { |key| unhandled_keys.include? key }
    end
  else
    {}
  end
end