pipe-ruby 0.3.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d0eca86ffad3466f3843db7cb3013985bfc1c3bf
-  data.tar.gz: df2cd7013334b5abce3608c1c85bcd4ca261201a
+SHA256:
+  metadata.gz: fbadf311c963de6b2d2b3afb84a0f2b77289a87a8845113bf50f151ed75f5f2e
+  data.tar.gz: 4ce615623a052ebfbdb74e09ada70331e51d2030af9e0103ea32f01f1545b6d9
 SHA512:
-  metadata.gz: 918395735261b1110693cfa0c08d933e5c7c8ea5e0a73597a3d067a5fc3b29044f36a47b608dfb5a0c911f9df1f3711ff50fbf765bb6a960b91bff22670a30f8
-  data.tar.gz: 9338db4f769305be5ad63474cca4e4e2ef2fcfebee1f8eb0ade7a2231f992beebfe6e92d842e31be5e823c1d208ba109c911cd72c63f944048214b785d342bf8
+  metadata.gz: 01ee3e1028218949442ac2ee4367e20664fa338f286214963a61ecfa957339530f029d67fba56f319358c6b31fecc13d2047884f7a7409425ded43871286d904
+  data.tar.gz: 1f5ff71f0f374c2366f97c5acdb8265afb5652fd9819e3d407d7e49a03c0d1f4551fe91d2bc307e2d5ce7a72c9aa573ff1a9b92d5dd77fa8b17599d426e0c90c

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.2"
 end

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/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

data/spec/spec_helper.rb

@@ -1,5 +1,8 @@
 require "pry"
 require "pipe"
+require "simplecov"
+
+SimpleCov.start
 
 module VerifyAndResetHelpers
   def verify(object)

metadata

@@ -1,57 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: pipe-ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 1.0.2
 platform: ruby
 authors:
-- Dan Matthews
+- Dan Matthews, Paul Hanyzewski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-12 00:00:00.000000000 Z
+date: 2023-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.9'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -66,34 +66,39 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: ''
 email:
-- oss@teamsnap.com
+- devs@teamsnap.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- 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
 - lib/pipe/reducer.rb
 - 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
-homepage: ''
+homepage: https://github.com/teamsnap/pipe-ruby
 licenses:
 - MIT
 metadata: {}
@@ -103,23 +108,21 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '2.1'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.2.22
 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/.gitignore

@@ -1,14 +0,0 @@
-/.bundle/
-/.yardoc
-/Gemfile.lock
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-*.bundle
-*.so
-*.o
-*.a
-mkmf.log

data/.rspec

@@ -1 +0,0 @@
---color

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in pipe-ruby.gemspec
-gemspec

data/LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright (c) 2015 TeamSnap
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,190 +0,0 @@
-# Pipe
-
-`pipe-ruby` is an implementation of the UNIX pipe command. It exposes two
-instance methods, `pipe` and `pipe_each`.
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem "pipe-ruby", :require => "pipe"
-```
-
-After bundling, include the `Pipe` module in your class(es)
-
-```ruby
-class MyClass
-  include Pipe
-
-  # ...
-end
-```
-
-## Default Usage
-
-### #pipe
-
-```ruby
-pipe(subject, :through => [
-  :method1, :method2#, ...
-])
-```
-
-Just as with the UNIX pipe, `subject` will be passed as the first argument to
-`method1`. The results of `method1` will be passed to `method2` and on and
-on. The result of the last method called will be returned from the pipe.
-
-### #pipe_each
-
-```ruby
-pipe_each([subj1, subj2], :through => [
-  :method1, :method2#, ...
-])
-```
-
-`pipe_each` calls `pipe`, passing each individual subject. It will return a
-mapped array of the responses.
-
-## Configurable Options
-
-After implementing the `pipe` method in a few different places, we found that a
-slightly different version was needed for each use case. `Pipe::Config` allows
-for this customization per call or per class implementation. There are four
-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
-)
-```
-
-A `Pipe::Config` object can be passed to the pipe method one of three ways.
-
-NOTE: The options below are in priority order, meaning an override of the
-`pipe_config` method will take precedence over an override of the `@pipe_config`
-instance variable.
-
-You can pass it to pipe when called:
-
-```ruby
-class MyClass
-  include Pipe
-
-  def my_method
-    config = Pipe::Config.new(:raise_on_error => false)
-    subject = Object.new
-
-    pipe(subject, :config => config, :through => [
-      # ...
-    ])
-  end
-
-  # ...
-end
-```
-
-Or override the `pipe_config` method:
-
-```ruby
-class MyClass
-  include Pipe
-
-  def pipe_config
-    Pipe::Config.new(:raise_on_error => false)
-  end
-
-  # ...
-end
-```
-
-Or you can assign it to the `@pipe_config` instance variable:
-
-```ruby
-class MyClass
-  include Pipe
-
-  def initialize
-    @pipe_config = Pipe::Config.new(:raise_on_error => 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
-returns truthy, execution will be stopped and the current value of subject will
-be returned. A falsey response will allow the execution to move forward.
-
-If not stopped, `Pipe::Config#skip_on` will be called. Truthy responses will
-cause the current value of subject to be passed to the next iteration without
-calling the method specified in the current iteration. Falsey responses will
-allow the specified method to be called.
-
-Both skip_on and stop_on will receive three arguments when they're called, the
-current value of subject, the method to be called on this iteration and the
-value of `#through`.
-
-## Contributing
-
-First: please check out our [style guides](https://github.com/teamsnap/guides/tree/master/ruby)...
-we will hold you to them :)
-
-1. Fork it ( https://github.com/[my-github-username]/pipe-ruby/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Make sure you're green (`bundle exec rspec`)
-4. Commit your changes (`git commit -am 'Add some feature'`)
-5. Push to the branch (`git push origin my-new-feature`)
-6. Create a new Pull Request
-
-## Testing
-
-`bundle exec rspec`
-
-We like to have good coverage of each major feature. Before contributing with a
-PR, please make sure you've added tests and are fully green.
-

data/Rakefile

@@ -1,2 +0,0 @@
-require "bundler/gem_tasks"
-

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/pipe-ruby.gemspec

@@ -1,26 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-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.summary       = %q{Ruby implementation of the UNIX pipe}
-  spec.description   = %q{}
-  spec.homepage      = ""
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
-  spec.required_ruby_version = "~> 2.1"
-
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.1"
-  spec.add_development_dependency "pry"
-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