aqueductron 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 58506c06a6a555805358ad1545cf71769fc2f3cb
+  data.tar.gz: 0c7d1b25af500789ebb0f91c95bd407349f30eac
+SHA512:
+  metadata.gz: f8da3f12f7657164c0099b5eab8f731086b220b76a2d0b87b9abde68aa1e01a0ff965f7049ff0ae128632160f299e8447a016591f49b047ba426081a41c06883
+  data.tar.gz: 71486cc4c617bfc55ebc6c7f3622abee44ed380a381696007ba3f1143e410ed97519bf78016f5d1793d329c61dd4b66258f1134a748535cd77ffdda1d085c9c5

data/lib/aqueductron.rb

@@ -0,0 +1,3 @@
+require_relative 'aqueductron/duct'
+require_relative 'aqueductron/monoid'
+require_relative 'improved_hash'

data/lib/aqueductron/buildering.rb

@@ -0,0 +1,86 @@
+require_relative 'counting_end_piece'
+require_relative 'last_end_piece'
+require_relative 'end_piece'
+require_relative 'inlet'
+require_relative 'joint_piece'
+require_relative 'piece'
+require_relative 'partition'
+
+module Aqueductron
+  module Buildering
+    def answer(monoid)
+      answer_int(EndPiece.new(monoid))
+    end
+
+    def count
+      answer_int(CountingEndPiece.new)
+    end
+
+    def take(how_many)
+      attach(take_function(how_many))
+    end
+
+    def keeping(predicate)
+      attach(filter_function(predicate))
+    end
+
+    def through(transform)
+      attach(map_function(transform))
+    end
+
+    def custom(piece)
+       attach(piece)
+    end
+
+    def expand(transform)
+      attach(expand_function(transform))
+    end
+
+    def split(paths)
+      answer_int(JointPiece.new(paths))
+    end
+
+    def partition(categorize, make_new_path)
+      answer_int(SpontaneousJointPiece.new({}, categorize, make_new_path))
+    end
+
+    def last
+      answer_int(LastEndPiece.new)
+    end
+
+    module_function
+    def take_function(how_many) # this will either return a Result or a Piece
+      what_to_do = ->(piece, msg) do
+        if (how_many == 0) then # this is a little inefficient. One extra piece of info will be read
+          piece.send_eof
+        else
+          piece.pass_on(msg, take_function(how_many -1))
+        end
+      end
+    end
+
+    def expand_function(expansion)
+      ->(piece, msg) do
+        next_piece = Inlet.new(piece.destination, :not_done).flow(expansion.call(msg))
+        Piece.new(next_piece, expand_function(expansion))
+      end
+    end
+
+    def map_function(transform)
+      ->(piece, msg) do
+        piece.pass_on(transform.call(msg), map_function(transform))
+      end
+    end
+
+    def filter_function(predicate)
+      ->(piece, msg) do
+        if(predicate.call(msg)) then
+          piece.pass_on(msg, filter_function(predicate))
+        else
+          piece #don't change
+        end
+      end
+    end
+
+  end
+end

data/lib/aqueductron/compound_result.rb

@@ -0,0 +1,19 @@
+module Aqueductron
+  class CompoundResult
+    include Result
+    def initialize(paths)
+      @contents = paths
+    end
+
+    def keys
+      @contents.keys
+    end
+
+    def value(*path)
+      return self if path.empty?
+      (head, *tail) = path
+      puts "Nothing found at #{head}" unless @contents[head]
+      @contents[head].value(*tail)
+    end
+  end
+end

data/lib/aqueductron/counting_end_piece.rb

@@ -0,0 +1,16 @@
+require_relative 'piece_common'
+
+module Aqueductron
+  class CountingEndPiece
+    include PieceCommon
+    def initialize(so_far = 0)
+      @so_far = so_far
+    end
+    def eof
+      SimpleResult.new(@so_far)
+    end
+    def receive msg
+      CountingEndPiece.new(@so_far + 1)
+    end
+  end
+end

data/lib/aqueductron/duct.rb

