pipe-ruby 0.3.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d0eca86ffad3466f3843db7cb3013985bfc1c3bf
-  data.tar.gz: df2cd7013334b5abce3608c1c85bcd4ca261201a
+  metadata.gz: 195a31eb3c9e9ddb6f80a553703cf0501c50b72f
+  data.tar.gz: abfdff691c25899d33931d210180c423a612550f
 SHA512:
-  metadata.gz: 918395735261b1110693cfa0c08d933e5c7c8ea5e0a73597a3d067a5fc3b29044f36a47b608dfb5a0c911f9df1f3711ff50fbf765bb6a960b91bff22670a30f8
-  data.tar.gz: 9338db4f769305be5ad63474cca4e4e2ef2fcfebee1f8eb0ade7a2231f992beebfe6e92d842e31be5e823c1d208ba109c911cd72c63f944048214b785d342bf8
+  metadata.gz: 6e245799adc6c83fd32ac002b45fafd1475b03beec178e0b99871f4dd891185c912d0bcc7f4dd2bf9f7e2e87777b55a8bbeafbc496a8062b113eb71c86aebed3
+  data.tar.gz: 84c1fe2750d276eaf7d673f2040e018102f31c3de8f98ceb7a83c3161e5b46f832241dc58fa4fdac5b850ea33617d5709fbdb5b9ce68cbd278f17e75fc283686

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+# Change Log
+
+## 1.0.0 (2020-02-25)
+- remove pipe-ruby error handling

data/README.md

@@ -55,15 +55,9 @@ configurable options. Here they are with their defaults:
 
 ```ruby
 Pipe::Config.new(
-  :error_handlers => [],        # an array of procs to be called when an error
-                                # occurs
-  :raise_on_error => true,      # tells Pipe to re-raise errors which occur
-  :return_on_error => :subject, # when an error happens and raise error is false
-                                # returns the current value of subject defaultly;
-                                # if callable, will return the result of the call
-                                # if not callable, will return the value
   :skip_on => false,            # a truthy value or proc which tells pipe to skip
                                 # the next method in the `through` array
+
   :stop_on => false             # a truthy value or proc which tells pipe to stop
                                 # processing and return the current value
 )
@@ -82,7 +76,7 @@ class MyClass
   include Pipe
 
   def my_method
-    config = Pipe::Config.new(:raise_on_error => false)
+    config = Pipe::Config.new(:skip_on => false)
     subject = Object.new
 
     pipe(subject, :config => config, :through => [
@@ -101,7 +95,7 @@ class MyClass
   include Pipe
 
   def pipe_config
-    Pipe::Config.new(:raise_on_error => false)
+    Pipe::Config.new(:skip_on => false)
   end
 
   # ...
@@ -115,45 +109,13 @@ class MyClass
   include Pipe
 
   def initialize
-    @pipe_config = Pipe::Config.new(:raise_on_error => false)
+    @pipe_config = Pipe::Config.new(:skip_on => false)
   end
 
   # ...
 end
 ```
 
-## Error Handling
-
-As we implemented different versions of `pipe` across our infrastructure, we
-came across several different error handling needs.
-
-- logging errors that occur in methods called by pipe without raising them
-- catching and re-raising errors with additional information so we can still
-  see the real backtrace while also gaining insight into which subject and
-  method combination triggered the error
-- easily seeing which area of the pipe stack we were in when an error occurred
-
-The first layer of error handling is the `error_handlers` attribute in
-`Pipe::Config`. Each proc in this array will be called with two arguments,
-the actual error object and a context hash containing the method and subject
-when the error occurred. If an error occurs within one of these handlers it
-will be re-raised inside the `Pipe::HandlerError` namespace, meaning a
-`NameError` becomes a `Pipe::HandlerError::NameError`. We also postpend the
-current method, current subject and original error class to the message.
-
-NOTE: `Pipe::Config#error_handler` takes a block and adds it to the existing
-error handlers.
-
-We have two other namespaces, `Pipe::ReducerError`, which is used when an error
-occurs inside during `pipe` execution and `Pipe::IteratorError` for errors which
-occur inside of `pipe_each` execution.
-
-Whenever an error occurs in execution (but not in error handler processing), the
-response of `Pipe::Config#raise_on_error?` is checked. If this method returns
-`true`, the error will be re-raised inside of the appropriate namespace. If it
-returns `false`, the current value of `subject` will be returned and execution
-stopped.
-
 ## Skipping / Stopping Execution
 
 At the beginning of each iteration, `Pipe::Config#stop_on` is called. If it

