Class: Kiba::Extend::Transforms::Rename::Field

Inherits:
Object
  • Object
show all
Includes:
SingleWarnable
Defined in:
lib/kiba/extend/transforms/rename/field.rb

Overview

Renames one field

Example notes

1 - :from field exists

:from field renamed to :to field. Not much to see here.

2 - :to field already exists

:sex is renamed to :gender, overwriting the existing value of :gender (unknown) with value of :sex (m). The transform emits a warning about this unless you suppress_overwrite_warnings

3 - :from field does not exist

Row is passed through unchanged, and the transform emits a warning about not being able to rename a field that doesn’t exist, unless you suppress_missing_key_warnings

4 - :from and :to field are the same

This seems like a real weird edge case from the perspective of defining transforms manually, but it can happen when transform definitions are programmatically generated from configuration.

Examples:

1 - :from field exists

# Used in pipeline as:
# transform Rename::Field,
#   from: :sex,
#   to: :gender
xform = Rename::Field.new(
  from: :sex,
  to: :gender
)
input = [
  {name: "Weddy", sex: "m", color: "pearl gray, greater, pied"},
  {name: "Kernel", sex: "f", color: "buff dundotte"}
]
result = Kiba::StreamingRunner.transform_stream(input, xform)
  .map{ |row| row }
expected = [
  {name: "Weddy", gender: "m", color: "pearl gray, greater, pied"},
  {name: "Kernel", gender: "f", color: "buff dundotte"},
]
expect(result).to eq(expected)

2 - :to field already exists

# Used in pipeline as:
# transform Rename::Field,
#   from: :sex,
#   to: :gender
xform = Rename::Field.new(
  from: :sex,
  to: :gender
)
input = [
  {name: "Weddy", sex: "m", gender: "unknown"}
]
result = Kiba::StreamingRunner.transform_stream(input, xform)
  .map{ |row| row }
expected = [
  {name: "Weddy", gender: "m"}
]
expect(xform.send(:single_warnings)).to include(
  "Renaming `sex` to `gender` overwrites existing `gender` "\
  "field data"
)
expect(result).to eq(expected)

2b - :to field already exists, warning suppressed

# Used in pipeline as:
# transform Rename::Field,
#   from: :sex,
#   to: :gender,
#   suppress_overwrite_warnings: true
xform = Rename::Field.new(
  from: :sex,
  to: :gender,
  suppress_overwrite_warnings: true
)
input = [
  {name: "Weddy", sex: "m", gender: "unknown"}
]
result = Kiba::StreamingRunner.transform_stream(input, xform)
  .map{ |row| row }
expected = [
  {name: "Weddy", gender: "m"}
]
expect(xform.send(:single_warnings)).not_to include(
  "Renaming `sex` to `gender` overwrites existing `gender`"\
  "field data"
)
expect(result).to eq(expected)

3 - :from field does not exist

# Used in pipeline as:
# transform Rename::Field,
#   from: :sex,
#   to: :gender
xform = Rename::Field.new(
  from: :sex,
  to: :gender
)
input = [
  {name: "Weddy", gender: "unknown"}
]
result = Kiba::StreamingRunner.transform_stream(input, xform)
  .map{ |row| row }
expected = [
  {name: "Weddy", gender: "unknown"}
]
expect(xform.send(:single_warnings)).to include(
  "Cannot rename field: `sex` does not exist in row"
)
expect(result).to eq(expected)

3b - :from field does not exist, warnings suppressed

# Used in pipeline as:
# transform Rename::Field,
#   from: :sex,
#   to: :gender,
#   suppress_missing_key_warnings: true
xform = Rename::Field.new(
  from: :sex,
  to: :gender,
  suppress_missing_key_warnings: true
)
input = [
  {name: "Weddy", gender: "unknown"}
]
result = Kiba::StreamingRunner.transform_stream(input, xform)
  .map{ |row| row }
expected = [
  {name: "Weddy", gender: "unknown"}
]
expect(xform.send(:single_warnings)).not_to include(
  "Cannot rename field: `sex` does not exist in row"
)
expect(result).to eq(expected)

4 - :from and :to field are the same

# Used in pipeline as:
# transform Rename::Field,
#   from: :gender,
#   to: :gender
xform = Rename::Field.new(
  from: :gender,
  to: :gender
)
input = [
  {name: "Weddy", gender: "unknown"}
]
result = Kiba::StreamingRunner.transform_stream(input, xform)
  .map{ |row| row }
expected = [
  {name: "Weddy", gender: "unknown"}
]
expect(result).to eq(expected)

Instance Method Summary collapse

Methods included from SingleWarnable

single_warnings

Constructor Details

#initialize(from:, to:, suppress_missing_key_warnings: false, suppress_overwrite_warnings: false) ⇒ Field

Returns a new instance of Field.

Parameters:

  • from (Symbol) —

    current field name

  • to (Symbol) —

    target field name

  • suppress_missing_key_warnings (Boolean) (defaults to: false)
  • suppress_overwrite_warnings (Boolean) (defaults to: false) 


175
176
177
178
179
180
181
182
183
184
 
# File 'lib/kiba/extend/transforms/rename/field.rb', line 175

def initialize(from:, to:,
  suppress_missing_key_warnings: false,
  suppress_overwrite_warnings: false)
  @from = from
  @to = to
  @suppress_missing_key_warnings = suppress_missing_key_warnings
  @suppress_overwrite_warnings = suppress_overwrite_warnings
  setup_single_warning unless suppress_missing_key_warnings &&
    suppress_overwrite_warnings
end

Instance Method Details

#process(row) ⇒ Hash{ Symbol => String, nil }

Parameters:

  • row (Hash{ Symbol => String, nil })

Returns:

  • (Hash{ Symbol => String, nil }) 


188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
 
# File 'lib/kiba/extend/transforms/rename/field.rb', line 188

def process(row)
  return row if from == to

  unless row.key?(from)
    unless suppress_missing_key_warnings
      add_single_warning("Cannot rename field: `#{from}` does not "\
                         "exist in row")
    end

    return row
  end

  if row.key?(to) && !suppress_overwrite_warnings
    add_single_warning("Renaming `#{from}` to `#{to}` overwrites "\
                       "existing `#{to}` field data")
  end

  row[to] = row.fetch(from)
  row.delete(from)
  row
end