piece_pipe 0.0.1

data/.gitignore

@@ -0,0 +1,15 @@
+pkg
+*.swp
+*.swo
+*.log
+doc
+coverage
+complexity
+.DS_Store
+.yardoc
+tmp
+tags
+ctags
+.bundle
+*.lock
+vendor

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Atomic Object
+
+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

@@ -0,0 +1,44 @@
+# PiecePipe
+
+PiecePipe is about breaking your problem into its smallest, most interesting pieces, solving those pieces and not spending time on the glue code between them.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'piece_pipe'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install piece_pipe
+
+## Usage
+
+```
+class NuclearPowerPlantHealthSummaryGenerator
+  def generate(region)
+    PiecePipe::Pipeline.new.
+      source([{region: region}]).
+      step(FetchPowerPlantsByRegion).
+      step(FindWorstReactor).
+      step(DetermineStatusClass).
+      step(BuildPlantHealthSummary).
+      step(SortByRadiationLevelsDescending).
+      collect(:plant_health_summary).
+      to_enum
+  end
+end
+```
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+desc "Run all rspecs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+  t.rspec_opts = '-c'
+end
+
+task :default => :spec
+

data/lib/piece_pipe/assembly_station.rb

@@ -0,0 +1,40 @@
+
+module PiecePipe
+  class AssemblyStation < PipelineElement
+    def process(item)
+      ensure_hash_like_object item
+      @assembly = item
+      begin
+        receive(item)
+      ensure
+        @assembly = nil
+      end
+    end
+
+    def receive(assembly)
+      noop
+    end
+
+    def noop
+      install({})
+    end
+
+    def install(value,opts={})
+      output = @assembly.merge(value || {})
+      
+      if opts[:drop]
+        opts[:drop].each do |key|
+          output.delete(key)
+        end
+      end
+      produce output
+    end
+
+    private
+    def ensure_hash_like_object(obj)
+      unless obj.respond_to?(:[]) and obj.respond_to?(:merge) and obj.respond_to?(:dup)
+        raise "AssemblyStation object #{self.class.name} requires its source to produce Hash-like elements; not acceptable: #{obj.inspect}"
+      end
+    end
+  end
+end

data/lib/piece_pipe/collector.rb

@@ -0,0 +1,11 @@
+module PiecePipe
+  class Collector < PipelineElement
+    def initialize(key)
+      @key = key
+    end
+
+    def process(hash)
+      produce hash[@key]
+    end
+  end
+end

data/lib/piece_pipe/debug_step.rb

@@ -0,0 +1,17 @@
+module PiecePipe
+  class DebugStep < PipelineElement
+    def initialize(opts={},&block)
+      @opts = opts
+      @block = block
+    end
+
+    def process(item)
+      title = @opts[:title] || "DEBUG:" 
+      if @opts[:inspect_keys]
+        puts "#{title} #{item.slice(*@opts[:inspect_keys])}"
+      end
+      @block.call if @block
+      produce item
+    end
+  end
+end

data/lib/piece_pipe/hashed_aggregator.rb

@@ -0,0 +1,27 @@
+module PiecePipe
+  class HashedAggregator < PipelineElement
+    def initialize
+      @hash = {}
+    end
+
+    def generate_sequence
+      super
+      @hash.each do |key,values|
+        aggregate key, values
+      end
+    end
+
+    def process(item)
+      raise "HashedAggregator requires inputs to be Hashes with :key and :value" unless item.keys.include?(:key) and item.keys.include?(:value)
+      # TODO : check key/val keys in item
+      #
+      @hash[item[:key]] ||= []
+      @hash[item[:key]] << item[:value]
+    end
+
+    def aggregate(key, values)
+      produce key: key, values: values 
+    end
+  end
+end
+    

data/lib/piece_pipe/map_step.rb

@@ -0,0 +1,15 @@
+module PiecePipe
+  class MapStep < PipelineElement
+    def process(item)
+      map item
+    end
+
+    def map(item)
+      emit item, item
+    end
+
+    def emit(key, value)
+      produce key: key, value: value
+    end
+  end
+end

data/lib/piece_pipe/method_assembly_station.rb

@@ -0,0 +1,12 @@
+module PiecePipe
+  class MethodAssemblyStation < AssemblyStation
+    def initialize(meth)
+      @method = meth
+    end
+
+    def receive(inputs)
+      install(@method.call(inputs))
+    end
+
+  end
+end

