remi 0.2.17 → 0.2.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3bd2e6e34158794c804cc06b0e43b16710770fee
-  data.tar.gz: 847df60b53d1f942f81fb8fd9ead83ab7ae56063
+  metadata.gz: 7c112dfed8a5515c7c839e41c038181c79364504
+  data.tar.gz: a7185273e9bb567e70a83bf09a8670cf85d4d223
 SHA512:
-  metadata.gz: dfc58dc7fe0cdbc505156348ce0b8558c8cdb20e77a5d3b0cf7d9f69f4645ac56fbbef0610f7cac1d8498db7a8fa6e9bad0beaa52000d93c58e07aa42c0d974e
-  data.tar.gz: 3a7006a47ab9a5f0723ef91c572c37b6618f003e160d62d7c3787cb46c4ecc838d67c15b9a5fe10fcfe7636e6006df15dec57e7b5d3ea8065ece9327c23d1ecb
+  metadata.gz: 81645e029daa594ec66f7b109443f1337a1e2af0c5d85daf0f54d6e3f6254ad4c02ba637b31b96eb487aa2f3c1a8df535b90f7f67b29b2f61eb291d8bc052443
+  data.tar.gz: 6a700425dc41377ffa5e56aa34a46eb4c7d9d9f9e9d37c48c631379f0cf3336e8fab1188a43d7b908b39dbbfa154176bc0473427932c92b1823795e4504897aa

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    remi (0.2.17)
+    remi (0.2.18)
       activesupport (~> 4.2)
       bond (~> 0.5)
       cucumber (~> 2.1)
@@ -123,4 +123,4 @@ DEPENDENCIES
   remi!
 
 BUNDLED WITH
-   1.10.6
+   1.11.2

data/features/formulas.feature

@@ -72,4 +72,5 @@ Feature: This tests the creation of example records.
     And the source field 'Some Date'
     And the source field 'Some String'
     And the target field 'Combination'
-    Then the target field is a concatenation of 'Some Date' and 'Some String', delimited by "-"
+    Then the target field 'Combination' is a concatenation of the source fields 'Some Date' and 'Some String', delimited by "-"
+    Then the target field 'Combination' is a concatenation of the source fields, delimited by "-"

data/features/sample_job.feature

@@ -195,12 +195,12 @@ Feature: This is a sample feature file.
     Then the target field '<Target Field>' is populated from the source field using the format "<Target Format>"
 
     When the source field is blank
-    Then the target field '<Target Field>' is populated with "<If Blank>" using the format "<Target Format>"
+    Then the target field '<Target Field>' is populated with "<If Blank>"
 
     Examples:
-      | Source Field | Source Format | Target Field    | Target Format | If Blank       |
-      | Applied Date | %m/%d/%Y      | Applied_Date__c | %Y-%m-%d      | *Today's Date* |
-      | Birthdate    | %m/%d/%Y      | Birthdate       | %Y-%m-%d      |                |
+      | Source Field | Source Format | Target Field    | Target Format | If Blank          |
+      | Applied Date | %m/%d/%Y      | Applied_Date__c | %Y-%m-%d      | *Today: %Y-%m-%d* |
+      | Birthdate    | %m/%d/%Y      | Birthdate       | %Y-%m-%d      |                   |
 
 
   Scenario: Populating School__c

data/features/step_definitions/remi_step.rb

@@ -106,7 +106,7 @@ Given /^the (source|target) file contains at least the following headers in no p
     field = row.first
     step "the #{st} field '#{field}'"
   end
-  expect(@brt.send(st.to_sym).data_obj.fields.keys).to include(*@brt.send(st.to_sym).fields.names)
+  expect(@brt.send(st.to_sym).data_obj.fields.keys).to include(*@brt.send(st.to_sym).fields.field_names)
 end
 
 Given /^the (source|target) file contains all of the following headers in this order:$/ do |st, table|
