exel 1.4.0 → 1.5.1

data/lib/exel/logging/logger_wrapper.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module EXEL
   module Logging
     # Wraps calls to a logger to add {Logging} prefix to log messages
@@ -20,7 +21,9 @@ module EXEL
       end
 
       def add(severity, message = nil, progname = nil)
-        message = yield if message.nil? && block_given?
+        if message.nil? && block_given?
+          message = yield
+        end
         __getobj__.add(severity, "#{Logging.prefix}#{message}", progname)
       end
     end

data/lib/exel/logging_helper.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module EXEL
   # Logging related helper methods for processors
   module LoggingHelper

data/lib/exel/middleware/chain.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module EXEL
   # Middleware is code configured to run around each processor execution. Custom middleware can be added as follows:
   #

data/lib/exel/middleware/logging.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module EXEL
   module Middleware
     # Middleware to add a prefix to all messages logged during processor execution. The prefix is specified by the
@@ -12,7 +13,6 @@ module EXEL
 
       def log_process
         start_time = Time.now
-        EXEL.logger.info 'Starting'
 
         yield
 

data/lib/exel/null_instruction.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module EXEL
   # An {Instruction} that does nothing when executed
   class NullInstruction

data/lib/exel/processor_helper.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module EXEL
   # Helper methods useful to processors
   # @deprecated Most functionality replaced by {EXEL::Middleware::Logging} middleware.

data/lib/exel/processors/run_processor.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module EXEL
   module Processors
     # Implements the +run+ instruction.

data/lib/exel/processors/split_processor.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'csv'
 require 'tempfile'
 require_relative '../logging_helper'
@@ -65,7 +66,7 @@ module EXEL
       def process_file(callback)
         csv_options = @context[:csv_options] || {col_sep: ','}
 
-        CSV.foreach(@file.path, csv_options) do |line|
+        CSV.foreach(@file.path, **csv_options) do |line|
           process_line(line, callback)
 
           break if @tempfile_count == @max_chunks

data/lib/exel/providers/local_file_provider.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module EXEL
   module Providers
     # The default remote provider. Doesn't actually upload and download files to and from remote storage, but rather
@@ -14,7 +15,7 @@ module EXEL
       end
 
       def self.remote?(uri)
