burner 1.6.0 → 1.9.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/pivot.rb

@@ -0,0 +1,150 @@
+# 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
+      # Take an array of objects and pivot a key into multiple keys.  It essentially takes all
+      # the values for a key and creates N number of keys (one per value.)
+      # Under the hood it uses HashMath's Record and Table classes:
+      # https://github.com/bluemarblepayroll/hash_math
+      #
+      # An example of a normalized dataset that could be pivoted:
+      #
+      # records = [
+      #   { patient_id: 1, key: :first_name, value: 'bozo' },
+      #   { patient_id: 1, key: :last_name,  value: 'clown' },
+      #   { patient_id: 2, key: :first_name, value: 'frank' },
+      #   { patient_id: 2, key: :last_name,  value: 'rizzo' },
+      # ]
+      #
+      # Using the following job configuration:
+      #
+      # config = {
+      #   unique_key: :patient_id
+      # }
+      #
+      # Once ran through this job, it would set the register to:
+      #
+      # records = [
+      #   { patient_id: 1, first_name: 'bozo', last_name: 'clown' },
+      #   { patient_id: 2, first_name: 'frank', last_name: 'rizzo' },
+      # ]
+      #
+      # Expected Payload[register] input: array of objects.
+      # Payload[register] output: An array of objects.
+      class Pivot < JobWithRegister
+        DEFAULT_PIVOT_KEY       = :key
+        DEFAULT_PIVOT_VALUE_KEY = :value
+
+        attr_reader :insensitive,
+                    :other_keys,
+                    :non_pivoted_keys,
+                    :pivot_key,
+                    :pivot_value_key,
+                    :resolver,
+                    :unique_keys
+
+        def initialize(
+          unique_keys:,
+          insensitive: false,
+          name: '',
+          other_keys: [],
+          pivot_key: DEFAULT_PIVOT_KEY,
+          pivot_value_key: DEFAULT_PIVOT_KEY_VALUE,
+          register: DEFAULT_REGISTER,
+          separator: ''
+        )
+          super(name: name, register: register)
+
+          @insensitive      = insensitive || false
+          @pivot_key        = pivot_key.to_s
+          @pivot_value_key  = pivot_value_key.to_s
+          @resolver         = Objectable.resolver(separator: separator)
+          @unique_keys      = Array(unique_keys)
+          @other_keys       = Array(other_keys)
+          @non_pivoted_keys = @unique_keys + @other_keys
+
+          freeze
+        end
+
+        def perform(output, payload)
+          objects = array(payload[register])
+          table   = make_table(objects)
+
+          output.detail("Pivoting #{objects.length} object(s)")
+          output.detail("By key: #{pivot_key} and value: #{pivot_value_key}")
+
+          objects.each { |object| object_to_table(object, table) }
+
+          pivoted_objects = table.to_a.map(&:fields)
+
+          output.detail("Resulting dataset has #{pivoted_objects.length} object(s)")
+
+          payload[register] = pivoted_objects
+        end
+
+        private
+
+        def resolve_key(object)
+          key_to_use = resolver.get(object, pivot_key)
+
+          make_key(key_to_use)
+        end
+
+        def make_key(value)
+          insensitive ? value.to_s.downcase : value
+        end
+
+        def make_row_id(object)
+          unique_keys.map { |k| make_key(resolver.get(object, k)) }
+        end
+
+        def make_key_map(objects)
+          objects.each_with_object({}) do |object, key_map|
+            key = resolver.get(object, pivot_key)
+            unique_key = make_key(key)
+
+            key_map[unique_key] ||= Set.new
+
+            key_map[unique_key] << key
+          end
+        end
+
+        def make_record(objects)
+          key_map = make_key_map(objects)
+          keys    = non_pivoted_keys + key_map.values.map(&:first)
+
+          HashMath::Record.new(keys)
+        end
+
+        def make_table(objects)
+          HashMath::Table.new(make_record(objects))
+        end
+
+        def object_to_table(object, table)
+          row_id = make_row_id(object)
+
+          non_pivoted_keys.each do |key|
+            value = resolver.get(object, key)
+
+            table.add(row_id, key, value)
+          end
+
+          key_to_use   = resolve_key(object)
+          value_to_use = resolver.get(object, pivot_value_key)
+
+          table.add(row_id, key_to_use, value_to_use)
+
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -22,10 +22,10 @@ module Burner
         attr_reader :supress_side_effect
 
         def initialize(
-          name:,
           path:,
           binary: false,
           disk: {},
+          name: '',
           register: DEFAULT_REGISTER,
           supress_side_effect: false
         )

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