@@ -116,7 +116,7 @@ Given /^the (source|target) file contains all of the following headers in this o
   end
 
   @brt.run_transforms if st == 'target'
-  expect(@brt.send(st.to_sym).data_obj.fields.keys).to eq @brt.send(st.to_sym).fields.names
+  expect(@brt.send(st.to_sym).data_obj.fields.keys).to eq @brt.send(st.to_sym).fields.field_names
 end
 
 
@@ -130,29 +130,31 @@ Given /^the source field '([^']+)'$/ do |source_field_name|
   @brt.sources.add_field(source_field_name)
 end
 
-Given /^the source field has the value "([^"]*)"$/ do |arg|
-  @brt.source.field.value = Remi::BusinessRules::ParseFormula.parse(arg)
+Given /^the source field '([^']+)' (?:has|is set to) the value "([^"]*)"$/ do |source_field, value|
+  step "the source field '#{source_field}'"
+
+  source_name, source_field_name = @brt.sources.parse_full_field(source_field)
+  @brt.sources[source_name].fields[source_field_name].value = Remi::BusinessRules::ParseFormula.parse(value)
 end
 
-When /^the source field (?:has an empty value|is blank)$/ do
-  @brt.source.field.value = ''
+Given /^the source field (?:has|is set to) the value "([^"]*)"$/ do |value|
+  @brt.sources.fields.each do |field|
+    step "the source field '#{field.full_name}' is set to the value \"#{value}\""
+  end
 end
 
-When /^the source field '(.+)' (?:has an empty value|is blank)$/ do |source_field|
+When /^the source field '([^']+)' (?:has an empty value|is blank)$/ do |source_field|
   step "the source field '#{source_field}'"
+
   source_name, source_field_name = @brt.sources.parse_full_field(source_field)
-  @brt.sources[source_name].fields[source_field_name].value = ''
-end
 
-Given /^the source field '([^:]+)' (?:has|is set to) the value "([^"]*)"$/ do |source_field, value|
-  step "the source field '#{source_field}'"
-  @brt.source.fields[source_field].value = Remi::BusinessRules::ParseFormula.parse(value)
+  @brt.sources[source_name].fields[source_field_name].value = ''
 end
 
-Given /^the source field '(.+:.+)' (?:has|is set to) the value "([^"]*)"$/ do |source_field, value|
-  step "the source field '#{source_field}'"
-  source_name, field_name = @brt.sources.parse_full_field(source_field)
-  @brt.sources[source_name].fields[field_name].value = Remi::BusinessRules::ParseFormula.parse(value)
+When /^the source field (?:has an empty value|is blank)$/ do
+  @brt.sources.fields.each do |field|
+    step "the source field '#{field.full_name}' is blank"
+  end
 end
 
 Given /^the source field '(.+:.+)' (?:has|is set to) the value in the source field '(.+:.+)'$/ do |source_field, other_source_field|
@@ -178,8 +180,17 @@ Given /^the source data are tied through the fields '(.+:.+)' and '(.+:.+)'$/ do
   step "the source field '#{other_source_field}' is set to the value in the source field '#{source_field}'"
 end
 
+Given /^the source field '([^']+)' is parsed with the date format "([^"]*)"$/ do |source_field, date_format|
+  step "the source field '#{source_field}'"
+
+  source_name, source_field_name = @brt.sources.parse_full_field(source_field)
+  expect(@brt.sources[source_name].fields[source_field_name].metadata[:format]).to eq date_format
+end
+
 Given /^the source field is parsed with the date format "([^"]*)"$/ do |date_format|
-  expect(@brt.source.field.metadata[:format]).to eq date_format
+  @brt.sources.fields.each do |field|
+    step "the source field '#{field.full_name}' is parsed with the date format \"#{date_format}\""
+  end
 end
 
 Given /^the source field is a valid email address$/ do
@@ -200,55 +211,66 @@ Given /^the target field '([^']+)'$/ do |arg|
   @brt.targets.add_field(arg)
 end
 
