shifty 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 46d6ec38da041475fa499d8d79042e685d9eb3c4ab1dbce24ab70579b466acc2
+  data.tar.gz: b8cc19ee79ad7321e113f8ec7311f52020566506ff8a7e84dc36c6eb840e57dd
+SHA512:
+  metadata.gz: c11b09e67ff91d611ddedff9404d81b043f9211e0a96a452ff6d9fde0480955e65050b00fb6a71cabc867e35ef3ae28815943d371b56c1a3a1a425a80e5847f0
+  data.tar.gz: 46d0ef549da9cdfc57043b2563d1a4549abb44abffbe424228b18d97758e871e1ad279c9e5d8824d584a1ab66e43100a514c5ccb82fcce161280318d06762a53

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,17 @@
+env:
+  global:
+    - CC_TEST_REPORTER_ID=de10d77685b449162f3f3d568e1ab75d94c0f281afceee218502cf0995e49aa6
+sudo: false
+language: ruby
+rvm:
+  - 2.5.0
+  - jruby-19mode
+before_install: gem install bundler -v 1.16.1
+before_script:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - ./cc-test-reporter before-build
+script:
+  - bundle exec rspec
+after_script:
+  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+git_source(:github) {|repo_name| 'https://github.com/#{repo_name}' }
+
+# Specify your gem's dependencies in shifty.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Joel Helbling
+
+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,459 @@
+[![Gem Version](https://badge.fury.io/rb/shifty.svg)](https://badge.fury.io/rb/shifty)
+[![Build Status](https://travis-ci.org/joelhelbling/shifty.png)](https://travis-ci.org/joelhelbling/shifty)
+[![Maintainability](https://api.codeclimate.com/v1/badges/950ded888350c1124348/maintainability)](https://codeclimate.com/github/joelhelbling/shifty/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/950ded888350c1124348/test_coverage)](https://codeclimate.com/github/joelhelbling/shifty/test_coverage)
+
+# The Shifty Framework
+
+_"How many Ruby fibers does it take to screw in a lightbulb?"_
+
+## Quick Start
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'shifty'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself:
+
+    $ gem install steplader
+
+And then use it:
+
+```ruby
+require 'shifty'
+```
+
+## Shifty DSL
+
+The DSL provides convenient shorthand for several common types of
+workers.  Let's look at them.
+
+But first, be sure to include the DSL mixin:
+
+```ruby
+include Shifty::DSL
+```
+
+### Source Worker
+
+At the headwater of every Shifty pipeline, there is a source worker
+which is able to generate its own work items.
+
+Here is possibly the simplest of source workers, which provides the same
+string each time it is invoked:
+
+```ruby
+worker = source_worker { "Number 9" }
+
+worker.shift #=> "Number 9"
+worker.shift #=> "Number 9"
+worker.shift #=> "Number 9"
+# ...ad nauseum...
+```
+
+Sometimes you want a worker which generates until it doesn't:
+
+```ruby
+counter = 0
+worker = source_worker do
+  if counter < 3
+    counter += 1
+    counter + 1000
+  end
+end
+
+worker.shift #=> 1001
+worker.shift #=> 1002
+worker.shift #=> 1003
+worker.shift #=> nil
+worker.shift #=> nil (and will be nil henceforth)
+```
+
+If all you want is a source worker which generates a series of numbers
+the DSL provides an easier way to do it:
+
+```ruby
+w1 = source_worker [0,1,2]
+w2 = source_worker (0..2)
+
+w1.shift == w2.shift #=> 0
+w1.shift == w2.shift #=> 1
+w1.shift == w2.shift #=> 2
+w1.shift == w2.shift #=> nil (and henceforth, etc.)
+```
+
+### Relay Worker
+
+This is perhaps the most "normal" kind of worker in Shifty.  It
+accepts a value and returns some transformation of that value:
+
+```ruby
+squarer = relay_worker do |number|
+  number ** 2
+end
+```
+
+Of course a relay worker needs a source from which to get values upon
+which to operate:
+
+```ruby
+source = source_worker (0..3)
+
+squarer.supply = source
+```
+
+Or, if you prefer, the DSL provides a vertical pipe for linking the
+workers together into a pipeline:
+
+```ruby
+pipeline = source | squarer
+
+pipeline.shift #=> 0
+pipeline.shift #=> 1
+pipeline.shift #=> 4
+pipeline.shift #=> 9
+pipeline.shift #=> nil
+```
+
+### Side Worker
+
+As we travel down the pipeline, from time to time, we will want to
+stop and smell the roses, or write to a log file, or drop a beat, or
+create some other kind of side-effect.  That's the purpose of the
+`side_worker`.  A side worker will pass through the same value that
+it received, but as it does so, it can perform some kind side-effect
+work.
+
+```
+source = source_worker (0..3)
+
+evens = []
+even_stasher = side_effect do |value|
+  if value % 2 == 0
+    evens << value
+  end
+end
+
+# re-using "squarer" from above example...
+pipeline = source | even_stasher | squarer
+
+pipeline.shift #=> 0
+pipeline.shift #=> 1
+pipeline.shift #=> 4
+pipeline.shift #=> 9
+pipeline.shift #=> nil
+
+evens #=> [0, 2]
+```
+
+Notice that the output is the same as the previous example, even though
+we put this `even_stasher` `side_worker` in the middle of the pipeline.
+
+However, we can also see that the `evens` array now contains the even numbers from `source` (the side effect).
+
+_But wait,_ you want to say, _can't we still create side effects with
+regular ole relay workers?_  Why, yes.  Yes you can.  Ruby being what
+it is, there really isn't a way to prevent the implementation of any
+worker from creating side effects.
+
+_And still wait,_ you'll also be wanting to say, _isn't it possible
+that a side worker could mutate the value as it's passed through?_  And
+again, yes.  It would be very difficult\* in the Ruby language (where
+so many things are passed by reference) to perfectly prevent a side
+worker from mutating the value.  But please don't.
+
+The side effect worker's purpose is to provide _intentionality_ and
+clarity.  When you're creating a side effect, let it be very clear.
+And don't do regular, pure functional style work in the same worker.
+
+This will make side effects easier to troubleshoot; if you pull them
+out of the pipeline, the pipeline's output shouldn't change.  By the
+same token, if there is a problem with a side effect, troubleshooting
+it will be much simpler if the side effects are already isolated and
+named.
+
+Another measure for preventing side workers from creating unwanted
+side-effects is to use `:hardened` mode.  That's right, `side_worker`
+has a mode (which defaults to `:normal`).  When set to `:hardened`,
+each value is `Marshal.dump`ed and `Marshal.load`ed before being
+passed to the side worker's callable.  This helps to ensure that
+the original value will be passed through to the next worker in the
+queue in a pristine state (unmodified), and that no future or
+subsequent modification can take place.
+
+Given a source...
+
+```ruby
+source = source_worker [[:foo], [:bar]]
+```
+
+Consider this unsafe, unhardened side worker:
+
+```ruby
+unsafe = side_worker { |v| v << :boo }
+```
+
+This produces unwanted mutations, because of the `<<`.
+
+```ruby
+pipeline = source | unsafe
+
+pipeline.shift #=> [:foo, :boo] <-- Oh noes!
+pipeline.shift #=> [:bar, :boo] <-- Disaster!
+pipeline.shift #=> nil
+```
+
+Let's harden it:
+
+```ruby
+unsafe = side_worker(:hardened) { |v| v << :boo }
+```
+
+The `:hardened` side worker doesn't have access to the original
+value, and therefore its shenanigans are moot with respect to
+the main workflow:
+
+```ruby
+pipeline = source | unsafe
+
+pipeline.shift #=> [:foo] <-- No changes
+pipeline.shift #=> [:bar] <-- Much better
+pipeline.shift #=> nil
+```
+
+### Filter Worker
+
+The filter worker simply passes through the values which are given
+to it, but _only_ those values which result in truthiness when your
+provided callable is run against it.  Values which result in
+falsiness are simply discarded.
+
+```ruby
+source = source_worker (0..5)
+
+filter = filter_worker do |value|
+  value % 2 == 0
+end
+
+pipeline = source | filter
+
+pipeline.shift #=> 0
+pipeline.shift #=> 2
+pipeline.shift #=> 4
+pipeline.shift #=> nil
+```
+
+### Batch Worker
+
+The batch worker gathers outputs into batches and the returns each
+batch as its output.
+
+```ruby
+source = source_worker (0..7)
+
+batch = batch_worker gathering: 3
+
+pipeline = source | batch
+
+pipeline.shift #=> [0, 1, 2]
+pipeline.shift #=> [3, 4, 5]
+pipeline.shift #=> [6, 7]
+pipeline.shift #=> nil
+```
+
+Notice how the final batch doesn't have full compliment of three.
+
+Fixed-numbered batch workers are useful for things like pagination,
+perhaps, but sometimes we don't want a batch to include a specific
+number of items, but to batch together all items until a certain
+condition is met.  So batch worker can also accept a callable:
+
+```ruby
+source = source_worker [
+  "some", "rain", "must\n", "fall", "but", "ok" ]
+
+line_reader = batch_worker do |value|
+  value.end_with? "\n"
+end
+
+pipeline = source | line_reader
+
+pipeline.shift #=> ["some", "rain", "must\n"]
+pipeline.shift #=> ["fall", "but", "ok"]
+pipeline.shift #=> nil
+```
+
+### Splitter Worker
+
+The splitter worker accepts a value from its supply, and generates an array
+and then successively returns each element of the array.  Once the array
+has been expended, the splitter worker appeals to its supplier for another
+value and the process repeats.
+
+```ruby
+source = source_worker [
+  'A bold', 'move westward' ]
+
+splitter = splitter_worker do |value|
+  value.split(' ')
+end
+
+pipeline = source | splitter
+
+pipeline.shift #=> 'A'
+pipeline.shift #=> 'bold'
+pipeline.shift #=> 'move'
+pipeline.shift #=> 'westward'
+pipeline.shift #=> nil
+```
+
+### Trailing Worker
+
+
+The trailing worker accepts a value, and returns an array containing the
+last _n_ values.  This worker could be useful for things like rolling averages.
+
+No values are returned until n values had been accumulated. New values are
+_unshifted_ into the zero-th position in the array of trailing values, so
+that a given value will graduate through the array until it reaches the last
+position and then subsequently removed.
+
+Maybe it's easiest to just give an example:
+
+```ruby
+source = source_worker (0..5)
+trailer = trailing_worker 4
+
+pipeline = source | trailer
+
+pipeline.shift #=> [3,2,1,0]
+pipeline.shift #=> [4,3,2,1]
+pipeline.shift #=> [5,4,3,2]
+pipeline.shift #=> nil
+```
+
+Note that as soon as a nil is received from the supplying queue, the trailing
+worker simply provides a nil.
+
+
+## Origins of Shifty
+
+Shifty was Shifty, which grew out of experimentation with Ruby fibers, after reading
+[Dave Thomas' demo of Ruby fibers](http://pragdave.me/blog/2007/12/30/pipelines-using-fibers-in-ruby-19/),
+wherein he created a pipeline of fiber processes, emulating the style and syntax of the
+\*nix command line.  I noticed that, courtesy of fibers' extremely low surface area,
+fiber-to-fiber collaborators could operate with extremely low coupling.  That was the
+original motivation for creating the framework.
+
+After playing around with the new framework a bit, I began to notice
+other interesting characteristics of this paradigm.
+
+### Escalator vs Elevator
+
+Suppose we are performing several operations on the members of a largish
+collection. If we daisy-chain enumerable operators together (which is so
+easy and fun with Ruby) we will notice that if something goes awry with
+item number two during operation number seven, we nonetheless had to wait
+through a complete run of all items through operations 1 - 6 before we
+receive the bad news early in operation seven.  Imagine if the first six
+operations take a long time to each complete?  Furthermore, what if the
+operations on all incomplete items must be reversed in some way (e.g.
+cleaned up or rolled back)?  It would be far less messy and far more
+expedient if each item could be processed though all operations before
+the next one is begun.
+
+This is the design paradigm which shifty makes easy.  Although all
+the workers in your assembly line can be coded in the same context (which
+is one of the big selling points of the daisy-chaining of enumerable
+methods,incidentally), you also get the advantage of passing each item
+though the entire op-chain before starting the next.
+
+### Think Locally, Act Globally
+
+Because shifty workers use fibers as their basic API, the are almost
+unaware of the outside world.  And they can pretty much be written as such.
+At the heart of each Shifty worker is a task which you provide, which
+is a callable ruby object (such as a Proc or a lambda).
+
+The scope of the work is whatever scope existed in the task when you
+initially created the worker.  And if you want a worker to maintain its
+own internal state, you can simply include a loop within the worker's
+task, and use the `#handoff` method to pass along the worker's product at
+the appropriate point in the loop.
+
+For example:
+
+```ruby
+realestate_maker = Shifty::Worker.new do
+  oceans = %w[Atlantic Pacific Indiana Arctic]
+  previous_ocean = "Atlantic"
+  while current_ocean = oceans.sample
+    drain current_ocean  #=> let's posit that this is a long-running async process!
+    handoff previous_ocean
+    previous_ocean = current_ocean
+  end
+```
+
+Anything scoped to the outside of that loop but inside the worker's task
+will essentially become that worker's initial state.  This means we often
+don't need to bother with instance variables, accessors, and other
+features of classes which deal with maintaining instances' state.
+
+### The Wormhole Effect
+
+Despite the fact that the work is done in separate threads, the _scope_
+of the work is the scope of the coordinating body of code.  This means
+that even the remaining coupling in such systems --which is primarily
+just _common objects_ coupling-- this little remaining coupling is
+mitigated by the possibility of having coupled code _live together_.
+I call this feature the _folded collaborators_ effect.
+
+Consider the following ~~code~~ vaporware:
+
+```ruby
+SUBJECT = 'kitteh'
+
+include Shifty::DSL
+
+tweet_getter = source_worker do
+  twitter_api.fetch_my_tweets
+end
+
+about_me = filter_worker do |tweet|
+  tweet.referenced.include? SUBJECT
+end
+
+tweet_formatter = relay_worker do |tweet|
+  apply_format_to tweet
+end
+
+kitteh_tweets = tweet_getter | about_me | tweet_formatter
+
+while tweet = kitteh_tweets.shift
+  display(tweet)
+end
+```
+
+None of these tasks have hard coupling with each other.  If we were to
+insert another worker between the filter and the formatter, neither of
+those workers would need changes in their code, assuming the inserted
+worker plays nicely with the objects they're all passing along.
+
+Which brings me to the point: these workers to have a dependency upon the
+objects they're handing off and receiving.  But we have the capability to
+coordinate those workers in a centralized location (such as in this code
+example).
+
+## Shifty::Worker
+
+The Shifty::Worker documentation (which was the old README) is now
+[here](docs/shifty/worker.md).
+
+## Roadmap
+

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "shifty"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/docs/shifty/worker.md

@@ -0,0 +1,80 @@
+# Shifty::Worker
+
+_The workhorse of the Shifty framework._
+
+## Workers have tasks...
+
+Initialize with a block of code:
+
+```ruby
+source_worker = Shifty::Worker.new { "hulk" }
+
+source_worker.shift #=> "hulk"
+```
+If you supply a worker with another worker as its supply, then you
+can give it a task which accepts a value:
+
+```ruby
+relay_worker = Shifty::Worker.new { |name| name.upcase }
+relay_worker.supply = source_worker
+
+relay_worker.shift #=> "HULK"
+```
+
+You can also initialize a worker by passing in a callable object
+as its task:
+
+```ruby
+capitalizer = Proc.new { |name| name.capitalize }
+relay_worker = Shifty::Worker.new(task: capitalizer, supply: source_worker)
+
+relay_worker.shift #=> 'Hulk'
+```
+
+A worker also has an accessor for its @task:
+
+```ruby
+doofusizer = Proc.new { |name| name.gsub(/u/, 'oo') }
+relay_worker.task = doofusizer
+
+relay_worker.shift #=> 'hoolk'
+```
+
+And finally, you can provide a task by directly overriding the
+worker's #task instance method:
+
+```ruby
+def relay_worker.task(name)
+  name.to_sym
+end
+
+relay_worker.shift #=> :hulk
+```
+
+Even workers without a task have a task; all workers actually come
+with a default task which simply passes on the received value unchanged:
+
+```ruby
+useless_worker = Shifty::Worker.new(supply: source_worker)
+
+useless_worker.shift #=> 'hulk'
+```
+
+## The pipeline DSL
+
+You can stitch your workers together using the vertical pipe ("|") like so:
+
+```ruby
+pipeline = source_worker | relay_worker | another worker
+```
+
+...and then just call on that pipeline (it's actually the last worker in the
+chain):
+
+```ruby
+while next_value = pipeline.shift do
+  do_something_with next_value
+  # etc.
+end
+```
+

data/lib/shifty.rb

@@ -0,0 +1,5 @@
+require_relative 'shifty/version'
+require_relative 'shifty/worker'
+require_relative 'shifty/gang'
+require_relative 'shifty/roster'
+require_relative 'shifty/dsl'

data/lib/shifty/dsl.rb

@@ -0,0 +1,180 @@
+module Shifty
+  class WorkerInitializationError < StandardError; end
+
+  module DSL
+    def source_worker(argument=nil, &block)
+      ensure_correct_arity_for!(argument, block)
+
+      series = series_from(argument)
+      callable = setup_callable_for(block, series)
+
+      return Worker.new(&callable) if series.nil?
+
+      Worker.new do
+        series.each(&callable)
+
+        while true do
+          handoff nil
+        end
+      end
+
+    end
+
+    def relay_worker(&block)
+      ensure_regular_arity(block)
+
+      Worker.new do |value|
+        value && block.call(value)
+      end
+    end
+
+    def side_worker(mode=:normal, &block)
+      ensure_regular_arity(block)
+
+      Worker.new do |value|
+        value.tap do |v|
+          used_value = mode == :hardened ?
+            Marshal.load(Marshal.dump(v)) : v
+
+          v && block.call(used_value)
+        end
+      end
+    end
+
+    def filter_worker(argument=nil, &block)
+      if (block && argument.respond_to?(:call))
+        throw_with 'You cannot supply two callables'
+      end
+      callable = argument.respond_to?(:call) ? argument : block
+      ensure_callable(callable)
+
+      Worker.new do |value, supply|
+        while value && !callable.call(value) do
+          value = supply.shift
+        end
+        value
+      end
+    end
+
+    class BatchContext < OpenStruct
+      def batch_complete?(value, collection)
+        value.nil? ||
+          !! batch_full.call(value, collection)
+      end
+    end
+
+    def batch_worker(options = {gathering: 1}, &block)
+      ensure_regular_arity(block) if block
+      batch_full = block ||
+        Proc.new { |_, batch| batch.size >= options[:gathering] }
+
+      batch_context = BatchContext.new({ batch_full: batch_full })
+
+      Worker.new(context: batch_context) do |value, supply, context|
+        if value
+          context.collection = [value]
+          until context.batch_complete?(
+              context.collection.last,
+              context.collection
+          )
+            context.collection << supply.shift
+          end
+          context.collection.compact
+        end
+      end
+    end
+
+    def splitter_worker(&block)
+      ensure_regular_arity(block)
+
+      Worker.new do |value|
+        if value.nil?
+          value
+        else
+          parts = [block.call(value)].flatten
+          while parts.size > 1 do
+            handoff parts.shift
+          end
+          parts.shift
+        end
+      end
+    end
+
+    def trailing_worker(trail_length=2)
+      trail = []
+      Worker.new do |value, supply|
+        if value
+          trail.unshift value
+          if trail.size >= trail_length
+            trail.pop
+          end
+          while trail.size < trail_length
+            trail.unshift supply.shift
+          end
+
+          trail
+        else
+          value
+        end
+      end
+    end
+
+    def handoff(something)
+      Fiber.yield something
+    end
+
+    private
+
+    def throw_with(*msg)
+      raise WorkerInitializationError.new([msg].flatten.join(' '))
+    end
+
+    def ensure_callable(callable)
+      unless callable && callable.respond_to?(:call)
+        throw_with 'You must supply a callable'
+      end
+    end
+
+    def ensure_regular_arity(block)
+      if block.arity != 1
+        throw_with \
+          "Worker must accept exactly one argument (arity == 1)"
+      end
+    end
+
+    # only valid for #source_worker
+    def ensure_correct_arity_for!(argument, block)
+      return unless block
+      if argument
+        ensure_regular_arity(block)
+      else
+        if block.arity > 0
+          throw_with \
+            'Source worker cannot accept any arguments (arity == 0)'
+        end
+      end
+    end
+
+    def series_from(series)
+      return if series.nil?
+      case
+      when series.respond_to?(:to_a)
+        series.to_a
+      when series.respond_to?(:scan)
+        series.scan(/./)
+      else
+        [series]
+      end
+    end
+
+    def setup_callable_for(block, series)
+      return block unless series
+      if block
+        return Proc.new { |value| handoff block.call(value) }
+      else
+        return Proc.new { |value| handoff value }
+      end
+    end
+
+  end
+end

data/lib/shifty/gang.rb

@@ -0,0 +1,46 @@
+require 'shifty/roster'
+
+module Shifty
+  class Gang
+    attr_accessor :workers
+
+    def initialize(workers=[])
+      link(workers + [])
+    end
+
+    def roster
+      workers
+    end
+
+    def shift
+      workers.last.shift
+    end
+
+    def ready_to_work?
+      workers.first.ready_to_work?
+    end
+
+    def supply
+      workers.first.supply
+    end
+
+    def supply=(source_queue)
+      workers.first.supply = source_queue
+    end
+
+    def supplies(subscribing_party)
+      subscribing_party.supply = self
+    end
+    alias_method :"|", :supplies
+
+    private
+
+    def link(workers)
+      @workers = [workers.shift]
+      while worker = workers.shift do
+        Roster[self] << worker
+      end
+    end
+
+  end
+end

data/lib/shifty/roster.rb

@@ -0,0 +1,46 @@
+module Shifty
+  module Roster
+    class << self
+      def [](gang)
+        RosterizedGang.new(gang)
+      end
+    end
+  end
+
+  class RosterizedGang
+    attr_reader :gang
+
+    def initialize(gang)
+      @gang = gang
+    end
+
+    def workers
+      gang.workers
+    end
+
+    def push(worker)
+      if worker
+        worker.supply = workers.last
+        workers << worker
+      end
+    end
+    alias_method :"<<", :push
+
+    def pop
+      gang.workers.pop.tap do |popped|
+        popped.supply = nil
+      end
+    end
+
+    def shift
+      workers.shift.tap do
+        workers.first.supply = nil
+      end
+    end
+
+    def unshift(worker)
+      workers.first.supply = worker
+      workers.unshift worker
+    end
+  end
+end

data/lib/shifty/version.rb

@@ -0,0 +1,3 @@
+module Shifty
+  VERSION = "0.3.0"
+end

data/lib/shifty/worker.rb

@@ -0,0 +1,80 @@
+require 'ostruct'
+
+module Shifty
+  class Worker
+    attr_reader :supply
+
+    def initialize(p={}, &block)
+      @supply   = p[:supply]
+      @task     = block || p[:task]
+      @context  = p[:context] || OpenStruct.new
+      # don't define default task here
+      # because we want to allow for
+      # an initialized worker to have
+      # a task injected, including
+      # method-based tasks.
+    end
+
+    def shift
+      ensure_ready_to_work!
+      workflow.resume
+    end
+
+    def ready_to_work?
+      @task && (supply || !task_accepts_a_value?)
+    end
+
+    def supplies(subscribing_party)
+      subscribing_party.supply = self
+      subscribing_party
+    end
+    alias_method :"|", :supplies
+
+    def supply=(supplier)
+      raise WorkerError.new("Worker is a source, and cannot accept a supply") unless suppliable?
+      @supply = supplier
+    end
+
+    def suppliable?
+      @task && @task.arity > 0
+    end
+
+    private
+
+    def ensure_ready_to_work!
+      @task ||= default_task
+
+      unless ready_to_work?
+        raise "This worker's task expects to receive a value from a supplier, but has no supply."
+      end
+    end
+
+    def workflow
+      @my_little_machine ||= Fiber.new do
+        loop do
+          value = supply && supply.shift
+          Fiber.yield @task.call(value, supply, @context)
+        end
+      end
+    end
+
+    def default_task
+      Proc.new { |value| value }
+    end
+
+    def task_accepts_a_value?
+      @task.arity > 0
+    end
+
+    def task_method_exists?
+      self.methods.include? :task
+    end
+
+    def task_method_accepts_a_value?
+      self.method(:task).arity > 0
+    end
+
+  end
+
+  class WorkerError < StandardError; end
+end

data/shifty.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'shifty/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'shifty'
+  spec.version       = Shifty::VERSION
+  spec.authors       = ['Joel Helbling']
+  spec.email         = ['joel@joelhelbling.com']
+
+  spec.summary       = %q{A functional framework aimed at extremely low coupling}
+  spec.description   = %q{Shifty provides tools for coordinating simple workers which consume a supplying queue and emit corresponding work products, valuing pure functions, carefully isolated side effects, and extremely low coupling.}
+  spec.homepage      = 'https://github.com/joelhelbling/shifty'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.1'
+  spec.add_development_dependency 'rspec-given', '~> 3.8'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'simplecov'
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: shifty
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Joel Helbling
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-04-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rspec-given
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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'
+- !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: Shifty provides tools for coordinating simple workers which consume a
+  supplying queue and emit corresponding work products, valuing pure functions, carefully
+  isolated side effects, and extremely low coupling.
+email:
+- joel@joelhelbling.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- docs/shifty/worker.md
+- lib/shifty.rb
+- lib/shifty/dsl.rb
+- lib/shifty/gang.rb
+- lib/shifty/roster.rb
+- lib/shifty/version.rb
+- lib/shifty/worker.rb
+- pkg/.gitkeep
+- shifty.gemspec
+homepage: https://github.com/joelhelbling/shifty
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: A functional framework aimed at extremely low coupling
+test_files: []