Module: Transform::Read

Extended by:
Transform
Defined in:
lib/transform/read.rb

Constant Summary

Constants included from Transform

Error

Class Method Summary collapse

Methods included from Transform

transform_const?, transformer?, transformer_const?, transformer_name, transformer_reflection

Class Method Details

.assure_instance_method(transformer) ⇒ Object 



57
58
59
60
61
 
# File 'lib/transform/read.rb', line 57

def self.assure_instance_method(transformer)
  unless transformer.respond_to?(:instance)
    raise Error, "#{transformer.name} does not implement `instance'"
  end
end

.call(input, format_name, cls) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
# File 'lib/transform/read.rb', line 5

def self.call(input, format_name, cls)
  logger.trace { "Reading (Format Name: #{format_name.inspect})" }
  logger.trace(tags: [:data, :input]) { input.pretty_inspect }

  transformer_reflection = transformer_reflection(cls)

  format_reflection = transformer_reflection.get(format_name, coerce_constant: false)

  raw_data = format_reflection.(:read, input)

  instance = instance(raw_data, cls, transformer_reflection)

  logger.info { "Read (Format Name: #{format_name.inspect})" }
  logger.debug(tags: [:data, :output]) { instance.pretty_inspect }

  instance
end

.get_instance(transformer, raw_data, cls) ⇒ Object 



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/transform/read.rb', line 41

def self.get_instance(transformer, raw_data, cls)
  assure_instance_method(transformer)

  method = transformer.method(:instance)

  instance = nil
  case method.parameters.length
  when 1
    instance = transformer.instance(raw_data)
  when 2
    instance = transformer.instance(raw_data, cls)
  end

  instance
end

.instance(raw_data, cls, transformer_reflection = nil) ⇒ Object 



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/transform/read.rb', line 23

def self.instance(raw_data, cls, transformer_reflection=nil)
  logger.trace { "Transforming raw data to instance" }
  logger.trace(tags: [:data, :raw_data]) { raw_data.pretty_inspect }

  if transformer_reflection.nil?
    transformer_reflection = transformer_reflection(cls)
  end

  transformer = transformer_reflection.target

  instance = get_instance(transformer, raw_data, cls)

  logger.debug { "Transformed raw data to instance" }
  logger.debug(tags: [:data, :instance]) { instance.pretty_inspect }

  instance
end

.logger ⇒ Object 



63
64
65
 
# File 'lib/transform/read.rb', line 63

def self.logger
  @logger ||= Log.get(self)
end