burner 1.5.0 → 1.8.0

data/lib/burner/library/collection/group.rb

@@ -16,6 +16,12 @@ module Burner
       # It is worth noting that the resulting hashes values are singular objects and not an array
       # like Ruby's Enumerable#group_by method.
       #
+      # If the insensitive option is set as true then each key's value will be coerced as
+      # a lowercase string.  This can help provide two types of insensitivity: case and type
+      # insensitivity.  This may be appropriate in some places but not others.  If any other
+      # value coercion is needed then another option would be to first transform the records
+      # before grouping them.
+      #
       # An example of this specific job:
       #
       # input: [{ id: 1, code: 'a' }, { id: 2, code: 'b' }]
@@ -25,18 +31,22 @@ module Burner
       # Expected Payload[register] input: array of objects.
       # Payload[register] output: hash.
       class Group < JobWithRegister
-        attr_reader :keys, :resolver
+        include Util::Keyable
+
+        attr_reader :insensitive, :keys, :resolver
 
         def initialize(
-          name:,
+          insensitive: false,
           keys: [],
+          name: '',
           register: DEFAULT_REGISTER,
           separator: ''
         )
           super(name: name, register: register)
 
-          @keys     = Array(keys)
-          @resolver = Objectable.resolver(separator: separator.to_s)
+          @insensitive = insensitive || false
+          @keys        = Array(keys)
+          @resolver    = Objectable.resolver(separator: separator.to_s)
 
           raise ArgumentError, 'at least one key is required' if @keys.empty?
 
@@ -50,18 +60,12 @@ module Burner
           output.detail("Grouping based on key(s): #{keys} for #{count} records(s)")
 
           grouped_records = payload[register].each_with_object({}) do |record, memo|
-            key       = make_key(record)
+            key       = make_key(record, keys, resolver, insensitive)
             memo[key] = record
           end
 
           payload[register] = grouped_records
         end
-
-        private
-
-        def make_key(record)
-          keys.map { |key| resolver.get(record, key) }
-        end
       end
     end
   end

data/lib/burner/library/collection/nested_aggregate.rb

@@ -21,7 +21,7 @@ module Burner
       class NestedAggregate < JobWithRegister
         attr_reader :key, :key_mappings, :resolver
 
-        def initialize(name:, key:, key_mappings: [], register: DEFAULT_REGISTER, separator: '')
+        def initialize(key:, key_mappings: [], name: '', register: DEFAULT_REGISTER, separator: '')
           super(name: name, register: register)
 
           raise ArgumentError, 'key is required' if key.to_s.empty?

data/lib/burner/library/collection/number.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Burner
+  module Library
+    module Collection
+      # This job can iterate over a set of records and sequence them (set the specified key to
+      # a sequential index value.)
+      #
+      # Expected Payload[register] input: array of objects.
+      # Payload[register] output: array of objects.
+      class Number < JobWithRegister
+        BLANK            = ''
+        DEFAULT_KEY      = 'number'
+        DEFAULT_START_AT = 1
+
+        attr_reader :key, :resolver, :start_at
+
+        def initialize(
+          key: DEFAULT_KEY,
+          name: BLANK,
+          register: Burner::DEFAULT_REGISTER,
+          separator: BLANK,
+          start_at: DEFAULT_START_AT
+        )
+          super(name: name, register: register)
+
+          @key      = key.to_s
+          @resolver = Objectable.resolver(separator: separator)
+          @start_at = start_at.to_i
+
+          freeze
+        end
+
+        def perform(output, payload)
+          output.detail("Setting '#{key}' for each record with values starting at #{start_at}")
+
+          ensure_array(payload).each.with_index(start_at) do |record, index|
+            resolver.set(record, key, index)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/burner/library/collection/objects_to_arrays.rb

@@ -58,7 +58,7 @@ module Burner
         # nested hashes then set separator to '.'.  For more information, see the underlying
         # library that supports this dot-notation concept:
         #   https://github.com/bluemarblepayroll/objectable
-        def initialize(name:, mappings: [], register: DEFAULT_REGISTER, separator: '')
+        def initialize(mappings: [], name: '', register: DEFAULT_REGISTER, separator: '')
           super(name: name, register: register)
 
           @mappings = Modeling::KeyIndexMapping.array(mappings)

data/lib/burner/library/collection/shift.rb

@@ -23,7 +23,7 @@ module Burner
 
         attr_reader :amount
 
-        def initialize(name:, amount: DEFAULT_AMOUNT, register: DEFAULT_REGISTER)
+        def initialize(amount: DEFAULT_AMOUNT, name: '', register: DEFAULT_REGISTER)
           super(name: name, register: register)
 
           @amount = amount.to_i