-Then /^the target field '(.+)' is copied from the source field$/ do |arg|
-  step "the target field '#{arg}'"
-  step "the target field is copied from the source field"
-end
-
-Then /^the target field is copied from the source field$/ do
-  @brt.run_transforms
-  expect(@brt.target.field.value).to eq (@brt.source.field.value)
-end
-
-Then /^the target field '(.+)' is copied from the source field '(.+:.+)'$/ do |target_field, source_field|
+Then /^the target field '([^']+)' is copied from the source field '([^']+)'$/ do |target_field, source_field|
   step "the target field '#{target_field}'"
   step "the source field '#{source_field}'"
 
   source_name, source_field_name = @brt.sources.parse_full_field(source_field)
+  target_names, target_field_name = @brt.targets.parse_full_field(target_field, multi: true)
 
   @brt.run_transforms
-  expect(@brt.target.fields[target_field].value).to eq (@brt.sources[source_name].fields[source_field_name].value)
+  Array(target_names).each do |target_name|
+    expect(@brt.targets[target_name].fields[target_field_name].value).to eq (@brt.sources[source_name].fields[source_field_name].value)
+  end
 end
 
-Then /^the target field '(.+)' is copied from the source field '([^:]+)'$/ do |target_field, source_field|
-  step "the target field '#{target_field}'"
-  step "the source field '#{source_field}'"
-
-  @brt.run_transforms
-  expect(@brt.target.field.value).to eq (@brt.source.fields[source_field].value)
+Then /^the target field '([^']+)' is copied from the source field$/ do |target_field|
+  @brt.sources.fields.each do |source_field|
+    step "the target field '#{target_field}' is copied from the source field '#{source_field.full_name}'"
+  end
 end
 
-Then /^the target field is (?:set to the value|populated with) "([^"]*)"$/ do |value|
-  @brt.run_transforms
-  expect(@brt.target.field.value).to eq Remi::BusinessRules::ParseFormula.parse(value)
+Then /^the target field is copied from the source field$/ do
+  @brt.targets.fields.each do |target_field|
+    @brt.sources.fields.each do |source_field|
+      step "the target field '#{target_field.full_name}' is copied from the source field '#{source_field.full_name}'"
+    end
+  end
 end
 
-Then /^the target field '(.+)' is (?:set to the value|populated with) "([^"]*)"$/ do |target_field, value|
+Then /^the target field '([^']+)' is (?:set to the value|populated with) "([^"]*)"$/ do |target_field, value|
   expect_cucumber {
+    target_names, target_field_name = @brt.targets.parse_full_field(target_field, multi: true)
+
     expect {
-  @brt.targets.add_field(target_field)
-  @brt.run_transforms
+      Array(target_names).each do |target_name|
+        @brt.targets[target_name].add_field(target_field_name)
+      end
+      @brt.run_transforms
     }.not_to raise_error
-  expect(@brt.targets.fields[target_field].values.uniq).to eq [Remi::BusinessRules::ParseFormula.parse(value)]
+    Array(target_names).each do |target_name|
+      expect(@brt.targets[target_name].fields[target_field_name].values.uniq).to eq [Remi::BusinessRules::ParseFormula.parse(value)]
+    end
   }
 end
 
-Then /^the target field '(.+)' is in the list "([^"]*)"$/ do |target_field, list|
+Then /^the target field is (?:set to the value|populated with) "([^"]*)"$/ do |value|
+  @brt.targets.fields.each do |field|
+    step "the target field '#{field.full_name}' is populated with \"#{value}\""
+  end
+end
+
+
+Then /^the target field '(.+)' has a value in the list "([^"]*)"$/ do |target_field, list|
   step "the target field '#{target_field}'"
 
+  target_names, target_field_name = @brt.targets.parse_full_field(target_field, multi: true)
+
   list_array = list.split(',').map(&:strip)
   @brt.run_transforms