data/lib/pipe.rb

@@ -1,6 +1,5 @@
 require "pipe/ext/string"
 require "pipe/config"
-require "pipe/error"
 require "pipe/iterator"
 require "pipe/reducer"
 

data/lib/pipe/config.rb

@@ -1,34 +1,19 @@
 module Pipe
   class Config
-    attr_accessor :raise_on_error
-    attr_reader :error_handlers, :return_on_error, :skip_on, :stop_on
+    attr_reader :skip_on, :stop_on
 
     def initialize(
-      error_handlers: [],
-      raise_on_error: true,
-      return_on_error: :subject,
       skip_on: false,
       stop_on: false
     )
-      @error_handlers = error_handlers
-      @raise_on_error = raise_on_error
-      @return_on_error = return_on_error
       self.skip_on = skip_on
       self.stop_on = stop_on
     end
 
-    def error_handler(&block)
-      error_handlers << block if block_given?
-    end
-
     def break?(*args)
       stop_on.call(*args) ? true : false
     end
 
-    def raise_on_error?
-      raise_on_error ? true : false
-    end
-
     def skip?(*args)
       skip_on.call(*args) ? true : false
     end

data/lib/pipe/iterator.rb

@@ -9,33 +9,18 @@ module Pipe
 
     def iterate
       subjects.map { |subject|
-        begin
-          Reducer.new(
-            config: config,
-            context: context,
-            subject: subject,
-            through: through
-          ).reduce
-        rescue => e
-          handle_error(:error => e, :subject => subject)
-          subject
-        end
+        Reducer.new(
+          config: config,
+          context: context,
+          subject: subject,
+          through: through
+        ).reduce
       }
     end
 
     private
-
     attr_accessor :config, :context, :subjects, :through
 
-    def handle_error(error:, subject:)
-      if config.raise_on_error?
-        Error.process(
-          :data => { :subject => subject },
-          :error => error,
-          :namespace => IterationError,
-        )
-      end
-    end
   end
 end
 

data/lib/pipe/reducer.rb

@@ -9,15 +9,8 @@ module Pipe
 
     def reduce
       through.reduce(subject) { |subj, method|
-        begin
-          break subj if config.break?(subj, method, through)
-
-          process(subj, method)
-        rescue => e
-          payload = {:error => e, :method => method, :subject => subj}
-          handle_error(payload)
-          break error_response(payload)
-        end
+        break subj if config.break?(subj, method, through)
+        process(subj, method)
       }
     end
 
@@ -25,32 +18,6 @@ module Pipe
 
     attr_accessor :config, :context, :subject, :through
 
-    def error_response(error:, method:, subject:)
-      if config.return_on_error == :subject
-        subject
-      elsif config.return_on_error.respond_to?(:call)
-        config.return_on_error.call(subject, method, error)
-      else
-        config.return_on_error
-      end
-    end
-
-    def handle_error(error:, method:, subject:)
-      process_error_handlers(
-        :error => error,
-        :method => method,
-        :subject => subject
-      )
-
-      if config.raise_on_error?
-        Error.process(
-          :data => { :method => method, :subject => subject },
-          :error => error,
-          :namespace => ReducerError,
-        )
-      end
-    end
-
     def process(subj, method)
       if config.skip?(subj, method, through)
         subj
@@ -58,20 +25,6 @@ module Pipe
         context.send(method, subj)
       end
     end
-
-    def process_error_handlers(error:, method:, subject:)
-      data = { method: method, subject: subject }
-
-      begin
-        config.error_handlers.each { |handler| handler.call(error, data) }
-      rescue => e
-        Error.process(
-          :data => data,
-          :error => e,
-          :namespace => HandlerError,
-        )
-      end
-    end
   end
 end
 