data/lib/piece_pipe/method_element.rb

@@ -0,0 +1,27 @@
+module PiecePipe
+  class MethodElement < PipelineElement
+    def initialize(meth)
+      raise "method cannot be nil" if meth.nil?
+      raise "method must accept 1 or 2 arguments; it accepts #{meth.arity}" if meth.arity != 1 and meth.arity != 2
+      @method = meth
+    end
+
+    public :produce # We will provide a ref to self as a producer for use by @method.
+
+    def process(item)
+      case @method.arity
+      when 1
+        # The method takes 1 argument, which we assume to be the input item.
+        # We also assume that the method RETURNS the ONLY item it wishes to produce.
+        # Will always produce exactly 1 output, even if that's just nil.
+        produce @method.call(item)
+      when 2
+        # The method takes 2 arguments.  Assume first is input item, second is "producer",
+        # ie, a means for the method to produce 0, 1 or many outputs at its discretion.
+        # (by calling producer.produce)
+        # Return value of @method.call is NOT considered.
+        @method.call item, self
+      end
+    end
+  end
+end

data/lib/piece_pipe/pipeline.rb

@@ -0,0 +1,75 @@
+module PiecePipe
+  class Pipeline
+    def initialize
+      @latest_source = nil
+    end
+
+    def source(source)
+      raise "Source already set to #{@latest_source.inspect}" unless @latest_source.nil?
+      @latest_source = source
+      self
+    end
+
+    def input(item)
+      source [item]
+      self
+    end
+
+    def step(step)
+      case step
+      when Class
+        step = step.new # If the arg is a Class, instantiate it
+      when Method
+        step = MethodElement.new(step)
+      end
+      add_step step
+    end
+
+    def assembly_step(step)
+      case step
+      when Class
+        step = step.new # If the arg is a Class, instantiate it
+      when Method
+        step = MethodAssemblyStation.new(step)
+      end
+      add_step step
+    end
+
+    def add_step(step)
+      step.source = @latest_source
+      @latest_source = step
+      self
+    end
+    private :add_step
+
+    def tap(&block)
+      step(TapStep.new(&block))
+    end
+
+    def debug(opts)
+      step(DebugStep.new(opts))
+    end
+
+    def collect(key)
+      step(Collector.new(key))
+    end
+
+    def result
+      to_enum.first
+    end
+
+    def to_enum
+      @latest_source.to_enum
+    end
+    alias smoke to_enum
+
+    def to_a
+      to_enum.to_a
+    end
+  end
+
+  def create_pipeline
+    ::Pipeline::Pipeline.new
+  end
+
+end

data/lib/piece_pipe/pipeline_element.rb

@@ -0,0 +1,35 @@
+module PiecePipe
+  class PipelineElement
+    attr_accessor :source
+
+    def to_enum
+      Enumerator.new do |yielder|
+        @yielder = yielder
+        begin
+          generate_sequence
+        ensure
+          @yielder = nil
+        end
+      end
+    end
+
+    protected 
+
+    def generate_sequence
+      if source.nil?
+        raise "The source of PipelineElement #{self.class.name} is nil"
+      end
+      source.to_enum.each do |item|
+        process(item)
+      end
+    end
+
+    def process(item)
+      produce item
+    end
+
+    def produce(something)
+      @yielder << something
+    end
+  end
+end

data/lib/piece_pipe/tap_step.rb

@@ -0,0 +1,12 @@
+module PiecePipe
+  class TapStep < PipelineElement
+    def initialize(&block)
+      @block = block
+    end
+
+    def process(item)
+      @block.call item
+      produce item
+    end
+  end
+end

data/lib/piece_pipe/version.rb

@@ -0,0 +1,3 @@
+module PiecePipe
+  VERSION = "0.0.1"
+end

data/lib/piece_pipe.rb

@@ -0,0 +1,12 @@
+require 'piece_pipe/pipeline'
+require 'piece_pipe/pipeline_element'
+
+require 'piece_pipe/assembly_station'
+require 'piece_pipe/collector'
+require 'piece_pipe/debug_step'
+require 'piece_pipe/hashed_aggregator'
+require 'piece_pipe/map_step'
+require 'piece_pipe/method_assembly_station'
+require 'piece_pipe/method_element'
+require 'piece_pipe/tap_step'
+require 'piece_pipe/version'