-  expect(@brt.targets.fields[target_field].values.uniq & list_array).to include(*@brt.targets.fields[target_field].values.uniq)
+  Array(target_names).each do |target_name|
+    expect(@brt.targets[target_name].fields[target_field].values.uniq & list_array).to include(*@brt.targets[target_name].fields[target_field].values.uniq)
+  end
 end
 
 
@@ -284,31 +306,82 @@ end
 
 ### Transforms
 
+Then /^the target field '([^']+)' is a concatenation of the source fields '(.+)', delimited by "([^"]*)"$/ do |target_field, source_field_list, delimiter|
+  source_fields = "'#{source_field_list}'".gsub(' and ', ', ').split(',').map do |field_with_quotes|
+    full_field_name = field_with_quotes.match(/'(.+)'/)[1]
+
+    source_name, field_name = @brt.sources.parse_full_field(full_field_name)
+    { full_field_name: full_field_name, source: source_name, field: field_name }
+  end
+
+  concatenated_source = source_fields.map do |field|
+    step "the source field '#{field[:full_field_name]}'"
+    @brt.sources[field[:source]].fields[field[:field]].values.uniq
+  end.join(delimiter)
+
+  step "the target field '#{target_field}'"
+
+  target_names, target_field_name = @brt.targets.parse_full_field(target_field, multi: true)
+
+  @brt.run_transforms
+  Array(target_names).each do |target_name|
+    expect(@brt.targets[target_name].fields[target_field_name].values.uniq).to eq Array(concatenated_source)
+  end
+end
+
+Then /^the target field '([^']+)' is a concatenation of the source fields, delimited by "([^"]*)"$/ do |target_field, delimiter|
+  source_field_list = @brt.sources.fields.map do |field|
+    "'#{field.full_name}'"
+  end.join(',')
+
+  step "the target field '#{target_field}' is a concatenation of the source fields #{source_field_list}, delimited by \"#{delimiter}\""
+end
+
 Then /^the target field is a concatenation of the source fields, delimited by "([^"]*)"$/ do |delimiter|
-  concatenated_source = @brt.sources.fields.values.uniq.map do |row|
-    Array(row.join(delimiter))
+  @brt.targets.fields.each do |target_field|
+    step "the target field '#{target_field.full_name}' is a concatenation of the source fields, delimited by \"#{delimiter}\""
   end
+end
+
 
+Then /^the target field '([^']+)' is a concatenation of "([^"]*)" and '(.+)', delimited by "([^"]*)"$/ do |target_field, constant, source_field, delimiter|
+  step "the target field '#{target_field}'"
+
+  target_names, target_field_name = @brt.targets.parse_full_field(target_field, multi: true)
+  source_name, source_field_name = @brt.sources.parse_full_field(source_field)
+
+  expected_value = [constant, @brt.sources[source_name].fields[source_field_name].value].join(delimiter)
   @brt.run_transforms
-  expect(@brt.targets.fields.values.uniq).to eq concatenated_source
+
+  Array(target_names).each do |target_name|
+    expect(@brt.targets[target_name].fields[target_field_name].values.uniq).to eq Array(expected_value)
+  end
 end
 
-Then /^the target field is a concatenation of '(.+)' and '(.+)', delimited by "([^"]*)"$/ do |source_field_1, source_field_2, delimiter|
-  expected_value = [@brt.sources.fields[source_field_1].value, @brt.sources.fields[source_field_2].value].join(delimiter)
+Then /^the target field '([^']+)' is a concatenation of '(.+)' and "([^"]*)", delimited by "([^"]*)"$/ do |target_field, source_field, constant, delimiter|
+  step "the target field '#{target_field}'"
+
+  target_names, target_field_name = @brt.targets.parse_full_field(target_field, multi: true)
+  source_name, source_field_name = @brt.sources.parse_full_field(source_field)
+
+  expected_value = [@brt.sources[source_name].fields[source_field_name].value, constant].join(delimiter)
   @brt.run_transforms