data/lib/pipe/version.rb

@@ -1,3 +1,3 @@
 module Pipe
-  VERSION = "0.3.1"
+  VERSION = "1.0.0"
 end

data/pipe-ruby.gemspec

@@ -6,8 +6,8 @@ require 'pipe/version'
 Gem::Specification.new do |spec|
   spec.name          = "pipe-ruby"
   spec.version       = Pipe::VERSION
-  spec.authors       = ["Dan Matthews"]
-  spec.email         = ["oss@teamsnap.com"]
+  spec.authors       = ["Dan Matthews, Paul Hanyzewski"]
+  spec.email         = ["devs@teamsnap.com"]
   spec.summary       = %q{Ruby implementation of the UNIX pipe}
   spec.description   = %q{}
   spec.homepage      = ""

data/spec/pipe/config_spec.rb

@@ -2,18 +2,6 @@ require "spec_helper"
 
 describe Pipe::Config do
   describe "defaults" do
-    it "sets error handlers to a blank array" do
-      expect(Pipe::Config.new.error_handlers).to eq([])
-    end
-
-    it "sets raise_on_error to true" do
-      expect(Pipe::Config.new.raise_on_error).to eq(true)
-    end
-
-    it "sets return_on_error to :subject" do
-      expect(Pipe::Config.new.return_on_error).to eq(:subject)
-    end
-
     it "sets skip_on to a proc which returns false" do
       expect(Pipe::Config.new.skip_on.call).to eq(false)
     end
@@ -23,21 +11,6 @@ describe Pipe::Config do
     end
   end
 
-  describe "#error_handler" do
-    context "when passed a block" do
-      it "adds the block to the error_handlers array" do
-        config = Pipe::Config.new
-        block = proc { "error handler" }
-
-        expect{ config.error_handler(&block) }
-          .to change{ config.error_handlers.size }
-          .by(1)
-
-        expect(config.error_handlers.last).to eq(block)
-      end
-    end
-  end
-
   describe "#break?" do
     it "returns a truthy version of the result of calling stop_on" do
       config = Pipe::Config.new(:stop_on => proc { 1 })
@@ -57,18 +30,6 @@ describe Pipe::Config do
     end
   end
 
-  describe "#raise_on_error?" do
-    it "returns a truthy version of raise_on_error" do
-      config = Pipe::Config.new
-      config.raise_on_error = nil
-      expect(config.raise_on_error?).to eq(false)
-      config.raise_on_error = true
-      expect(config.raise_on_error?).to eq(true)
-      config.raise_on_error = "yes"
-      expect(config.raise_on_error?).to eq(true)
-    end
-  end
-
   describe "#skip?" do
     it "returns a truthy version of the result of calling skip_on" do
       config = Pipe::Config.new(:skip_on => proc { 42 })

data/spec/pipe/iterator_spec.rb

@@ -27,60 +27,20 @@ describe Pipe::Iterator do
     end
 
     describe "when an error occurs" do
-      describe "and Config#raise_on_error is set to false" do
-        it "does not raise" do
-          dub = Object.new
-          dub.singleton_class.send(:define_method, :reduce) do
-            raise StandardError, "fail"
-          end
-          iterator = Pipe::Iterator.new(
-            :config => Pipe::Config.new(:raise_on_error => false),
-            :context => Object.new,
-            :subjects => [Object.new],
-            :through => [:to_s]
-          )
-          expect(Pipe::Reducer).to receive(:new).and_return(dub)
-
-          expect{ iterator.iterate }.to_not raise_error
-        end
-
-        it "returns an array of the original items" do
-          dub = Object.new
-          dub.singleton_class.send(:define_method, :reduce) do
-            raise StandardError, "fail"
-          end
-          subjects = [Object.new, Object.new]
-          iterator = Pipe::Iterator.new(
-            :config => Pipe::Config.new(:raise_on_error => false),
-            :context => Object.new,
-            :subjects => subjects,
-            :through => [:to_s]
-          )
-          expect(Pipe::Reducer)
-            .to receive(:new)
-            .and_return(dub)
-            .exactly(2).times
-
-          expect(iterator.iterate).to eq(subjects)
-        end
-      end
-
-      describe "and Config#raise_on_error is set to true" do
-        it "raises" do
-          dub = Object.new
-          dub.singleton_class.send(:define_method, :reduce) do
-            raise StandardError, "fail"
-          end
-          iterator = Pipe::Iterator.new(
-            :config => Pipe::Config.new(:raise_on_error => true),
-            :context => Object.new,
-            :subjects => [Object.new],
-            :through => [:to_s]
-          )
-          expect(Pipe::Reducer).to receive(:new).and_return(dub)
-
-          expect{ iterator.iterate }.to raise_error
+      it "raises an error" do
+        dub = Object.new
+        dub.singleton_class.send(:define_method, :reduce) do
+          raise StandardError, "fail"
         end
