Class: Hashie::Trash

Inherits:
Dash show all
Defined in:
lib/hashie/trash.rb

Overview

A Trash is a 'translated' Dash where the keys can be remapped from a source hash.

Trashes are useful when you need to read data from another application, such as a Java api, where the keys are named differently from how we would in Ruby.

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Dash

#[], inherited, #initialize, #merge, #merge!, property?, #replace, required?, #update_attributes!

Methods included from Extensions::PrettyInspect

#hashie_inspect, included

Methods inherited from Hash

#to_hash, #to_json, #to_mash

Methods included from Extensions::StringifyKeys

#stringify_keys, #stringify_keys!

Constructor Details

This class inherits a constructor from Hashie::Dash

Class Method Details

.permitted_input_keys ⇒ Object 



66
67
68
 
# File 'lib/hashie/trash.rb', line 66

def self.permitted_input_keys
  @permitted_input_keys ||= properties.map { |property| inverse_translations.fetch property, property }
end

.property(property_name, options = {}) ⇒ Object

Defines a property on the Trash. Options are as follows:

  • :default - Specify a default value for this property, to be returned before a value is set on the property in a new Dash.
  • :from - Specify the original key name that will be write only.
  • :with - Specify a lambda to be used to convert value.
  • :transform_with - Specify a lambda to be used to convert value without using the :from option. It transform the property itself.


19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/hashie/trash.rb', line 19

def self.property(property_name, options = {})
  super

  options[:from] = options[:from] if options[:from]

  if options[:from]
    if property_name == options[:from]
      fail ArgumentError, "Property name (#{property_name}) and :from option must not be the same"
    end

    translations[options[:from]] = property_name

    define_method "#{options[:from]}=" do |val|
      with = options[:with] || options[:transform_with]
      self[property_name] = with.respond_to?(:call) ? with.call(val) : val
    end
  else
    if options[:transform_with].respond_to? :call
      transforms[property_name] = options[:transform_with]
    end
  end
end

.transformation_exists?(name) ⇒ Boolean

Returns:

  • (Boolean) 


62
63
64
 
# File 'lib/hashie/trash.rb', line 62

def self.transformation_exists?(name)
  transforms.key? name
end

.transformed_property(property_name, value) ⇒ Object 



54
55
56
 
# File 'lib/hashie/trash.rb', line 54

def self.transformed_property(property_name, value)
  transforms[property_name].call(value)
end

.translation_exists?(name) ⇒ Boolean

Returns:

  • (Boolean) 


58
59
60
 
# File 'lib/hashie/trash.rb', line 58

def self.translation_exists?(name)
  translations.key? name
end

Instance Method Details

#[]=(property, value) ⇒ Object

Set a value on the Dash in a Hash-like way. Only works on pre-existing properties.



44
45
46
47
48
49
50
51
52
 
# File 'lib/hashie/trash.rb', line 44

def []=(property, value)
  if self.class.translation_exists? property
    send("#{property}=", value)
  elsif self.class.transformation_exists? property
    super property, self.class.transformed_property(property, value)
  elsif property_exists? property
    super
  end
end