@@ -0,0 +1,22 @@
+require_relative 'buildering'
+
+module Aqueductron
+  class Duct
+    include Buildering
+    def initialize(things_so_far = [])
+      @do_these_things = things_so_far
+    end
+
+    def attach(piece)
+      Duct.new(@do_these_things + [piece])
+    end
+
+    def answer_int(piece)
+      if (@do_these_things.empty?)
+        piece
+      else
+        answer_int(Piece.new(piece, @do_these_things.pop))
+      end
+    end
+  end
+end

data/lib/aqueductron/end_piece.rb

@@ -0,0 +1,20 @@
+require_relative 'piece_common'
+require_relative 'simple_result'
+
+module Aqueductron
+  class EndPiece
+    include PieceCommon
+    def initialize(monoid, so_far = :no_value)
+      @monoid = monoid
+      @so_far = (so_far == :no_value) ? monoid.zero : so_far
+    end
+
+    def eof
+      SimpleResult.new(@so_far)
+    end
+
+    def receive msg
+      EndPiece.new(@monoid, @monoid.append(@so_far, msg))
+    end
+  end
+end

data/lib/aqueductron/inlet.rb

@@ -0,0 +1,30 @@
+module Aqueductron
+  class Inlet
+    def initialize(next_piece, done_or_not = :done)
+      @next_piece = next_piece
+      @done_or_not = done_or_not
+    end
+
+    def flow(source)
+      flow_internal(source.each)
+    end
+
+    def flow_internal(source)
+      result = begin
+                 response = @next_piece.receive(source.next)
+                 if (response.result?) then
+                   response
+                 else #it's another piece
+                   Inlet.new(response, @done_or_not).flow_internal(source)
+                 end
+               rescue StopIteration
+                 if (@done_or_not == :done) then
+                   @next_piece.eof
+                 else
+                   @next_piece
+                 end
+               end
+    end
+  end
+end
+

data/lib/aqueductron/joint_piece.rb

@@ -0,0 +1,32 @@
+require_relative 'compound_result'
+require_relative 'piece_common'
+
+module Aqueductron
+  class JointPiece
+    def initialize(paths)
+      @paths = paths
+    end
+    include PieceCommon
+
+    def receive(msg)
+      go = ->(v) { v.result? ? v : v.receive(msg) }
+      new_map = @paths.map_values(&go)
+      if (new_map.values.all? &:result? )
+        construct_compound_result(new_map)
+      else
+        JointPiece.new(new_map)
+      end
+    end
+
+    def eof
+      go = ->(v) { v.result? ? v : v.eof }
+      new_map = @paths.map_values(&go)
+      construct_compound_result(new_map)
+    end
+
+    private
+    def construct_compound_result(paths)
+      CompoundResult.new(paths)
+    end
+  end
+end

data/lib/aqueductron/last_end_piece.rb

@@ -0,0 +1,16 @@
+require_relative 'piece_common'
+
+module Aqueductron
+  class LastEndPiece
+    include PieceCommon
+    def initialize(most_recent = :no_data)
+      @most_recent = most_recent
+    end
+    def eof
+      SimpleResult.new(@most_recent)
+    end
+    def receive msg
+      LastEndPiece.new(msg)
+    end
+  end
+end

data/lib/aqueductron/monoid.rb

@@ -0,0 +1,20 @@
+module Aqueductron
+  class Monoid
+    attr_reader :zero
+    def initialize(zero, add_lambda)
+      @zero = zero
+      @append = add_lambda
+    end
+    def append(a,b)
+      @append.call(a,b)
+    end
+
+    # instances
+    def self.concat
+      Monoid.new("", ->(a,b) {a + b})
+    end
+    def self.plus
+      Monoid.new(0,  ->(a,b) {a + b})
+    end
+  end
+end

data/lib/aqueductron/partition.rb