data/lib/burner/library/collection/transform.rb

@@ -28,9 +28,9 @@ module Burner
                     :resolver
 
         def initialize(
-          name:,
           attributes: [],
           exclusive: false,
+          name: '',
           register: DEFAULT_REGISTER,
           separator: BLANK
         )

data/lib/burner/library/collection/unpivot.rb

@@ -20,7 +20,7 @@ module Burner
         attr_reader :unpivot
 
         def initialize(
-          name:,
+          name: '',
           pivot_set: HashMath::Unpivot::PivotSet.new,
           register: DEFAULT_REGISTER
         )

data/lib/burner/library/collection/validate.rb

@@ -29,10 +29,10 @@ module Burner
                     :validations
 
         def initialize(
-          name:,
           invalid_register: DEFAULT_INVALID_REGISTER,
           join_char: DEFAULT_JOIN_CHAR,
           message_key: DEFAULT_MESSAGE_KEY,
+          name: '',
           register: DEFAULT_REGISTER,
           separator: '',
           validations: []

data/lib/burner/library/collection/values.rb

@@ -19,7 +19,7 @@ module Burner
       class Values < JobWithRegister
         attr_reader :include_keys
 
-        def initialize(name:, include_keys: false, register: DEFAULT_REGISTER)
+        def initialize(include_keys: false, name: '', register: DEFAULT_REGISTER)
           super(name: name, register: register)
 
           @include_keys = include_keys || false

data/lib/burner/library/collection/zip.rb

@@ -25,9 +25,9 @@ module Burner
         attr_reader :base_register, :with_register
 
         def initialize(
-          name:,
           with_register:,
           base_register: DEFAULT_REGISTER,
+          name: '',
           register: DEFAULT_REGISTER
         )
           super(name: name, register: register)

data/lib/burner/library/compress/row_reader.rb

@@ -33,10 +33,10 @@ module Burner
                     :resolver
 
         def initialize(
-          name:,
           data_key: DEFAULT_DATA_KEY,
           ignore_blank_data: false,
           ignore_blank_path: false,
+          name: '',
           path_key: DEFAULT_PATH_KEY,
           register: DEFAULT_REGISTER,
           separator: ''

data/lib/burner/library/deserialize/yaml.rb

@@ -20,7 +20,7 @@ module Burner
       class Yaml < JobWithRegister
         attr_reader :safe
 
-        def initialize(name:, register: DEFAULT_REGISTER, safe: true)
+        def initialize(name: '', register: DEFAULT_REGISTER, safe: true)
           super(name: name, register: register)
 
           @safe = safe

data/lib/burner/library/echo.rb

@@ -15,7 +15,7 @@ module Burner
     class Echo < Job
       attr_reader :message
 
-      def initialize(name:, message: '')
+      def initialize(message: '', name: '')
         super(name: name)
 
         @message = message.to_s

data/lib/burner/library/io/exist.rb

@@ -17,7 +17,7 @@ module Burner
       class Exist < Job
         attr_reader :disk, :path, :short_circuit
 
-        def initialize(name:, path:, disk: {}, short_circuit: false)
+        def initialize(path:, disk: {}, name: '', short_circuit: false)
           super(name: name)
 
           raise ArgumentError, 'path is required' if path.to_s.empty?

data/lib/burner/library/io/open_file_base.rb

@@ -14,7 +14,7 @@ module Burner
       class OpenFileBase < JobWithRegister
         attr_reader :binary, :disk, :path
 
-        def initialize(name:, path:, binary: false, disk: {}, register: DEFAULT_REGISTER)
+        def initialize(path:, binary: false, disk: {}, name: '', register: DEFAULT_REGISTER)
           super(name: name, register: register)
 
           raise ArgumentError, 'path is required' if path.to_s.empty?

data/lib/burner/library/io/row_reader.rb

@@ -35,12 +35,12 @@ module Burner
                     :resolver
 
         def initialize(
-          name:,
           binary: false,
           data_key: DEFAULT_DATA_KEY,
           disk: {},
           ignore_blank_path: false,
           ignore_file_not_found: false,
+          name: '',
           path_key: DEFAULT_PATH_KEY,
           register: DEFAULT_REGISTER,
           separator: ''

data/lib/burner/library/io/write.rb

@@ -12,11 +12,34 @@ require_relative 'open_file_base'
 module Burner
   module Library
     module IO
-      # Write value to disk.
+      # Write value to disk.  By default, written files are also logged as WrittenFile
+      # instances to the Payload#side_effects array.  You can pass in
+      # supress_side_effect: true to disable this behavior.
       #
       # Expected Payload[register] input: anything.
       # Payload[register] output: whatever was passed in.
       class Write < OpenFileBase
+        attr_reader :supress_side_effect
+
+        def initialize(
+          path:,
+          binary: false,
+          disk: {},
+          name: '',
+          register: DEFAULT_REGISTER,
+          supress_side_effect: false
+        )
+          @supress_side_effect = supress_side_effect || false
+
+          super(
+            binary: binary,
+            disk: disk,
+            name: name,
+            path: path,
+            register: register
+          )
+        end
+
         def perform(output, payload)
           logical_filename  = job_string_template(path, output, payload)
           physical_filename = nil
@@ -29,6 +52,10 @@ module Burner
 
           output.detail("Wrote to: #{physical_filename}")
 
+          return if supress_side_effect
+
+          output.detail("Saving to side effects: #{logical_filename}")
+
           side_effect = SideEffects::WrittenFile.new(
             logical_filename: logical_filename,
             physical_filename: physical_filename,

data/lib/burner/library/param/base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Burner
+  module Library
+    module Param
+      # Common logic shared across Param job subclasses.
+      class Base < JobWithRegister
+        BLANK = ''
+
+        attr_reader :param_key
+
+        def initialize(name: BLANK, param_key: BLANK, register: DEFAULT_REGISTER)
+          super(name: name, register: register)
+
+          @param_key = param_key.to_s
+
+          freeze
+        end
+      end
+    end
+  end
+end

data/lib/burner/library/param/from_register.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'base'
+
+module Burner
+  module Library
+    module Param
+      # Copy a register's value into a param key.  Generally speaking you should only be
+      # mutating registers, that way the params stay true to the passed in params for the
+      # pipeline.  But this job is available in case a param needs to be updated.
+      #
+      # Expected Payload[register] input: anything.
+      # Payload.params(param_key) output: whatever value was specified in the register.
+      class FromRegister < Base
+        def perform(output, payload)
+          output.detail("Pushing value from register: #{register} to param: #{param_key}")
+
+          payload.update_param(param_key, payload[register])
+        end
+      end
+    end
+  end
+end

data/lib/burner/library/param/to_register.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'base'
+
+module Burner
+  module Library
+    module Param
+      # Copy a param key's value into a register.
+      #
+      # Expected Payload.param(param_key) input: anything.
+      # Payload[register] output: whatever value was specified as the param_key's value.
+      class ToRegister < Base
+        def perform(output, payload)
+          output.detail("Pushing value to register: #{register} from param: #{param_key}")
+
+          payload[register] = payload.param(param_key)
+        end
+      end
+    end
+  end
+end

data/lib/burner/library/serialize/csv.rb

@@ -18,7 +18,7 @@ module Burner
       class Csv < JobWithRegister
         attr_reader :byte_order_mark
 
-        def initialize(name:, byte_order_mark: nil, register: DEFAULT_REGISTER)
+        def initialize(byte_order_mark: nil, name: '', register: DEFAULT_REGISTER)
           super(name: name, register: register)
 
           @byte_order_mark = Modeling::ByteOrderMark.resolve(byte_order_mark)

data/lib/burner/library/sleep.rb

@@ -15,7 +15,7 @@ module Burner
     class Sleep < Job
       attr_reader :seconds
 
-      def initialize(name:, seconds: 0)
+      def initialize(name: '', seconds: 0)
         super(name: name)
 
         @seconds = seconds.to_f

data/lib/burner/library/value/copy.rb

@@ -19,7 +19,7 @@ module Burner
       class Copy < Job
         attr_reader :from_register, :to_register
 
-        def initialize(name:, to_register: DEFAULT_REGISTER, from_register: DEFAULT_REGISTER)
+        def initialize(from_register: DEFAULT_REGISTER, name: '', to_register: DEFAULT_REGISTER)
           super(name: name)
 
           @from_register = from_register.to_s

data/lib/burner/library/value/nest.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2020-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Burner
+  module Library
+    module Value
+      # This job will nest the current value within a new outer hash.  The specified key
+      # passed in will be the corresponding new hash key entry for the existing value.
+      #
+      # Expected Payload[from_register] input: anything.
+      # Payload[to_register] output: hash.
+      class Nest < JobWithRegister
+        DEFAULT_KEY = 'key'
+
+        attr_reader :key
+
+        def initialize(key: DEFAULT_KEY, name: '', register: Burner::DEFAULT_REGISTER)
+          super(name: name, register: register)
+
+          @key = key.to_s
+
+          freeze
+        end
+
+        def perform(_output, payload)
+          payload[register] = { key => payload[register] }
+        end
+      end
+    end
+  end
+end