data/piece_pipe.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/piece_pipe/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["David Crosby", "Shawn Anderson"]
+  gem.email         = ["crosby@atomicobject.com", "shawn42@gmail.com"]
+  gem.description   = %q{PiecePipe is about breaking your problem into its smallest, most interesting pieces, solving those pieces and not spending time on the glue code between them. }
+  gem.summary       = %q{ PiecePipe helps you break your code into small interesting pieces and provides the glue for pipelining them together to provide elegant, readable code. }
+  gem.homepage      = "http://atomicobject.com"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "piece_pipe"
+  gem.require_paths = ["lib"]
+  gem.version       = PiecePipe::VERSION
+  gem.add_development_dependency "mocha"
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "rake"
+    
+end

data/spec/assembly_station_spec.rb

@@ -0,0 +1,162 @@
+require "spec_helper"
+
+describe PiecePipe::AssemblyStation do
+
+  context "default AssemblyStation" do
+    it "produces unaltered items from its source" do
+      as = PiecePipe::AssemblyStation.new
+      as.source = [
+        {hello: "hippo"},
+        {hello: "lion"}
+      ]
+      as.to_enum.to_a.should == [
+        {hello: "hippo"},
+        {hello: "lion"}
+      ]
+
+    end
+  end
+
+  context "a typical AssemblyStation" do
+    class AnimalPhraser < PiecePipe::AssemblyStation
+      def receive(inputs)
+        install phrase: "There are #{inputs[:count]} #{inputs[:animal]}s"
+      end
+    end
+
+    it "can install new information into the work stream based on inputs" do
+      ap = AnimalPhraser.new
+      ap.source = [
+        { animal: "Hippo", count: 2 },
+        { animal: "Bird", count: 5 },
+      ]
+      ap.to_enum.to_a.should == [
+        { animal: "Hippo", count: 2, phrase: "There are 2 Hippos" },
+        { animal: "Bird", count: 5, phrase: "There are 5 Birds" },
+      ]
+    end
+
+    class Cuber < PiecePipe::AssemblyStation
+      def receive(inputs)
+        num = inputs[:num]
+        install squared: num * num, cubed: num * num * num
+      end
+    end
+
+    it "can install multiple keys per item" do
+      ap = Cuber.new
+      ap.source = [
+        { num: 2 },
+        { num: 5 },
+      ]
+      ap.to_enum.to_a.should == [
+        { num: 2, squared: 4, cubed: 8 },
+        { num: 5, squared: 25, cubed: 125 },
+      ]
+    end
+  end
+
+  context "a filtering AssemblyStation" do
+    class HippoHater < PiecePipe::AssemblyStation
+      def receive(inputs)
+        unless inputs[:animal] == "Hippo"
+          install phrase: "There are #{inputs[:count]} #{inputs[:animal]}s"
+        end
+      end
+    end
+
+    it "can remove elements from the work stream by NOT invoking #install for certain items" do
+      hh = HippoHater.new
+      hh.source = [
+        { animal: "Hippo", count: 2 },
+        { animal: "Bird", count: 5 },
+        { animal: "Hippo", count: 4 },
+        { animal: "Cow", count: 1 },
+      ]
+      hh.to_enum.to_a.should == [
+        { animal: "Bird", count: 5, phrase: "There are 5 Birds" },
+        { animal: "Cow", count: 1, phrase: "There are 1 Cows" },
+      ]
+    end
+  end
+
+  context "an exploding AssemblyStation" do
+    class LionCrusher < PiecePipe::AssemblyStation
+      def receive(inputs)
+        if inputs[:animal] == "Hippo"
+          inputs[:lion_count].times do 
+            install injured_lion: true
+          end
+        end
+      end
+    end
+
+    it "can insert new elements into the work stream by invoking #install more than once for a given input" do
+      lc = LionCrusher.new
+      lc.source = [
+        { animal: "Hippo", lion_count: 3 }
+      ]
+      lc.to_enum.to_a.should == [
+        { injured_lion: true, animal: "Hippo", lion_count: 3 },
+        { injured_lion: true, animal: "Hippo", lion_count: 3 },
+        { injured_lion: true, animal: "Hippo", lion_count: 3 },
+      ]
+    end
+  end
+
+  context "error and oddball cases" do
+    context "source produces non-Hash inputs" do
+      class MyOtherSomething < PiecePipe::AssemblyStation
+      end
+
+      it "raises an error indicating requisite input type" do
+        as = MyOtherSomething.new
+        as.source = [1,2,3]
+        lambda do as.to_enum.to_a end.should raise_error(/AssemblyStation object MyOtherSomething.*Hash-like/)
+      end
+    end
+
+    context "overridden receive() installs nil" do
+      class NilInstaller < PiecePipe::AssemblyStation
+        def receive(inputs)
+          install nil
+        end
+      end
+      it "does a no-op" do
+        as = NilInstaller.new
+        as.source = [
+          {hello: "hippo"},
+          {hello: "lion"}
+        ]
+        as.to_enum.to_a.should == [
+          {hello: "hippo"},
+          {hello: "lion"}
+        ]
+        end
+    end
+
+    context "using noop()" do
+      class UseTheNoOp < PiecePipe::AssemblyStation
+        def receive(inputs)
+          noop
+        end
+      end
+      it "does a no-op" do
+        as = UseTheNoOp.new
+        as.source = [
+          {hello: "hippo"},
+          {hello: "lion"}
+        ]
+        as.to_enum.to_a.should == [
+          {hello: "hippo"},
+          {hello: "lion"}
+        ]
+        end
+    end
+
+    context "overwriting keys that are already present in the inputs" # not sure what that might mean?
+
+    context "accessing keys that are NOT present in the inputs" # BOOM of course.... do something more interesting?
+  end
+end
+