-  expect(@brt.targets.fields.values.uniq).to eq [[expected_value]]
+
+  Array(target_names).each do |target_name|
+    expect(@brt.targets[target_name].fields[target_field_name].values.uniq).to eq Array(expected_value)
+  end
 end
 
 Then /^the target field is a concatenation of "([^"]*)" and '(.+)', delimited by "([^"]*)"$/ do |constant, source_field, delimiter|
-  expected_value = [constant, @brt.sources.fields[source_field].value].join(delimiter)
-  @brt.run_transforms
-  expect(@brt.targets.fields.values.uniq).to eq [[expected_value]]
+  @brt.targets.fields.each do |target_field|
+    step "the target field '#{target_field.full_name}' is a concatenation of \"#{constant}\" and '#{source_field}', delimited by \"#{delimiter}\""
+  end
 end
 
 Then /^the target field is a concatenation of '(.+)' and "([^"]*)", delimited by "([^"]*)"$/ do |source_field, constant, delimiter|
-  expected_value = [@brt.sources.fields[source_field].value, constant].join(delimiter)
-  @brt.run_transforms
-  expect(@brt.targets.fields.values.uniq).to eq [[expected_value]]
+  @brt.targets.fields.each do |target_field|
+    step "the target field '#{target_field.full_name}' is a concatenation of '#{source_field}' and \"#{constant}\", delimited by \"#{delimiter}\""
+  end
 end
 
 Then /^the source field is prefixed with "([^"]*)" and loaded into the target field$/ do |prefix|
@@ -317,25 +390,27 @@ Then /^the source field is prefixed with "([^"]*)" and loaded into the target fi
   expect(@brt.target.field.value).to eq prefixed_source
 end
 
-Then /^the target field '(.+)' is populated from the source field using the format "([^"]*)"$/ do |target_field, target_format|
-  source_format = @brt.source.field.metadata[:format]
+Then /^the target field '([^']+)' is populated from the source field '([^']+)' using the format "([^"]*)"$/ do |target_field, source_field, target_format|
+  step "the source field '#{source_field}'"
+  step "the target field '#{target_field}'"
+
+  source_name, source_field_name = @brt.sources.parse_full_field(source_field)
+  target_names, target_field_name = @brt.targets.parse_full_field(target_field, multi: true)
+
+  source_format = @brt.sources[source_name].fields[source_field_name].metadata[:format]
   source_reformatted = Remi::Transform[:format_date].(from_fmt: source_format, to_fmt: target_format)
-    .call(@brt.source.field.value)
+    .call(@brt.sources[source_name].fields[source_field_name].value)
 
-  step "the target field '#{target_field}'"
   @brt.run_transforms
-  expect(@brt.target.field.value).to eq source_reformatted
+  target_names.each do |target_name|
+    expect(@brt.targets[target_name].fields[target_field_name].value).to eq source_reformatted
+  end
 end
 
-Then /^the target field '(.+)' is populated with "([^"]*)" using the format "([^"]*)"$/ do |target_field, target_value, target_format|
-  source_format = @brt.source.field.metadata[:format]
-  target_value_source_format = target_value == "*Today's Date*" ? Date.today.strftime(source_format) : target_value
-  target_reformatted = Remi::Transform[:format_date].(from_fmt: source_format, to_fmt: target_format)
-   .call(target_value_source_format)
-
-  step "the target field '#{target_field}'"
-  @brt.run_transforms
-  expect(@brt.target.field.value).to eq target_reformatted
+Then /^the target field '([^']+)' is populated from the source field using the format "([^"]*)"$/ do |target_field, target_format|
+  @brt.sources.fields.each do |source_field|
+    step "the target field '#{target_field}' is populated from the source field '#{source_field.full_name}' using the format \"#{target_format}\""
+  end
 end
 
 Then /^the target field '(.+)' is the first non-blank value from source fields '(.+)'$/ do |target_field_name, source_field_list|
@@ -374,6 +449,35 @@ Then /^the target field is copied from the source field, but commas have been re
   expect(@brt.target.field.value).to eq source_field_value.gsub(/,/, '.')
 end
 
+Then /^the target field '([^']+)' contains a unique value matching the pattern \/(.*)\/$/ do |target_field, pattern|
+  step "the target field '#{target_field}'"
+
+  target_names, target_field_name = @brt.targets.parse_full_field(target_field, multi: true)
+  regex_pattern = Regexp.new(pattern)
+
+  results = 1.upto(10).map do |iter|
+    @brt.run_transforms
+
+    Array(target_names).map do |target_name|
+      @brt.targets[target_name].fields[target_field_name].values.uniq
+    end.flatten
+  end.flatten
+
+  results.each do |result_value|
+    expect(result_value).to match(regex_pattern)
+  end
+
+  expect(results.size).to eq results.uniq.size
+
+end
+
+Then /^the target field contains a unique value matching the pattern \/(.*)\/$/ do |pattern|
+  @brt.targets.fields.each do |target_field|
+    step "the target field '#{target_field.full_name}' contains a unique value matching the pattern /#{pattern}/"
+  end
+end
+
+
 
 ### Field presence
 
@@ -384,7 +488,7 @@ Then /^only the following fields should be present on the target:$/ do |table|
   end
 
   @brt.run_transforms
-  expect(@brt.target.data_obj.fields.keys).to match_array @brt.target.fields.names
+  expect(@brt.target.data_obj.fields.keys).to match_array @brt.target.fields.field_names
 end
 
 ### Record-level expectations

data/features/transforms/truncate.feature

@@ -0,0 +1,14 @@
+Feature: Test the truncate transformer.
+
+  Background:
+    Given the job is 'Truncate'
+    And the job source 'Source Data'
+    And the job target 'Target Data'
+
+  Scenario: Truncating a field.
+    Given the source 'Source Data'
+    And the target 'Target Data'
+    And the job parameter 'truncate_len' is "5"
+
+    And the source field 'My Field' is set to the value "something"
+    Then the target field 'Truncated Field' is set to the value "somet"

data/jobs/transforms/truncate_job.rb

@@ -0,0 +1,19 @@
+require_relative '../all_jobs_shared'
+
+class TruncateJob
+  include AllJobsShared
+
+  define_param :truncate_len, 5
+  define_source :source_data, Remi::DataSource::DataFrame,
+    fields: {
+      :my_field => {}
+    }
+  define_target :target_data, Remi::DataTarget::DataFrame
+
+  define_transform :main, sources: :source_data, targets: :target_data do
+    Remi::SourceToTargetMap.apply(source_data.df, target_data.df) do
+      map source(:my_field) .target(:truncated_field)
+        .transform(Remi::Transform[:truncate].(params[:truncate_len].to_i))
+    end
+  end
+end

data/lib/remi/cucumber/business_rules.rb

@@ -188,7 +188,7 @@ module Remi::BusinessRules
     end
 
     def add_subject(subject_name, subject)
-      @subjects[subject_name] ||= DataSubject.new(subject)
+      @subjects[subject_name] ||= DataSubject.new(subject_name, subject)
     end
 
     def add_field(full_field_name)
@@ -204,11 +204,17 @@ module Remi::BusinessRules
     end
 
     def fields
-      dfc = DataFieldCollection.new
-      @subjects.each do |subject_name, subject|
-        subject.fields.each { |field_name, field| dfc.add_field(subject, field_name) }
+      Enumerator.new do |enum|
+        @subjects.each do |subject_name, subject|
+          subject.fields.each { |field_name, field| enum << field }
+        end
       end
-      dfc
+    end
+
+    def full_field_names
+      @subjects.map do |subject_name, subject|
+        subject.fields.map { |field_name, field| "#{field.full_name}" }
+      end.flatten
     end
 
     def size
@@ -222,13 +228,15 @@ module Remi::BusinessRules
 
 
   class DataSubject
-    def initialize(subject)
+    def initialize(name, subject)
+      @name = name
       @data_obj = subject
       @fields = DataFieldCollection.new
 
       stub_data
     end
 
+    attr_reader :name
     attr_reader :data_obj
 
     def add_field(field_name)
@@ -353,7 +361,7 @@ module Remi::BusinessRules
       generated_data = generate_values_from_cumulative_dist(@data_obj.df.size, cumulative_dist)
 
       generated_data.each do |field_name, data_array|
-        vector_name = fields[field_name].name
+        vector_name = fields[field_name].field_name
         @data_obj.df[vector_name] = Daru::Vector.new(data_array, index: @data_obj.df.index)
       end
     end
@@ -403,8 +411,13 @@ module Remi::BusinessRules
       @fields.values.map(&:name)
     end
 
+    def field_names
+      @fields.values.map(&:field_name)
+    end
+
     def add_field(subject, field_name)
-      @fields[field_name] = DataField.new(subject.data_obj, field_name) unless @fields.include? field_name
+      raise "Attempting to add a field with the same name but different subject - #{subject.name}: #{field_name}" if @fields.include?(field_name) && @fields[field_name].subject.name != subject.name
+      @fields[field_name] = DataField.new(subject, field_name) unless @fields.include? field_name
     end
 
     def only
@@ -420,21 +433,26 @@ module Remi::BusinessRules
 
 
   class DataField
-    def initialize(subject, field_name)
+    def initialize(subject, name)
       @subject = subject
-      @field_name = field_name.symbolize(subject.field_symbolizer)
+      @name = name
+      @field_name = name.symbolize(subject.data_obj.field_symbolizer)
     end
 
-    def name
-      @field_name
+    attr_reader :name
+    attr_reader :field_name
+    attr_reader :subject
+
+    def full_name
+      "#{@subject.name}: #{@name}"
     end
 
     def metadata
-      @subject.fields[name]
+      @subject.data_obj.fields[@field_name]
     end
 
     def vector
-      @subject.df[@field_name]
+      @subject.data_obj.df[@field_name]
     end
 
     def value

data/lib/remi/transform.rb

@@ -38,6 +38,12 @@ module Remi
       end
     end
 
+    def truncate(len)
+      memoize_as_lambda(__method__, len) do |(mlen), larg|
+        larg.slice(0,len)
+      end
+    end
+
     def concatenate(delimiter="")
       memoize_as_lambda(__method__, delimiter) do |(mdelimiter), *largs|
         Array(largs).join(mdelimiter)

data/lib/remi/version.rb

@@ -1,3 +1,3 @@
 module Remi
-  VERSION = '0.2.17'
+  VERSION = '0.2.18'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: remi
 version: !ruby/object:Gem::Version
-  version: 0.2.17
+  version: 0.2.18
 platform: ruby
 authors:
 - Sterling Paramore
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-24 00:00:00.000000000 Z
+date: 2016-03-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: daru
@@ -238,6 +238,7 @@ files:
 - features/transforms/nvl.feature
 - features/transforms/parse_date.feature
 - features/transforms/prefix.feature
+- features/transforms/truncate.feature
 - jobs/aggregate_job.rb
 - jobs/all_jobs_shared.rb
 - jobs/copy_source_job.rb
@@ -250,6 +251,7 @@ files:
 - jobs/transforms/parse_date_job.rb
 - jobs/transforms/prefix_job.rb
 - jobs/transforms/transform_jobs.rb
+- jobs/transforms/truncate_job.rb
 - lib/remi.rb
 - lib/remi/cli.rb
 - lib/remi/cucumber.rb
@@ -318,3 +320,4 @@ test_files:
 - features/transforms/nvl.feature
 - features/transforms/parse_date.feature
 - features/transforms/prefix.feature
+- features/transforms/truncate.feature