+        iterator = Pipe::Iterator.new(
+          :config => Pipe::Config.new(),
+          :context => Object.new,
+          :subjects => [Object.new],
+          :through => [:to_s]
+        )
+        expect(Pipe::Reducer).to receive(:new).and_return(dub)
+
+        expect{ iterator.iterate }.to raise_error
       end
     end
   end

data/spec/pipe/reducer_spec.rb

@@ -112,120 +112,24 @@ describe Pipe::Reducer do
       expect(reducer.reduce).to eq(subject.to_s.to_sym)
     end
 
-    it "calls the error handlers when a raise occurs" do
-      handler1 = Proc.new {}
-      handler2 = Proc.new {}
-      config = Pipe::Config.new(:error_handlers => [handler1, handler2])
-      context = Class.new do
-        ExpectedError = Class.new(StandardError)
-
-        def bomb(subject)
-          raise ExpectedError, "BOOM!"
-        end
-      end.new
+    it "does not modify errors" do
+      config = Pipe::Config.new()
+      OneMoreError = Class.new(StandardError)
 
-      expect(handler1).to receive(:call)
-      expect(handler2).to receive(:call)
-
-      expect{
-        Pipe::Reducer.new(
-          :config => config,
-          :context => context,
-          :subject => Object.new,
-          :through => [:bomb]
-        ).reduce
-      }.to raise_error
-    end
-
-    it "honors Config#raise_on_error" do
-      config = Pipe::Config.new(:raise_on_error => false)
       context = Class.new do
-        AnotherExpectedError = Class.new(StandardError)
-
-        def bomb(subject)
-          raise AnotherExpectedError, "BOOM!"
-        end
-      end.new
-
-      expect{
-        Pipe::Reducer.new(
-          :config => config,
-          :context => context,
-          :subject => Object.new,
-          :through => [:bomb]
-        ).reduce
-      }.to_not raise_error
-    end
-
-    it "honors Config#return_on_error :subject default" do
-      config = Pipe::Config.new(:raise_on_error => false)
-      context = Class.new do
-        AndAnotherExpectedError = Class.new(StandardError)
-
-        def bomb(subject)
-          raise AndAnotherExpectedError, "BOOM!"
-        end
-      end.new
-      subject = Object.new
-
-      expect(
-        Pipe::Reducer.new(
-          :config => config,
-          :context => context,
-          :subject => subject,
-          :through => [:bomb]
-        ).reduce
-      ).to eq(subject)
-    end
-
-    it "honors Config#return_on_error callable objects" do
-      subject = Object.new
-      config = Pipe::Config.new(
-        :raise_on_error => false,
-        :return_on_error => proc { |subj, method, e|
-          [subj, method, e.class, e.to_s, :hello]
-        }
-      )
-      context = Class.new do
-        YetAnotherExpectedError = Class.new(StandardError)
-
-        def bomb(subject)
-          raise YetAnotherExpectedError, "BOOM!"
-        end
-      end.new
-      expected = [subject, :bomb, YetAnotherExpectedError, "BOOM!", :hello]
-
-      expect(
-        Pipe::Reducer.new(
-          :config => config,
-          :context => context,
-          :subject => subject,
-          :through => [:bomb]
-        ).reduce
-      ).to eq(expected)
-    end
-
-    it "returns Config#return_on_error when not callable" do
-      config = Pipe::Config.new(
-        :raise_on_error => false,
-        :return_on_error => :error
-      )
-      context = Class.new do
-        OneMoreError = Class.new(StandardError)
-
         def bomb(subject)
           raise OneMoreError, "BOOM!"
         end
       end.new
 