data/spec/collector_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe PiecePipe::Collector do
+  let(:key) { :the_key }
+  subject { described_class.new(key) }
+
+  let(:pipeline) { PiecePipe::Pipeline.new }
+
+  context "processing hashes" do
+    it "produces the single item pulled from incoming Hash as named by the key" do
+      pipeline.
+        source([
+               {one: "1", two: "2", the_key: "big"},
+               {one: "11", two: "22", the_key: "momma"}]).
+               collect(:the_key).to_enum.to_a.should == [ "big", "momma" ]
+    end
+  end
+end

data/spec/hashed_aggregator_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe PiecePipe::HashedAggregator do
+  let(:burps_and_chirps) do
+    [
+      {key: "burp", value: 2 },
+      {key: "chirp", value: 2 },
+      {key: "chirp", value: 3 },
+      {key: "burp", value: 4 },
+    ]
+  end
+
+  context "default impl" do
+    it "produces the accumulated values for each key" do
+
+      results = PiecePipe::Pipeline.new.
+        source(burps_and_chirps).
+        step(subject).
+        to_a
+
+      results[0].should == { key: "burp", values: [2,4] }
+      results[1].should == { key: "chirp", values: [2,3] }
+    end
+
+    it "raises if the input items don't have :key and :value set" do
+      lambda do ezpipe(subject, {}).to_a end.should raise_error(/key.*value/)
+      lambda do ezpipe(subject, key: "ok").to_a end.should raise_error(/key.*value/)
+      lambda do ezpipe(subject, value: "ok").to_a end.should raise_error(/key.*value/)
+    end
+  end
+
+  context "custom #aggregate implementation" do
+    class Countup < PiecePipe::HashedAggregator
+      def aggregate(key,values)
+        sum = values.inject do |a,b| a+b end
+        produce [key, sum]
+      end
+    end
+
+    it "creates output for each key" do
+      results = PiecePipe::Pipeline.new.
+        source(burps_and_chirps).
+        step(Countup).
+        to_a
+      results[0].should == [ "burp", 6 ]
+      results[1].should == [ "chirp", 5 ]
+    end
+  end
+
+end
+

data/spec/map_step_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe PiecePipe::MapStep do
+  context "default impl" do
+    it "maps the input item to itself" do
+      ezpipe(subject, "hello").to_a.first.should == {key: "hello", value: "hello"}
+    end
+  end
+  
+  context "sample subclass of MapStep" do
+    class MyMapping < PiecePipe::MapStep
+      def map(item)
+        emit item[:name], item[:age]
+      end
+    end
+
+    subject do MyMapping.new end
+
+    it "can use #emit to produce Hashes w :key and :value set" do
+      ezpipe(subject, name: "Cosby", age: 65).to_a.first.should == {key:"Cosby", value: 65}
+    end
+  end
+end