-        uri =~ %r{file://}
+        uri.to_s =~ %r{file://}
       end
     end
   end

data/lib/exel/providers/threaded_async_provider.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module EXEL
   module Providers
     # The default remote provider. Provides async execution by running the given EXEL block in a new Thread

data/lib/exel/sequence_node.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative './ast_node'
 
 module EXEL

data/lib/exel/value.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module EXEL
   # Contains methods to handle remote and local values. Used for {Context} serialization
   module Value

data/lib/exel/version.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module EXEL
-  VERSION = '1.4.0'
+  VERSION = '1.5.1'
 end

data/spec/exel/ast_node_spec.rb

@@ -1,61 +1,61 @@
 # frozen_string_literal: true
-module EXEL
-  describe ASTNode do
-    let(:context) { instance_double(EXEL::Context) }
 
-    def instruction
-      instance_double(Instruction, execute: nil)
-    end
+describe EXEL::ASTNode do
+  let(:context) { instance_double(EXEL::Context) }
 
-    TestNode = Class.new(ASTNode)
+  def instruction
+    instance_double(EXEL::Instruction, execute: nil)
+  end
 
-    describe '#start' do
-      context 'when a JobTermination error bubbles up' do
-        let(:node) { TestNode.new(instruction) }
+  class TestNode < EXEL::ASTNode
+  end
 
-        before do
-          allow(node).to receive(:run).and_raise(EXEL::Error::JobTermination, 'Error')
-        end
+  describe '#start' do
+    context 'when a JobTermination error bubbles up' do
+      let(:node) { TestNode.new(instruction) }
 
-        it 'ensures the process fails silently' do
-          expect(EXEL.logger).to receive(:error).with('JobTerminationError: Error')
-          expect { node.start(context) }.not_to raise_error
-        end
+      before do
+        allow(node).to receive(:run).and_raise(EXEL::Error::JobTermination, 'Error')
+      end
 
-        it 'logs the error by default' do
-          expect(EXEL.logger).to receive(:error).with('JobTerminationError: Error')
-          node.start(context)
-        end
+      it 'ensures the process fails silently' do
+        expect(EXEL.logger).to receive(:error).with('JobTerminationError: Error')
+        expect { node.start(context) }.not_to raise_error
+      end
 
-        context 'given a log instruction' do
-          before do
-            allow(node).to receive(:run).and_raise(EXEL::Error::JobTermination.new('Error', :warn))
-          end
+      it 'logs the error by default' do
+        expect(EXEL.logger).to receive(:error).with('JobTerminationError: Error')
+        node.start(context)
+      end
 
-          it 'logs the error with the given cmd' do
-            expect(EXEL.logger).to receive(:warn).with('JobTerminationError: Error')
-            node.start(context)
-          end
+      context 'given a log instruction' do
+        before do
+          allow(node).to receive(:run).and_raise(EXEL::Error::JobTermination.new('Error', :warn))
+        end
+
+        it 'logs the error with the given cmd' do
+          expect(EXEL.logger).to receive(:warn).with('JobTerminationError: Error')
+          node.start(context)
         end
       end
     end
+  end
 
-    describe '#run' do
-      it 'raises an error if not implemented' do
-        expect { TestNode.new(instruction).run(context) }.to raise_error 'EXEL::TestNode does not implement #process'
-      end
+  describe '#run' do
+    it 'raises an error if not implemented' do
+      expect { TestNode.new(instruction).run(context) }.to raise_error 'TestNode does not implement #process'
     end
+  end
 
-    describe '#add_child' do
-      it 'adds the given node to its children' do
-        root = ASTNode.new(instruction)
-        child_node = ASTNode.new(instruction)
-        child_node2 = ASTNode.new(instruction)
-        root.add_child(child_node)
-        root.add_child(child_node2)
+  describe '#add_child' do
+    it 'adds the given node to its children' do
+      root = EXEL::ASTNode.new(instruction)
+      child_node = EXEL::ASTNode.new(instruction)
+      child_node2 = EXEL::ASTNode.new(instruction)
+      root.add_child(child_node)
+      root.add_child(child_node2)
 
-        expect(root.children).to eq([child_node, child_node2])
-      end
+      expect(root.children).to eq([child_node, child_node2])
     end
   end
 end

data/spec/exel/context_spec.rb

@@ -1,109 +1,108 @@
 # frozen_string_literal: true
-module EXEL
-  describe Context do
-    subject(:context) { EXEL::Context.new(key1: '1', key2: 2) }
 
-    it { is_expected.to be_a(Hash) }
+describe EXEL::Context do
+  subject(:context) { EXEL::Context.new(key1: '1', key2: 2) }
 
-    describe '#initialize' do
-      it 'initializes with a hash' do
-        expect(context[:key1]).to eq('1')
-        expect(context[:key2]).to eq(2)
-        expect(context[:key3]).to be_nil
-      end
+  it { is_expected.to be_a(Hash) }
+
+  describe '#initialize' do
+    it 'initializes with a hash' do
+      expect(context[:key1]).to eq('1')
+      expect(context[:key2]).to eq(2)
+      expect(context[:key3]).to be_nil
     end
+  end
 
-    describe '#deep_dup' do
-      it 'returns a deep copy of itself' do
-        context[:a] = {nested: []}
+  describe '#deep_dup' do
+    it 'returns a deep copy of itself' do
+      context[:a] = {nested: []}
 
-        dup = context.deep_dup
-        expect(context).to eq(dup)
-        expect(context).not_to be_equal(dup)
+      dup = context.deep_dup
+      expect(context).to eq(dup)
+      expect(context).not_to be_equal(dup)
 
-        dup[:a][:nested] << 1
-        expect(context[:a][:nested]).to be_empty
-      end
+      dup[:a][:nested] << 1
+      expect(context[:a][:nested]).to be_empty
     end
+  end
 
-    describe '#serialize' do
-      before { allow(Value).to receive(:upload) }
-
-      it 'writes the serialized context to a file and upload it' do
-        expect(Value).to receive(:remotize).with(context[:key1]).and_return('remote_value1')
-        expect(Value).to receive(:remotize).with(context[:key2]).and_return('remote_value2')
+  describe '#serialize' do
+    before { allow(EXEL::Value).to receive(:upload) }
 
-        expect(SecureRandom).to receive(:uuid).and_return('uuid')
+    it 'writes the serialized context to a file and upload it' do
+      expect(EXEL::Value).to receive(:remotize).with(context[:key1]).and_return('remote_value1')
+      expect(EXEL::Value).to receive(:remotize).with(context[:key2]).and_return('remote_value2')
 
-        expect(Value).to receive(:remotize) do |file|
-          expect(file.read).to eq(Marshal.dump(Context.new(key1: 'remote_value1', key2: 'remote_value2')))
-          expect(file.path).to include('uuid')
-          'file_uri'
-        end
+      expect(SecureRandom).to receive(:uuid).and_return('uuid')
 
-        expect(context.serialize).to eq('file_uri')
+      expect(EXEL::Value).to receive(:remotize) do |file|
+        expect(file.read).to eq(Marshal.dump(EXEL::Context.new(key1: 'remote_value1', key2: 'remote_value2')))
+        expect(file.path).to include('uuid')
+        'file_uri'
       end
 
-      it 'does not mutate the current context' do
-        allow(Value).to receive(:remotize).and_return('remote_value')
-        original_table = context.dup
-        context.serialize
-        expect(context).to eq(original_table)
-      end
+      expect(context.serialize).to eq('file_uri')
     end
 
-    describe '.deserialize' do
-      it 'deserializes a given uri' do
-        file = StringIO.new(Marshal.dump(context))
-        expect(Value).to receive(:localize).with('uri').and_return(file)
+    it 'does not mutate the current context' do
+      allow(EXEL::Value).to receive(:remotize).and_return('remote_value')
+      original_table = context.dup
+      context.serialize
+      expect(context).to eq(original_table)
+    end
+  end
 
-        expect(Context.deserialize('uri')).to eq(context)
+  describe '.deserialize' do
+    it 'deserializes a given uri' do
+      file = StringIO.new(Marshal.dump(context))
+      expect(EXEL::Value).to receive(:localize).with('uri').and_return(file)
 
-        expect(file).to be_closed
-      end
+      expect(EXEL::Context.deserialize('uri')).to eq(context)
+
+      expect(file).to be_closed
     end
+  end
 
-    shared_examples 'a reader method' do
-      subject(:context) { EXEL::Context.new(key: 'value') }
+  shared_examples 'a reader method' do
+    subject(:context) { EXEL::Context.new(key: 'value') }
 
-      it 'returns the value' do
-        expect(context.send(method, :key)).to eq('value')
-      end
+    it 'returns the value' do
+      expect(context.send(method, :key)).to eq('value')
+    end
 
-      it 'localizes the returned value' do
-        expect(Value).to receive(:localize).with('value').and_return('localized')
-        expect(context.send(method, :key)).to eq('localized')
-      end
+    it 'localizes the returned value' do
+      expect(EXEL::Value).to receive(:localize).with('value').and_return('localized')
+      expect(context.send(method, :key)).to eq('localized')
+    end
 
-      it 'stores the localized value' do
-        allow(Value).to receive(:localize).with('value').and_return('localized')
-        context.send(method, :key)
-        allow(Value).to receive(:localize).with('localized').and_return('localized')
-        context.send(method, :key)
-      end
+    it 'stores the localized value' do
+      allow(EXEL::Value).to receive(:localize).with('value').and_return('localized')
+      context.send(method, :key)
+      allow(EXEL::Value).to receive(:localize).with('localized').and_return('localized')
+      context.send(method, :key)
+    end
 
-      it 'looks up deferred values' do
-        # eq(context) as an argument matcher is necessary to prevent RSpec from calling fetch on the context, leading to
-        # a stack overflow
-        expect(DeferredContextValue).to receive(:resolve).with('value', eq(context)).and_return('resolved')
-        expect(context.send(method, :key)).to eq('resolved')
-      end
+    it 'looks up deferred values' do
+      # eq(context) as an argument matcher is necessary to prevent RSpec from calling fetch on the context, leading to
+      # a stack overflow
+      expect(EXEL::DeferredContextValue).to receive(:resolve).with('value', eq(context)).and_return('resolved')
+      expect(context.send(method, :key)).to eq('resolved')
     end
+  end
 
-    describe '#[]' do
-      it_behaves_like 'a reader method' do
-        let(:method) { :[] }
-      end
+  describe '#[]' do
+    it_behaves_like 'a reader method' do
+      let(:method) { :[] }
     end
+  end
 
-    describe '#fetch' do
-      it 'raises an exception if the key is not found' do
-        expect { context.fetch(:unknown) }.to raise_error(KeyError)
-      end
+  describe '#fetch' do
+    it 'raises an exception if the key is not found' do
+      expect { context.fetch(:unknown) }.to raise_error(KeyError)
+    end
 
-      it_behaves_like 'a reader method' do
-        let(:method) { :fetch }
-      end
+    it_behaves_like 'a reader method' do
+      let(:method) { :fetch }
     end
   end
 end

data/spec/exel/deferred_context_value_spec.rb

@@ -1,66 +1,65 @@
 # frozen_string_literal: true
-module EXEL
-  describe DeferredContextValue do
-    subject(:deferred_value) { DeferredContextValue.new }
 
-    describe '.resolve' do
-      subject(:deferred_value) { DeferredContextValue.new[:key] }
+describe EXEL::DeferredContextValue do
+  subject(:deferred_value) { EXEL::DeferredContextValue.new }
 
-      context 'at the top level' do
-        let(:context) { {key: 'value', deferred_value: deferred_value} }
+  describe '.resolve' do
+    subject(:deferred_value) { EXEL::DeferredContextValue.new[:key] }
 
-        it 'returns the lookup value from the context' do
-          expect(DeferredContextValue.resolve(context[:deferred_value], context)).to eq(context[:key])
-        end
+    context 'at the top level' do
+      let(:context) { {key: 'value', deferred_value: deferred_value} }
+
+      it 'returns the lookup value from the context' do
+        expect(EXEL::DeferredContextValue.resolve(context[:deferred_value], context)).to eq(context[:key])
       end
+    end
 
-      context 'in an array' do
-        let(:context) { {key: 'value', array: [1, 2, deferred_value]} }
+    context 'in an array' do
+      let(:context) { {key: 'value', array: [1, 2, deferred_value]} }
 
-        it 'returns the lookup value from the context' do
-          expect(DeferredContextValue.resolve(context[:array], context)).to eq([1, 2, context[:key]])
-        end
+      it 'returns the lookup value from the context' do
+        expect(EXEL::DeferredContextValue.resolve(context[:array], context)).to eq([1, 2, context[:key]])
       end
+    end
 
-      context 'in a hash' do
-        let(:context) { {key: 'value', hash: {hash_key: deferred_value}} }
+    context 'in a hash' do
+      let(:context) { {key: 'value', hash: {hash_key: deferred_value}} }
 
-        it 'returns the lookup value from the context' do
-          expect(DeferredContextValue.resolve(context[:hash], context)).to eq(hash_key: context[:key])
-        end
+      it 'returns the lookup value from the context' do
+        expect(EXEL::DeferredContextValue.resolve(context[:hash], context)).to eq(hash_key: context[:key])
       end
+    end
 
-      context 'in a hash nested in an array' do
-        let(:context) { {key: 'value', nested: [{}, {hash_key: deferred_value}]} }
+    context 'in a hash nested in an array' do
+      let(:context) { {key: 'value', nested: [{}, {hash_key: deferred_value}]} }
 
-        it 'looks up a deferred context value in a hash nested in an array' do
-          expect(DeferredContextValue.resolve(context[:nested], context)).to eq([{}, {hash_key: context[:key]}])
-        end
+      it 'looks up a deferred context value in a hash nested in an array' do
+        expect(EXEL::DeferredContextValue.resolve(context[:nested], context)).to eq([{}, {hash_key: context[:key]}])
       end
+    end
 
-      context 'in an array nested in a hash' do
-        let(:context) { {key: 'value', nested: {hash_key: [1, deferred_value]}} }
+    context 'in an array nested in a hash' do
+      let(:context) { {key: 'value', nested: {hash_key: [1, deferred_value]}} }
 
-        it 'looks up a deferred context value in an array nested in a hash' do
-          expect(DeferredContextValue.resolve(context[:nested], context)).to eq(hash_key: [1, context[:key]])
-        end
+      it 'looks up a deferred context value in an array nested in a hash' do
+        expect(EXEL::DeferredContextValue.resolve(context[:nested], context)).to eq(hash_key: [1, context[:key]])
       end
     end
+  end
 
-    describe '#[]' do
-      it 'stores the given key in the keys attribute' do
-        deferred_value[:top_level_key]['sub_key']
-        expect(deferred_value.keys).to eq([:top_level_key, 'sub_key'])
-      end
+  describe '#[]' do
+    it 'stores the given key in the keys attribute' do
+      deferred_value[:top_level_key]['sub_key']
+      expect(deferred_value.keys).to eq([:top_level_key, 'sub_key'])
     end
+  end
 
-    describe '#get' do
-      it 'looks up the value of the keys attribute in the passed-in context' do
-        allow(deferred_value).to receive(:keys).and_return([:top_level_key, 'sub_key'])
-        value = 'example_value'
-        context = Context.new(top_level_key: {'sub_key' => value})
-        expect(deferred_value.get(context)).to eq(value)
-      end
+  describe '#get' do
+    it 'looks up the value of the keys attribute in the passed-in context' do
+      allow(deferred_value).to receive(:keys).and_return([:top_level_key, 'sub_key'])
+      value = 'example_value'
+      context = EXEL::Context.new(top_level_key: {'sub_key' => value})
+      expect(deferred_value.get(context)).to eq(value)
     end
   end
 end