-      expect(
+      expect{
         Pipe::Reducer.new(
           :config => config,
           :context => context,
           :subject => Object.new,
           :through => [:bomb]
         ).reduce
-      ).to eq(:error)
+      }.to raise_error(OneMoreError)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pipe-ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 1.0.0
 platform: ruby
 authors:
-- Dan Matthews
+- Dan Matthews, Paul Hanyzewski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-12 00:00:00.000000000 Z
+date: 2020-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -68,20 +68,20 @@ dependencies:
         version: '0'
 description: ''
 email:
-- oss@teamsnap.com
+- devs@teamsnap.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/pipe.rb
 - lib/pipe/config.rb
-- lib/pipe/error.rb
 - lib/pipe/ext/inflection.rb
 - lib/pipe/ext/string.rb
 - lib/pipe/iterator.rb
@@ -89,7 +89,6 @@ files:
 - lib/pipe/version.rb
 - pipe-ruby.gemspec
 - spec/pipe/config_spec.rb
-- spec/pipe/error_spec.rb
 - spec/pipe/iterator_spec.rb
 - spec/pipe/reducer_spec.rb
 - spec/spec_helper.rb
@@ -113,13 +112,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
 summary: Ruby implementation of the UNIX pipe
 test_files:
 - spec/pipe/config_spec.rb
-- spec/pipe/error_spec.rb
 - spec/pipe/iterator_spec.rb
 - spec/pipe/reducer_spec.rb
 - spec/spec_helper.rb

data/lib/pipe/error.rb

@@ -1,38 +0,0 @@
-module Pipe
-  HandlerError = Module.new
-  IterationError = Module.new
-  ReducerError = Module.new
-
-  class Error
-    def self.process(data: {}, error:, namespace:)
-      new(error).rewrite_as(:namespace => namespace, :data => data)
-    end
-
-    def initialize(e)
-      @e = e
-    end
-
-    def rewrite_as(data: {}, namespace:)
-      subclass = find_or_create_subclass(namespace)
-      raise subclass, "#{e} [#{data}, #{e.class}]", e.backtrace
-    end
-
-    private
-
-    attr_reader :e
-
-    def find_or_create_subclass(namespace)
-      part = e.class.name.split("::").last
-      subclass_name = "#{namespace.name}::#{part}"
-
-      begin
-        subclass_name.constantize
-      rescue NameError
-        eval "#{subclass_name} = Class.new(StandardError)"
-      end
-
-      subclass_name.constantize
-    end
-  end
-end
-

data/spec/pipe/error_spec.rb

@@ -1,54 +0,0 @@
-require "spec_helper"
-
-Namespace = Module.new
-
-describe Pipe::Error do
-  describe ".process" do
-    it "re-renders the error under the namespace passed" do
-      begin
-        begin
-          not_a_method(:boom)
-        rescue => e
-          Pipe::Error.process(:error => e, :namespace => Namespace)
-        end
-      rescue => e
-        @err = e
-      end
-
-      expect(@err.class.name).to eq("Namespace::NoMethodError")
-    end
-
-    it "adds the original error class to the message" do
-      begin
-        begin
-          not_a_method(:boom)
-        rescue => e
-          Pipe::Error.process(:error => e, :namespace => Namespace)
-        end
-      rescue => e
-        @err = e
-      end
-
-      expect(@err.message).to match(Regexp.new("NoMethodError"))
-    end
-
-    it "adds the data passed to the message" do
-      data = {:one => 1, :two => 2}
-      begin
-        begin
-          not_a_method(:boom)
-        rescue => e
-          Pipe::Error.process(
-            :data => data,
-            :error => e,
-            :namespace => Namespace
-          )
-        end
-      rescue => e
-        @err = e
-      end
-
-      expect(@err.message).to match(Regexp.new("#{data}"))
-    end
-  end
-end