data/spec/method_assembly_station_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe PiecePipe::MethodAssemblyStation do
+  let(:pipeline) { PiecePipe::Pipeline.new }
+
+  context "wrapping methods with single arguments" do
+    it "creates a pipeline step that 'installs' the hash returned from the Method" do
+      pipeline.
+        input(a: 1, b: 2).
+        assembly_step( method(:sum_a_b) ).
+        to_enum.to_a.should == [{a: 1, b: 2, sum: 3}]
+    end
+
+    it "produces unchanged if the method returns an empty hash" do
+      pipeline.
+        input(a: 1, b: 2).
+        assembly_step( method(:return_empty_hash) ).
+        to_enum.to_a.should == [{a:1, b:2}]
+    end
+
+    it "produces unchanged if the method returns nothing" do
+      pipeline.
+        input(a: 1, b: 2).
+        assembly_step( method(:return_nothing) ).
+        to_enum.to_a.should == [{a:1, b:2}]
+    end
+
+  end
+
+  #
+  # HELPERS
+  #
+
+  def sum_a_b(inputs)
+    { sum: inputs[:a] + inputs[:b] }
+  end
+
+  def return_empty_hash(inputs)
+    { }
+  end
+
+  def return_nothing(inputs)
+  end
+
+
+end

data/spec/method_element_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe PiecePipe::MethodElement do
+  let(:pipeline) { PiecePipe::Pipeline.new }
+
+  context "wrapping methods with single arguments" do
+    it "creates a pipeline step that produces the return of the Method" do
+      pipeline.
+        input(42).
+        step( method(:stringify_number) ).
+        to_enum.to_a.should == ["!42!"]
+    end
+
+    it "produces nil if the method returns nothing" do
+      pipeline.
+        input(42).
+        step( method(:do_nothing) ).
+        to_enum.to_a.should == [nil]
+    end
+  end
+
+  context "wrapping methods with single arguments" do
+    it "creates a pipeline step wrapped around a Method, providing a 'producer' object as the second argument" do
+      pipeline.
+        input(3).
+        step( method(:spew_strings) ).
+        to_enum.to_a.should == [ ">>3", ">>3", ">>3" ]
+    end
+
+    it "produces NOTHING if the method doesn't invoke producer.produce" do
+      pipeline.
+        input(42).
+        step( method(:do_nothing2) ).
+        to_enum.to_a.should == []
+    end
+  end
+
+  it "raises an error if null is provided" do
+    lambda do pipeline.input(42).step( nil ) end.should raise_error(/nil/)
+  end
+
+  it "raises an error if arity is 0" do
+    lambda do pipeline.input(42).step( method(:no_args) ) end.should raise_error(/arguments/)
+  end
+
+  it "raises an error if arity greater than 2" do
+    lambda do pipeline.input(42).step( method(:three_args) ) end.should raise_error(/arguments.* 3/)
+  end
+
+  it "raises an error if arity is abitrary" do
+    lambda do pipeline.input(42).step( method(:many_args) ) end.should raise_error(/arguments.* -1/)
+  end
+
+  #
+  # HELPERS
+  #
+
+  def stringify_number(num)
+    "!#{num}!"
+  end
+
+  def do_nothing(num)
+  end
+  
+  def spew_strings(num,producer)
+    num.times do 
+      producer.produce ">>#{num}"
+    end
+  end
+
+  def do_nothing2(num,producer)
+  end
+
+  def no_args
+    "should not work"
+  end
+
+  def three_args(a,b,c)
+    "still should not work"
+  end
+
+  def many_args(*a)
+    "still should not work at all"
+  end
+
+end