@@ -0,0 +1,43 @@
+
+require_relative 'compound_result'
+require_relative 'piece_common'
+
+module Aqueductron
+  class SpontaneousJointPiece
+    attr_reader(:paths, :categorize, :make_new_path) # TODO: make private
+    def initialize(paths, categorize, make_new_path)
+      @categorize = categorize
+      @make_new_path = make_new_path
+      @paths = paths
+    end
+    include PieceCommon
+
+    def receive(msg)
+      category = categorize.call(msg)
+      new_map = if (paths.key? category)
+        paths
+      else
+        paths[category] = make_new_path.call(category) # todo: don't update
+        paths
+      end
+      go = ->(v) { v.result? ? v : v.receive(msg) }
+      new_map[category] = go.call(new_map[category]) #todo: don't mutate
+      if (new_map.values.all? &:result? )
+        construct_compound_result(new_map)
+      else
+        SpontaneousJointPiece.new(new_map, categorize, make_new_path)
+      end
+    end
+
+    def eof
+      go = ->(v) { v.result? ? v : v.eof }
+      new_map = paths.map_values(&go)
+      construct_compound_result(new_map)
+    end
+
+    private
+    def construct_compound_result(paths)
+      CompoundResult.new(paths)
+    end
+  end
+end

data/lib/aqueductron/piece.rb

@@ -0,0 +1,33 @@
+require_relative 'piece_common'
+
+module Aqueductron
+  class Piece
+    attr_reader :destination
+    include PieceCommon
+
+    def initialize(destination, what_to_do)
+      @destination = destination
+      @what_to_do = what_to_do
+    end
+
+    def receive(msg)
+      @what_to_do.call(self, msg)
+    end
+
+    def eof
+      send_eof
+    end
+
+    def pass_on(msg, what_to_do_next)
+      next_destination = @destination.receive(msg)
+      if (next_destination.result?) then
+        next_destination
+      else
+        Piece.new(next_destination, what_to_do_next)
+      end
+    end
+    def send_eof
+      @destination.eof
+    end
+  end
+end

data/lib/aqueductron/piece_common.rb

@@ -0,0 +1,10 @@
+module Aqueductron
+  module PieceCommon
+    def flow(source)
+      Inlet.new(self).flow_internal(source.each)
+    end
+    def result?
+      false
+    end
+  end
+end

data/lib/aqueductron/result.rb

@@ -0,0 +1,7 @@
+module Aqueductron
+  module Result
+    def result?
+      true
+    end
+  end
+end

data/lib/aqueductron/simple_result.rb

@@ -0,0 +1,18 @@
+require_relative 'result'
+
+module Aqueductron
+  class SimpleResult
+    include Result
+    def initialize(value)
+      @value = value
+    end
+
+    def keys
+      []
+    end
+
+    def value
+      @value
+    end
+  end
+end

data/lib/improved_hash.rb

@@ -0,0 +1,6 @@
+
+class Hash
+  def map_values &block
+    self.each_with_object({}) {|(k,v), h| h[k] = block.call(v) }
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: aqueductron
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jessica Kerr
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-04 00:00:00.000000000 Z
+dependencies: []
+description: Aqueductron lets you create a path for data, then flow data through it,
+  then find the results at the end. It encourages a functional style, avoiding mutable
+  values. It uses iteratees to let the path change itself as the data passes.
+email: jessitron@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/aqueductron/buildering.rb
+- lib/aqueductron/compound_result.rb
+- lib/aqueductron/counting_end_piece.rb
+- lib/aqueductron/duct.rb
+- lib/aqueductron/end_piece.rb
+- lib/aqueductron/inlet.rb
+- lib/aqueductron/joint_piece.rb
+- lib/aqueductron/last_end_piece.rb
+- lib/aqueductron/monoid.rb
+- lib/aqueductron/partition.rb
+- lib/aqueductron/piece.rb
+- lib/aqueductron/piece_common.rb
+- lib/aqueductron/result.rb
+- lib/aqueductron/simple_result.rb
+- lib/aqueductron.rb
+- lib/improved_hash.rb
+homepage: http://github.com/jessitron/aqueductron
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Dataflow in a functional, self-modifying pipeline style
+test_files: []