Module: CSVPP::Conversions

Included in:
Parser
Defined in:
lib/csvpp/conversions.rb

Constant Summary collapse

ARRAY_TYPE_RGX = 
/(?<array_type>\w+),\s*(?<array_delimiter>\W)/

Class Method Summary collapse

Class Method Details

.clean_decimal(str) ⇒ Object 



142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/csvpp/conversions.rb', line 142

def clean_decimal(str)
  return str unless str.is_a?(String)

  val = str.strip
           .gsub(/['`\s]?/, '')               # remove thousand separators
           .sub(/[\sa-zA-Z]*$/, '')           # remove trailing words like "mg"
           .sub(/^-0*(.+)$/, '-\1')           # remove 0 after negative sign: -003 => -3
  if val =~ /^0+$/                            # remove leading zeros
    '0'
  else
    val.gsub( /^0*/, '')
  end
end

.convert(obj, to:, missings: [], **options) ⇒ Object

Returns parsed value, read from obj, interpreted as type given by to.

Parameters:

  • obj (Object) —

    object to parse

  • to (String) —

    a type, e.g. “int”

  • missings (Array) (defaults to: []) —

    list of values that are treated as missings, e.g. [‘NA’, ‘-’, -999]

  • options (Hash) —

    options passed on to parsing methods for specific types

Returns:

  • parsed value, read from obj, interpreted as type given by to



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/csvpp/conversions.rb', line 15

def convert(obj, to:, missings: [], **options)
  return nil if missing?(obj, missings)

  if to.start_with?('array')
    to, rest = to.split('<')
    rest = rest.tr('>', '')
    match = rest.match(ARRAY_TYPE_RGX)
    options = options.merge(
      type: match[:array_type],
      delimiter: match[:array_delimiter]
    )
  end

  send("parse_#{to}", obj, **options)
end

.missing?(obj, missings) ⇒ Boolean

Returns:

  • (Boolean) 


138
139
140
 
# File 'lib/csvpp/conversions.rb', line 138

def missing?(obj, missings)
  missings.map(&:to_s).include?(obj.to_s)
end

.parse_array(str, type:, delimiter:, **options) ⇒ Object 



31
32
33
 
# File 'lib/csvpp/conversions.rb', line 31

def parse_array(str, type:, delimiter:, **options)
  str.split(delimiter).map { |entry| send("parse_#{type}", entry) }
end

.parse_boolean(str, true_values: [], false_values: [], **options) ⇒ Object

Returns true or false, or nil if str doesn’t match any value interpreted as true or false.

Parameters:

  • true_values (Array) (defaults to: []) —

    : list of values that are interpreted as true

  • false_values (Array) (defaults to: []) —

    : list of values that are interpreted as false

Returns:

  • true or false, or nil if str doesn’t match any value interpreted as true or false



114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/csvpp/conversions.rb', line 114

def parse_boolean(str,
                  true_values: [],
                  false_values: [],
                  **options)

  cleaned = str.to_s.strip.downcase

  trues = if true_values.empty?
            ['1', 't', 'true']
          else
            true_values.map(&:to_s).map(&:downcase)
          end
  return true if trues.include? cleaned

  falses = if false_values.empty?
             ['0', 'f', 'false']
           else
             false_values.map(&:to_s).map(&:downcase)
           end
  return false if falses.include? cleaned

  nil
end

.parse_chop(str, delimiter: ':', **options) ⇒ Object 



35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/csvpp/conversions.rb', line 35

def parse_chop(str, delimiter: ':', **options)
  code, laterality, date = str.split(delimiter)
  code = parse_string(code)
  laterality = parse_string(laterality) if laterality
  laterality = nil if laterality&.empty?
  date = parse_date(date) if date

  {
    code: code,
    laterality: laterality,
    date: date
  }
end

.parse_date(str, **options) ⇒ Object 



106
107
108
 
# File 'lib/csvpp/conversions.rb', line 106

def parse_date(str, **options)
  Date.parse(str.to_s)
end

.parse_decimal(str, **options) ⇒ Object 



94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/csvpp/conversions.rb', line 94

def parse_decimal(str, **options)
  return nil if str.to_s.empty?

  cleaned = clean_decimal(str).to_s

  if cleaned.empty?
    nil
  else
    BigDecimal(cleaned)
  end
end

.parse_float(str, **options) ⇒ Object 



89
90
91
92
 
# File 'lib/csvpp/conversions.rb', line 89

def parse_float(str, **options)
  return nil if str.to_s.empty?
  Float(clean_decimal(str)) rescue nil
end

.parse_int(str, **options) ⇒ Object 



73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/csvpp/conversions.rb', line 73

def parse_int(str, **options)
  return nil if str.to_s.empty?

  cleaned = if str.is_a?(String)
              val = str.strip
                      .gsub(/['`\s]?/, '')      # remove thousand separators
                      .sub(/\.\d*/, '')         # remove decimal point and everything thereafter
                      .sub(/[\sa-zA-Z]*$/, '')  # remove trailing words like "mg"
                      .sub(/^-0*(.+)$/, '-\1')  # remove 0 after negative sign: -003 => -3
              val =~ /^0+$/ ? '0' : val.gsub( /^0*/, '')      # remove leading zeros
            else
              str
            end
  Integer(cleaned) rescue nil
end

.parse_medi(str, delimiter: ':', **options) ⇒ Object

See page 3 in documentation/Technisches_Begleitblatt_2017_d.pdf more more info on the medi data type.



51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/csvpp/conversions.rb', line 51

def parse_medi(str, delimiter: ':', **options)
  atc_code, annex, application, dose, unit = str.split(delimiter)
  atc_code = parse_string(atc_code)
  annex = parse_string(annex) if annex
  annex = nil if annex&.empty?
  application = parse_string(application)
  dose = parse_decimal(dose)
  unit = parse_string(unit)

  {
    atc_code: atc_code,
    annex: annex,
    application: application,
    dose: dose,
    unit: unit
  }
end

.parse_string(str, **options) ⇒ Object 



69
70
71
 
# File 'lib/csvpp/conversions.rb', line 69

def parse_string(str, **options)
  str.to_s.strip
end