data/spec/pipeline_element_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe PiecePipe::PipelineElement do
+
+  let (:array_source) { [ "hippo", "distribution", "mechanism" ] }
+
+  context "default PipelineElement" do
+
+    it "provides an enumeration of its source's elements" do
+      e = PiecePipe::PipelineElement.new
+      e.source = array_source
+      
+      en = e.to_enum
+      en.next.should == "hippo"
+      en.next.should == "distribution"
+      en.next.should == "mechanism"
+      lambda do en.next end.should raise_error(StopIteration)
+    end
+  end
+
+  context "overriding #generate_sequence" do 
+    class IntegerGenerator < PiecePipe::PipelineElement
+      def generate_sequence
+        process 1
+        process 2
+        process 3
+      end
+    end
+
+    it "can produce a sequence of items by invoking #process multiple times" do
+      en = IntegerGenerator.new.to_enum
+      en.to_a.should == [1,2,3]
+    end
+
+    class NothingGenerator < PiecePipe::PipelineElement
+      def generate_sequence
+        
+      end
+    end
+
+
+    it "can produce an empty enumerator by never invoking #process" do
+      en = NothingGenerator.new.to_enum
+      en.to_a.should == []
+    end
+
+    context "bypassing the default #process invocation" do
+    class IntegerProducer < PiecePipe::PipelineElement
+      def generate_sequence
+        produce 1
+        produce 2
+        produce 3
+      end
+    end
+
+      it "can produce a sequence of items by invoking #produce multiple times" do
+        en = IntegerProducer.new.to_enum
+        en.to_a.should == [1,2,3]
+      end
+
+    class NothingProducer < PiecePipe::PipelineElement
+      def generate_sequence
+
+      end
+    end
+
+      it "can produce an empty enumerator by never invoking #produce" do
+        en = NothingProducer.new.to_enum
+        en.to_a.should ==[]
+      end
+    end
+  end
+
+  context "overriding #process" do
+    class StringExpander < PiecePipe::PipelineElement
+      def  process(item)
+        produce "x" * item
+      end
+    end
+
+    it "can transform a sequence of items" do
+      se = StringExpander.new
+      se.source = [2,4]
+      se.to_enum.to_a.should == ["xx", "xxxx"]
+    end
+
+    class AllFilter < PiecePipe::PipelineElement
+      def process(item)
+
+      end
+    end
+
+    it "can filter items out of a sequence by neglecting to call #produce" do
+      al = AllFilter.new
+      al.source = [3,6]
+      al.to_enum.to_a.should == []
+    end
+
+    class Exploder < PiecePipe::PipelineElement
+      def process(item)
+        item.times do
+          produce "hi #{item}"
+        end
+      end
+    end
+
+    it "can inflate a sequence by invoking #produce multiple times per item" do
+      ex = Exploder.new
+      ex.source = [2,3]
+      ex.to_enum.to_a.should == ["hi 2", "hi 2", "hi 3", "hi 3", "hi 3"]
+    end
+  end
+
+  context "nill source" do
+    class MySomething < PiecePipe::PipelineElement
+    end
+
+    it "raises an error" do
+      e = MySomething.new
+      e.source = nil
+      lambda do e.to_enum.to_a end.should raise_error(/source.*MySomething.*is nil/)
+    end
+  end
+
+end

