Class: Draisine::TypeMapper

Inherits:
Object
  • Object
show all
Defined in:
lib/draisine/type_mapper.rb

Defined Under Namespace

Classes: ActiveRecordColumnDef, Type

Constant Summary collapse

MAX_ALLOWED_STRING_TYPE_LENGTH = 
40
TYPES_MAP =

Apparently, mysql has a hard limit of 64k per row. That’s why we’re using text types where we could also use strings.

{
  "boolean" => type(:boolean),
  "string" => method(:determine_type_for_string),
  "reference" => type(:string, ar_options: { limit: 20 }),
  "picklist" => type(:binary, serialized: true),
  "textarea" => method(:determine_type_for_string),
  "phone" => method(:determine_type_for_string),
  "email" => method(:determine_type_for_string),
  "url" => method(:determine_type_for_string),
  "int" => type(:integer),
  "date" => type(:date),
  "time" => type(:time),
  "multipicklist" => type(:binary, serialized: true, array: true),
  "double" => method(:determine_type_for_float),
  "datetime" => type(:datetime),
  "anyType" => type(:binary, serialized: true),
  "combobox" => type(:text),
  "currency" => type(:decimal, ar_options: { precision: 18, scale: 6 }),
  "percent" => type(:decimal, ar_options: { precision: 18, scale: 6 })
  # Leave this one for now
  # "encrypted_string" => :string,
}
EXCLUDED_COLUMNS = 
["Id"]

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(sf_type_map) ⇒ TypeMapper

Returns a new instance of TypeMapper.



61
62
63
64
65
66
67
 
# File 'lib/draisine/type_mapper.rb', line 61

def initialize(sf_type_map)
  @sf_type_map = sf_type_map
  @type_map = sf_type_map.reject {|name, schema| ignored_column?(name, schema) }.
                          select {|name, schema| type_for(name, schema) }.
                          map {|name, schema| [name, type_for(name, schema)] }.
                          to_h
end

Instance Attribute Details

#sf_type_map ⇒ Object (readonly)

Returns the value of attribute sf_type_map.



60
61
62
 
# File 'lib/draisine/type_mapper.rb', line 60

def sf_type_map
  @sf_type_map
end

#type_map ⇒ Object (readonly)

Returns the value of attribute type_map.



60
61
62
 
# File 'lib/draisine/type_mapper.rb', line 60

def type_map
  @type_map
end

Class Method Details

.determine_type_for_float(name, sf_schema) ⇒ Object 



17
18
19
20
21
22
23
 
# File 'lib/draisine/type_mapper.rb', line 17

def self.determine_type_for_float(name, sf_schema)
  if (precision = sf_schema[:precision]) && (scale = sf_schema[:scale]) && scale == 0
    type(:integer, ar_options: { limit: 8 })
  else
    type(:float, ar_options: { limit: 53 })
  end
end

.determine_type_for_string(name, sf_schema) ⇒ Object 



25
26
27
28
29
30
31
 
# File 'lib/draisine/type_mapper.rb', line 25

def self.determine_type_for_string(name, sf_schema)
  if (length = sf_schema[:length]) && length > 0 && length <= MAX_ALLOWED_STRING_TYPE_LENGTH
    type(:string, ar_options: { limit: length })
  else
    type(:text)
  end
end

.type(ar_type, ar_options: {}, serialized: false, array: false) ⇒ Object 



13
14
15
 
# File 'lib/draisine/type_mapper.rb', line 13

def self.type(ar_type, ar_options: {}, serialized: false, array: false)
  Type.new(ar_type, ar_options, serialized, array)
end

Instance Method Details

#active_record_column_defs ⇒ Object 



69
70
71
 
# File 'lib/draisine/type_mapper.rb', line 69

def active_record_column_defs
  type_map.map {|name, type| active_record_column_def(name, type) }
end

#array_columns ⇒ Object 



85
86
87
 
# File 'lib/draisine/type_mapper.rb', line 85

def array_columns
  @array_columns ||= type_map.select {|_, type| type.array }.keys
end

#columns ⇒ Object 



73
74
75
 
# File 'lib/draisine/type_mapper.rb', line 73

def columns
  @columns ||= type_map.keys
end

#serialized_columns ⇒ Object 



81
82
83
 
# File 'lib/draisine/type_mapper.rb', line 81

def serialized_columns
  @serialized_columns ||= type_map.select {|_, type| type.serialized }.keys
end

#updateable_columns ⇒ Object 



77
78
79
 
# File 'lib/draisine/type_mapper.rb', line 77

def updateable_columns
  @updateable_columns ||= sf_type_map.select {|_, type| type[:updateable?] }.keys
end