data/spec/pipeline_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe PiecePipe::Pipeline do
+  class OneTwoThree < PiecePipe::PipelineElement
+    def generate_sequence
+      produce 1
+      produce 2
+      produce 3
+    end
+  end
+
+  class TheDoubler < PiecePipe::PipelineElement
+    def process(item)
+      produce item * 2
+    end
+  end
+
+  context "super simple" do
+    it "produces the values of its source" do
+      subject.step(OneTwoThree)
+      subject.to_enum.to_a.should == [ 1, 2, 3]
+    end
+  end
+
+  context "two steps" do
+    it "produces transformed values by processing both steps for each item" do
+      subject.
+        step(OneTwoThree).
+        step(TheDoubler)
+
+      subject.to_enum.to_a.should == [ 2, 4, 6]
+    end
+  end
+
+  context "using instantiated PipelineElements as steps" do
+    it "produces transformed values by processing both steps for each item" do
+      subject.
+        step(OneTwoThree.new).
+        step(TheDoubler.new)
+
+      subject.to_enum.to_a.should == [ 2, 4, 6]
+    end
+  end
+
+  context "using an enumerable object as the pipeline source" do
+    it "works with Arrays" do
+      subject.
+        source([10,20,30]).
+        step(TheDoubler)
+      subject.to_enum.to_a.should == [20, 40, 60]
+    end
+
+    it "works with PipelineElements" do
+      subject.
+        source(OneTwoThree.new).
+        step(TheDoubler)
+      subject.to_enum.to_a.should == [2, 4, 6]
+    end
+
+    it "raises if there's already something set as a source" do
+      subject.source([10,20,30])
+      lambda do subject.source([1,2,3]) end.should raise_error(/source already set/i)
+    end
+
+    it "raises if there's already a step" do
+      subject.step(OneTwoThree)
+      lambda do subject.source([1,2,3]) end.should raise_error(/source already set/i)
+    end
+  end
+
+  describe "#collect" do
+    let(:project_info) {
+      [
+        {name: "Project 1", project_health_summary: "Summary 1"},
+        {name: "Project 2", project_health_summary: "Summary 2"},
+      ]
+    }
+
+    it "maps the pipeline items down to the values indicated by the given key" do
+      subject.
+        source(project_info).
+        collect(:project_health_summary)
+      subject.to_enum.to_a.should == [
+        "Summary 1",
+        "Summary 2"
+      ]
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,97 @@
+require 'piece_pipe'
+
+module SpecHelpers
+  def ezpipe(single_step, inputz)
+    PiecePipe::Pipeline.new.
+      input(inputz).
+      step(single_step)
+  end
+end
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+  config.include SpecHelpers
+end
+
+class NilClass
+  def stubs(*args)
+    raise "Tried to stub a method on NilClass with arguments: #{args.inspect}.  Are you using a non-existant mock instance?"
+  end
+
+  def expects(*args)
+    raise "Tried to expect a method on NilClass with arguments: #{args.inspect}.  Are you using a non-existant mock instance?"
+  end
+
+  def to_regexp
+    # match empty string or  
+    /^$| /
+  end
+end
+
+def clever_girl
+  pending <<-EOVR
+                           __      ______
+                         ,^.__.>--"~~'_.--~_)~^.
+                        _L^~   ~    (~ _.-~ \\. |\\
+   CLEVER GIRL....   ,-~    __    __,^"/\\_A_/ /' \\
+                   /    ,-"  "~~" _) \\  ~_,^   /\\
+                  //    /  ,-~\\ x~"  \\._"-~     ~ _Y
+                  Y'   Y. (__.//     /  " , "\\_r ' ]
+                  J-._l_>---r{      ~    \\__/ \\ _/
+                 (_ (   (~  (  ~"---   _.-~ `\\ / \\ !
+                  (_"~--^----^--------"  _.-c Y  /Y'
+                   l~--v---.,____.--"  /  !_/ |
+                    \\.__!.__./~-.      _/  /  \\ !
+                     `x.\\_____\\_,>---"~___Y\\__/Y'
+                         ~     ~(~~()"~___)/ /\\|
+                                (~~   ~~__)  \\_t
+                                (~~   ~~__)\\_/ |
+                                (~~   ~~__)\\_/ |
+                                { ~~   ~~   }/ \\
+  EOVR
+end
+
+def pending_tiger_no_dragon
+pending <<-EOT
+
+                        ,''',
+                      .' ., .',                                  ../'''',
+                     .'. %%, %.',                            .,/' .,%   :
+                    .'.% %%%,`%%%'.    .....,,,,,,.....   .,%%% .,%%'. .'
+                    : %%% %%%%%%',:%%>>%>' .,>>%>>%>%>>%%>,.   `%%%',% :
+                    : %%%%%%%'.,>>>%'   .,%>%>%'.,>%>%' . `%>>>,. `%%%:'
+                    ` %%%%'.,>>%'  .,%>>%>%' .,%>%>%' .>>%,. `%%>>,. `%
+                     `%'.,>>>%'.,%%%%%%%' .,%%>%%>%' >>%%>%>>%.`%% %% `,
+                     ,`%% %%>>>%%%>>%%>%%>>%>>%>%%%  %%>%%>%%>>%>%%%' % %,
+                   ,%>%'.>>%>%'%>>%%>%%%%>%'                 `%>%>>%%.`%>>%.
+                 ,%%>' .>%>%'.%>%>>%%%>>%' ,%%>>%%>%>>%>>%>%%,.`%%%>%%. `%>%.
+                ` ,%' .>%%%'.%>%>>%' .,%%%%%%%%'          `%%%%%%.`%%>%% .%%>
+                .%>% .%%>' :%>>%%'.,%%%%%%%%%'.%%%%%' `%%%%.`%%%%%.%%%%> %%>%.
+               ,%>%' >>%%  >%' `%%%%'     `%%%%%%%'.,>,. `%%%%'     `%%%>>%%>%
+             .%%>%' .%%>'  %>>%, %% oO ~ Oo %%%>>'.>>>>>>. `% oO ~ Oo'.%%%'%>%,
+             %>'%> .%>%>%  %%>%%%'  `OoooO'.%%>>'.>>>%>>%>>.`%`OoooO'.%%>% '%>%
+             %',%' %>%>%'  %>%>%>% .%,>,>,   `>'.>>%>%%>>>%>.`%,>,>' %%%%> .>%>,
+             ` %>% `%>>%%. `%%% %' >%%%%%%>,  ' >>%>>%%%>%>>> >>%%' ,%%>%'.%%>>%.
+              .%%'  %%%%>%.   `>%%. %>%%>>>%.>> >>>%>%%%%>%>>.>>>'.>%>%>' %>>%>%%
+              `.%%  `%>>%%>    %%>%  %>>>%%%>>'.>%>>>>%%%>>%>>.>',%>>%'  ,>%'>% '
+               %>'  %%%%%%'    `%%'  %%%%%> >' >>>>%>>%%>>%>>%> %%>%>' .%>%% .%%
+              %>%>, %>%%>>%%,  %>%>% `%%  %>>  >>>%>>>%%>>>>%>>  %%>>,%>%%'.%>%,
+             %>%>%%, `%>%%>%>%, %>%%> ,%>%>>>.>>`.,.  `"   ..'>.%. % %>%>%'.%>%%;
+             %'`%%>%  %%>%%  %>% %'.>%>>%>%%>>%::.  `,   /' ,%>>>%>. >%>%'.%>%'%'
+             ` .%>%'  >%%% %>%%'.>%>%;''.,>>%%>%%::.  ..'.,%>>%>%>,`%  %'.>%%' '
+               %>%>%% `%>  >%%'.%%>%>>%>%>%>>>%>%>>%,,::,%>>%%>%>>%>%% `>>%>'
+               %'`%%>%>>%  %>'.%>>%>%>>;'' ..,,%>%>%%/::%>%%>>%%,,.``% .%>%%
+               `    `%>%>>%%' %>%%>>%>>%>%>%>%%>%/'       `%>%%>%>>%%% ' .%'
+                     %'  `%>% `%>%%;'' .,>>%>%/',;;;;;,;;;;,`%>%>%,`%'   '
+                     `    `  ` `%>%%%>%%>%%;/ @a;;;;;;;;;;;a@  >%>%%'
+                                `/////////';, `@a@@a@@a@@aa@',;`//'
+                                   `//////.;;,,............,,;;//'
+                                       `////;;;;;;;;;;;;;;;;;/'
+                                          `/////////////////'
+                                   /
+                                  /
+                                 /
+                       HAS TO COME CORRECT!!!!!
+EOT
+end
+

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: piece_pipe
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- David Crosby
+- Shawn Anderson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! 'PiecePipe is about breaking your problem into its smallest, most interesting
+  pieces, solving those pieces and not spending time on the glue code between them. '
+email:
+- crosby@atomicobject.com
+- shawn42@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/piece_pipe.rb
+- lib/piece_pipe/assembly_station.rb
+- lib/piece_pipe/collector.rb
+- lib/piece_pipe/debug_step.rb
+- lib/piece_pipe/hashed_aggregator.rb
+- lib/piece_pipe/map_step.rb
+- lib/piece_pipe/method_assembly_station.rb
+- lib/piece_pipe/method_element.rb
+- lib/piece_pipe/pipeline.rb
+- lib/piece_pipe/pipeline_element.rb
+- lib/piece_pipe/tap_step.rb
+- lib/piece_pipe/version.rb
+- piece_pipe.gemspec
+- spec/assembly_station_spec.rb
+- spec/collector_spec.rb
+- spec/hashed_aggregator_spec.rb
+- spec/map_step_spec.rb
+- spec/method_assembly_station_spec.rb
+- spec/method_element_spec.rb
+- spec/pipeline_element_spec.rb
+- spec/pipeline_spec.rb
+- spec/spec_helper.rb
+homepage: http://atomicobject.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: PiecePipe helps you break your code into small interesting pieces and provides
+  the glue for pipelining them together to provide elegant, readable code.
+test_files:
+- spec/assembly_station_spec.rb
+- spec/collector_spec.rb
+- spec/hashed_aggregator_spec.rb
+- spec/map_step_spec.rb
+- spec/method_assembly_station_spec.rb
+- spec/method_element_spec.rb
+- spec/pipeline_element_spec.rb
+- spec/pipeline_spec.rb
+- spec/spec_helper.rb
+has_rdoc: