pipetree 0.0.5 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fa9de99071c198cb1ac6254f7c5fc9eddbc3eaa1
-  data.tar.gz: ceb3b6450907aeccd607e8704fc78a24fbcd2b87
+  metadata.gz: 9d2f95504872630ac29dd00818a64ab869910211
+  data.tar.gz: 1df1dc4a468ad5e4ab2970f70e6bcae19c0e3a22
 SHA512:
-  metadata.gz: d57ed120a07f1ab17b84c96539eefad984a702156f72dfd4d3e86aa03e6185df9b1786ffe7af666d75a4dfd1168ffd4b090ffd89b98a8d1f757dbc2fc1c1012a
-  data.tar.gz: 75183aa0a9538807dbd9e3d7fc832d7645618d6275be743ff9234aa4fbd4512d937917e24a73ea6351734572758adf3a71668a43af0a2186460e0b20afa9e067
+  metadata.gz: b0f00369c97fbe68c5b96910166d34cf06b172d23f2ce30a97a19962faa2c5f5dbec91fd07750e9840451d5bc24c18ecff6ed48ac41f4bf7195e0ad079dc2c88
+  data.tar.gz: 43e323582b82f168b93835d0fe4ae4c9b1b5d1989db3e70ee2d4a0f2d0d72f8b2580c74778dd6cb72ba9f6d69b0b121b27168aa385bbba4778c8d3ab148eb130

data/CHANGES.md

@@ -1,3 +1,13 @@
+# 0.1.0
+
+* Rename `Flow` to `Railway`.
+* All "operators" like `Flow#&` are now optional in `Operator` and considered experimental. Single entry point to adding steps is `Flow#add`.
+* Remove `Flow#>>`.
+* Add `Flow#add` which allows a low-level *tie*, a step that sits directly on the track with incoming interface `(last, input, options)` and outgoing `[new_track, input]`.
+* Make `Flow#_insert` private, as we now have `add`.
+* `And`'s direction can now be configured via `:on_true` and `:on_false`, allowing to deviate to any kind of track.
+* Remove the `Pipetree` array implementation and save it for future versions.
+
 # 0.0.5
 
 * `Flow` doesn't inherit from `Array` anymore. Temporarily use `Uber::Delegates` to achieve the same interface. This will change in 0.1.x when `Insert` works against an array. This makes `Flow.new` the new canonical constructor which allows us to initialize `step@proc` properly.

data/README.md

@@ -16,6 +16,12 @@ Instead of implementing the perfect API where users can override methods, call `
 
 This is way less tedious than climbing through `super` calls and callstacks.
 
+##
+
+[ tie, tie, tie ]
+  On.new(track, strut)
+    Right.new( step )
+
 ## Installation
 
 In your `Gemfile`.

data/lib/pipetree/insert.rb

@@ -1,13 +1,14 @@
 module Pipetree::Function
   class Insert
-    def call(arr, func, options)
+    Operations = [:delete, :replace, :before, :after, :append, :prepend]
+
+    # DISCUSS: all methods write to original array.
+    def call(arr, operation, *args)
       # arr = arr.dup
-      operations = [:delete, :replace, :before, :after, :append, :prepend]
+      raise "[Pipetree] Unknown Insert operation #{args.inspect}" unless Operations.include?(operation)
 
-      # replace!(arr, options[:replace], func)
-      options.keys.reverse.each { |k| operations.include?(k) and return send("#{k}!", arr, options[k], func) }
+      send("#{operation}!", arr, *args) # replace!(arr, Old, New)
 
-      raise "[Pipetree] Unknown command #{options.inspect}" # TODO: test.
       # arr
     end
 
@@ -25,17 +26,10 @@ module Pipetree::Function
       arr
     end
 
-    def delete!(arr, _, removed_func)
-      index = arr.index(removed_func)
+    def delete!(arr, old_func, *)
+      index = arr.index(old_func)
       arr.delete_at(index)
 
-      # TODO: make nice.
-      # arr.each_with_index { |func, index|
-      #   if func.is_a?(Collect)
-      #     arr[index] = Collect[*Pipeline::Insert.(func, removed_func, delete: true)]
-      #   end
-      # }
-
       arr
     end
 
@@ -57,15 +51,7 @@ module Pipetree::Function
     def prepend!(arr, old_func, new_func)
       arr.unshift(new_func)
     end
-
-    module Macros
-      def insert!(new_function, options)
-        Pipetree::Insert.(self, new_function, options)
-      end
-    end
   end
 end
 
 Pipetree::Insert = Pipetree::Function::Insert.new
-
-#FIXME: all methods write to original array.

data/lib/pipetree/inspect.rb

@@ -10,18 +10,8 @@ module Pipetree::Inspect
     inspect_rows(names)
   end
 
-  # open source file to retrieve the constant name.
   def inspect_func(func)
-    return inspect_object(func) unless func.is_a?(Proc)
-    inspect_proc(func)
-  end
-
-  def inspect_object(obj)
-    obj.inspect.sub(/0x\w+/, "")
-  end
-
-  def inspect_proc(proc)
-    File.readlines(proc.source_location[0])[proc.source_location[1]-1].match(/^\s+([\w\:]+)/)[1]
+    func
   end
 
   def inspect_line(names)

data/lib/pipetree/{flow → railway}/inspect.rb

@@ -1,26 +1,22 @@
 require "pipetree/inspect"
 
-module Pipetree::Flow::Inspect
+module Pipetree::Railway::Inspect
   include ::Pipetree::Inspect
 
-  Proc = Struct.new(:name, :proc, :operator)
-
   def inspect_func(step)
-    cfg = @step2proc[step]
-    [cfg.name || super(cfg.proc), cfg.operator]
+    @inspect[step]
   end
 
+  Operator = { Pipetree::Railway::Left => "<", Pipetree::Railway::Right => ">", }
+
   def inspect_line(names)
-    string = names.collect { |i, name| "#{name.last}#{name.first}" }.join(",")
+    string = names.collect { |i, (track, name)| "#{Operator[track]}#{name}" }.join(",")
     "[#{string}]"
   end
 
-  def inspect_row(index, name)
-    "#{index} #{name.last}#{name.first}"
-  end
-
   def inspect_rows(names)
-    string = names.collect do |i, (name, operator)|
+    string = names.collect do |i, (track, name)|
+      operator = Operator[track]
 
       op = "#{operator}#{name}"
       padding = 38

data/lib/pipetree/railway/operator.rb

@@ -0,0 +1,29 @@
+# Optimize the most common steps with Stay/And objects that are faster than procs.
+# This is experimental API and might be removed/changed without prior warning.
+class Pipetree::Railway
+  module Operator
+    def <(proc, options={})
+      _insert(Pipetree::Railway.<(proc), options, Left, proc)
+    end
+
+    def &(proc, options={})
+      _insert(Pipetree::Railway.&(proc), options, Right, proc)
+    end
+
+    def >(proc, options={})
+      _insert(Pipetree::Railway.>(proc), options, Right, proc)
+    end
+  end
+
+  def self.<(proc)
+    On.new(Left, Stay.new(proc))
+  end
+
+  def self.&(proc)
+    On.new(Right, And.new(proc))
+  end
+
+  def self.>(proc)
+    On.new(Right, Stay.new(proc))
+  end
+end

data/lib/pipetree/railway.rb

@@ -0,0 +1,103 @@
+class Pipetree
+  class Railway
+    require "pipetree/insert"
+    require "pipetree/railway/operator"
+
+    def initialize(*args)
+      @steps   = Array.new(*args)
+      @index   = Hash.new
+      @inspect = Hash.new
+    end
+
+    # Actual implementation of Pipetree:Railway. Yes, it's that simple!
+    def call(input, options)
+      input = [Right, input]
+
+      @steps.inject(input) do |(last, memo), step|
+        step.call(last, memo, options)
+      end
+    end
+
+    # Naming:
+    # * Track
+    # * Tie: the callable that's usually an On instance and is sitting directly in the pipe, on a Track.
+    # * Strut: the callable that's wrapped by the Tie and implements the decider logic (e.g. And).
+    # * Step: the user callable with interface `Step.(input, options)`.
+    module Add
+      def add(track, strut, options={})
+        _insert On.new(track, strut), options, track, strut
+      end
+
+      require "uber/delegates"
+      extend Uber::Delegates
+      # TODO: make Insert properly decoupled! it still relies on Array interface on pipe`.
+      delegates :@steps, :<<, :each_with_index, :[]=, :delete_at, :insert, :unshift, :index
+
+    private
+      def _insert(tie, options, track, strut)
+        insert_operation = (options.keys & ::Pipetree::Function::Insert::Operations).last || :append
+
+        old_tie = @index[ options[insert_operation] ] # name --> tie
+
+        # todo: step, old_tie (e.g. for #delete!).
+        Insert.(self, insert_operation, old_tie, tie)
+
+        @index[options[:name]] = tie
+        @inspect[tie]          = [ track, options[:name] ]
+
+        self
+      end
+    end
+    include Add
+
+    # Tracks emitted by steps.
+    Track = Class.new
+    Left  = Class.new(Track)
+    Right = Class.new(Track)
+
+    # Incoming direction must be Left/Right.
+    # Tie
+    class On
+      def initialize(track, proc)
+        @track, @proc = track, proc
+      end
+
+      def call(last, input, options)
+        return [last, input] unless last == @track # return unless incoming track is Right (or Left).
+        @proc.(last, input, options)
+      end
+    end
+
+    class Strut
+      def initialize(proc, config={})
+        @proc    = proc
+        @config  = config
+      end
+
+      def call(last, input, options)
+        result = @proc.(input, options) # call the actual step.
+
+        [self.class::Decider.(result, @config, last, input, options), input] # decide about the track and return Flow-compliant response.
+      end
+    end
+
+    # Call step proc and return (Right || Left).
+    class And < Strut
+      # Deciders return the new track.
+      Decider = ->(result, config, *) do
+        result ?
+          config[:on_true]  || Right :
+          config[:on_false] || Left
+      end
+    end
+
+    # Call step proc and return incoming last step.
+    class Stay < Strut
+      # simply pass through the current direction: e.g. Left or Right.
+      Decider = ->(result, cfg, last, *) { last }
+    end
+
+    require "pipetree/railway/inspect"
+    include Inspect
+  end
+end

data/lib/pipetree/version.rb

@@ -1,3 +1,3 @@
 class Pipetree < Array
-  VERSION = "0.0.5"
+  VERSION = "0.1.0"
 end

data/lib/pipetree.rb

@@ -1,55 +1,2 @@
-class Pipetree < Array
-  # Allows to implement a pipeline of filters where a value gets passed in and the result gets
-  # passed to the next callable object.
-  Stop = Class.new
-
-  # options is mutuable.
-  # we have a fixed set of arguments here, since array splat significantly slows this down, as in
-  # call(input, *options)
-  def call(input, options)
-    inject(input) do |memo, step|
-      res = evaluate(step, memo, options)
-      return(Stop) if Stop == res
-      res
-    end
-  end
-
-private
-  def evaluate(step, input, options)
-    step.call(input, options)
-  end
-
-  require "pipetree/inspect"
-  include Inspect
-
-  module Macros
-    def insert!(new_function, options)
-      Pipetree::Insert.(self, new_function, options)
-    end
-  end
-  require "pipetree/insert"
-  include Macros
-
-  # Collect applies a pipeline to each element of input.
-  class Collect < self
-    # when stop, the element is skipped. (should that be Skip then?)
-    def call(input, options)
-      arr = []
-      input.each_with_index do |item_fragment, i|
-        result = super(item_fragment, options.merge(index: i)) # DISCUSS: NO :fragment set.
-        Stop == result ? next : arr << result
-      end
-      arr
-    end
-
-    # DISCUSS: will this make it into the final version?
-    class Hash < self
-      def call(input, options)
-        {}.tap do |hsh|
-          input.each { |key, item_fragment|
-            hsh[key] = super(item_fragment, options) }# DISCUSS: NO :fragment set.
-        end
-      end
-    end
-  end
+class Pipetree
 end

data/test/altering_test.rb

@@ -1,48 +1,21 @@
 require "test_helper"
 
-class AlteringTest < Minitest::Spec
-  A = ->(*) { "bla ruby 1.9 needs that" }
-  B = ->(*) { }
-  C = ->(*) { "otherwise it'll confuse empty procs" }
-
-  # constructor.
-  it do
-    pipe = ::Pipetree[A, B]
-    pipe.inspect.must_equal %{[A|>B]}
-  end
-
-  it { Pipetree[].insert(0, B).inspect.must_equal %{[B]} }
-  it { Pipetree[].unshift(B).inspect.must_equal %{[B]} }
-  it { Pipetree[].unshift(B, A).inspect.must_equal %{[B|>A]} }
-
-  it { Pipetree[A,B].insert!(C, before: A).inspect.must_equal %{[C|>A|>B]} }
-  it { Pipetree[A,B].insert!(C, before: B).inspect.must_equal %{[A|>C|>B]} }
-
-  it { Pipetree[A,B].insert!(C, after: A).inspect.must_equal %{[A|>C|>B]} }
-  it { Pipetree[A,B].insert!(C, after: B).inspect.must_equal %{[A|>B|>C]} }
-
-  it { Pipetree[A,B].insert!(C, append: true).inspect.must_equal %{[A|>B|>C]} }
-  it { Pipetree[].insert!(C, append: true).inspect.must_equal %{[C]} }
-
-  it { Pipetree[A,B].insert!(C, prepend: true).inspect.must_equal %{[C|>A|>B]} }
-  it { Pipetree[].insert!(C, prepend: true).inspect.must_equal %{[C]} }
-
-  # last option wins
-  it { Pipetree[A,B].insert!(C, after: B, prepend: true).inspect.must_equal %{[C|>A|>B]} }
-end
-
-require "pipetree/flow"
-class FlowInsertTest < Minitest::Spec
+require "pipetree/railway"
+class RailwayInsertTest < Minitest::Spec
   A = ->{ }
   B = ->{ }
   C = ->{ }
 
-  it { pipe = Pipetree::Flow.new.>(A).>(B).inspect.must_equal %{[>A,>B]} }
-  it { pipe = Pipetree::Flow.new.>(A).>(B, before: A).inspect.must_equal %{[>B,>A]} }
-  it { pipe = Pipetree::Flow.new.>(A).>(B).>(C, after: A).inspect.must_equal %{[>A,>C,>B]} }
-  it { pipe = Pipetree::Flow.new.>(A).>(C, append: true).inspect.must_equal %{[>A,>C]} }
-  it { pipe = Pipetree::Flow.new.>(A).>(C, prepend: true).inspect.must_equal %{[>C,>A]} }
-  it { pipe = Pipetree::Flow.new.>(A).>(C, replace: A).inspect.must_equal %{[>C]} }
-  it { pipe = Pipetree::Flow.new.>(A)._insert(A, {delete: true}, nil, nil).inspect.must_equal %{[]} }
-  # FIXME: add :delete and :replace.
+  let (:pipe) { Pipetree::Railway.new.extend(Pipetree::Railway::Operator) }
+
+  it { pipe.>(A, name: :A).>(B, name: :B).inspect.must_equal %{[>A,>B]} }
+  it { pipe.>(A, name: :A).>(B, before: :A, name: :B).inspect.must_equal %{[>B,>A]} }
+  it { pipe.>(A, name: :A).>(B, name: :B).>(C, after: :A, name: :C).inspect.must_equal %{[>A,>C,>B]} }
+  it { pipe.>(A, name: "A").>(C, append: true, name: :C).inspect.must_equal %{[>A,>C]} }
+  it { pipe.>(A, name: :A).>(C, prepend: true, name:  "C").inspect.must_equal %{[>C,>A]} }
+  it { pipe.>(A, name: :A).>(C, replace: :A, name: :C).inspect.must_equal %{[>C]} }
+  it { pipe.>(A, name: :A).add(nil, :A, delete: :A).inspect.must_equal %{[]} }
+  # last insert operation wins.
+  it { pipe.>(A, name: :A).>(B, name: :B).>(C, name: :C, after: :A, before: :A).inspect.must_equal %{[>C,>A,>B]} }
+  it { pipe.>(A, name: :A).>(B, name: :B).>(C, name: :C, before: :A, after: :A).inspect.must_equal %{[>A,>C,>B]} }
 end

data/test/inspect_test.rb

@@ -1,35 +1,35 @@
-require "test_helper"
+# require "test_helper"
 
-class InspectTest < Minitest::Spec
-  module M
-  end
+# class InspectTest < Minitest::Spec
+#   module M
+#   end
 
-  M::AlphaConstant = ->(*) { }
-  M::Beta          = ->(*) { }
-  Callable         = Object.new
+#   M::AlphaConstant = ->(*) { }
+#   M::Beta          = ->(*) { }
+#   Callable         = Object.new
 
-  let (:pipe) { ::Pipetree[M::Beta, M::AlphaConstant, M::Beta, M::AlphaConstant, M::Beta, M::AlphaConstant, M::Beta, M::AlphaConstant, M::Beta, M::AlphaConstant, M::Beta, Callable] }
+#   let (:pipe) { ::Pipetree[M::Beta, M::AlphaConstant, M::Beta, M::AlphaConstant, M::Beta, M::AlphaConstant, M::Beta, M::AlphaConstant, M::Beta, M::AlphaConstant, M::Beta, Callable] }
 
-  it do
-    puts pipe.inspect
-    puts pipe.inspect(style: :rows)
+#   it do
+#     puts pipe.inspect
+#     puts pipe.inspect(style: :rows)
 
 
-    pipe.inspect(style: :rows).must_equal %{
- 0|>M::Beta
- 1|>M::AlphaConstant
- 2|>M::Beta
- 3|>M::AlphaConstant
- 4|>M::Beta
- 5|>M::AlphaConstant
- 6|>M::Beta
- 7|>M::AlphaConstant
- 8|>M::Beta
- 9|>M::AlphaConstant
-10|>M::Beta
-11|>#<Object:>}
-  end
+#     pipe.inspect(style: :rows).must_equal %{
+#  0|>M::Beta
+#  1|>M::AlphaConstant
+#  2|>M::Beta
+#  3|>M::AlphaConstant
+#  4|>M::Beta
+#  5|>M::AlphaConstant
+#  6|>M::Beta
+#  7|>M::AlphaConstant
+#  8|>M::Beta
+#  9|>M::AlphaConstant
+# 10|>M::Beta
+# 11|>#<Object:>}
+#   end
 
-  # different separator
-  it { ::Pipetree[M::AlphaConstant,M::Beta,Callable].inspect.must_equal %{[M::AlphaConstant|>M::Beta|>#<Object:>]} }
-end
+#   # different separator
+#   it { ::Pipetree[M::AlphaConstant,M::Beta,Callable].inspect.must_equal %{[M::AlphaConstant|>M::Beta|>#<Object:>]} }
+# end

data/test/railway_test.rb

@@ -0,0 +1,183 @@
+require "test_helper"
+require "pipetree/railway"
+require "json"
+
+class RailwayTest < Minitest::Spec
+  F = Pipetree::Railway
+
+  describe "#add" do
+    let (:pipe) do
+      pipe = F.new
+
+      #       add: (track, proc)
+      # macro returns [signal, input]: (can be added to pipe via #add)
+      step_1 = F::And.new(->(input, options) { options["x"] = true })
+      step_2 = F::And.new(->(input, options) { input })
+      step_3 = F::And.new(->(input, options) { options["step_3"] = true })
+
+      fail_1 = F::Stay.new(->(input, options) { options["fail_1"] = true })
+      fail_2 = F::And.new(->(input, options) { options["fail_2"] = true }, on_true: left_1, on_false: F::Left)
+      fail_3 = F::Stay.new(->(input, options) { options["fail_3"] = true })
+
+
+      pipe.add(F::Right, step_1)
+      pipe.add(F::Right, step_2)
+      pipe.add(F::Left, fail_1)
+      pipe.add(F::Left, fail_2)
+      pipe.add(F::Left, fail_3)
+      pipe.add(F::Right, step_3)
+    end
+
+    let (:left_1) { Class.new(F::Left) }
+
+    # only right
+    it { [pipe.(true, options={}), options].must_equal [[F::Right, true], {"x"=>true, "step_3"=>true}] }
+    # jumps to left at step_2
+    it { [pipe.(false, options={}), options].must_equal [[left_1, false], {"x"=>true, "fail_1"=>true, "fail_2"=>true}] }
+
+    # options for #add
+    # chainability of #add.
+    it do
+      F.new
+        .add(F::Right, Object, name: "operation.new")
+        .add(F::Right, Module, name: "nested.create", before: "operation.new")
+        .inspect.must_equal %{[>nested.create,>operation.new]}
+    end
+  end
+
+  Aaa = ->(*) { "yo" }
+  B   = ->(*) {  }
+
+  let (:pipe) { pipe = Pipetree::Railway.new.extend(Pipetree::Railway::Operator)
+    pipe.& ->(value, options) { value && options["deserializer.result"] = JSON.parse(value) }
+    pipe.& ->(value, options) { options["deserializer.result"]["key"] == 1 ? true : (options["contract.errors"]=false) }
+    pipe.& ->(value, options) { options["deserializer.result"]["key2"] == 2 ? true : (options["contract.errors.2"]="screwd";false) }
+    pipe.< ->(value, options) { options["after_deserialize.fail"]=true }
+    pipe.> ->(value, options) { options["meantime"] = true }
+    pipe.< ->(value, options) { options["after_meantime.left?"]=true; false } # false is ignored.
+
+  }
+
+  # success?
+  it do
+    options = {}
+    pipe.(%{{"key": 1,"key2":2}}, options)#.must_equal ""
+
+    options.must_equal({"deserializer.result"=>{"key"=>1, "key2"=>2}, "meantime"=>true})
+  end
+
+  # invalid?
+  it do
+    options = {}
+    pipe.(%{{"key": 2}}, options)#.must_equal ""
+
+    options.must_equal({"deserializer.result"=>{"key"=>2}, "contract.errors"=>false, "after_deserialize.fail"=>true, "after_meantime.left?"=>true})
+  end
+
+  it do
+    options = {}
+    pipe.(%{{"key": 1,"key2":null}}, options)#.must_equal ""
+
+    options.must_equal({"deserializer.result"=>{"key"=>1, "key2"=>nil}, "contract.errors.2"=>"screwd", "after_deserialize.fail"=>true, "after_meantime.left?"=>true})
+  end
+
+  #---
+  # return value is new input.
+  it do
+    pipe = Pipetree::Railway.new [
+      Pipetree::Railway::On.new(Pipetree::Railway::Right, ->(last, value, options) { [Pipetree::Railway::Right, value.reverse] } )
+    ]
+    pipe.("Hello", {}).must_equal [Pipetree::Railway::Right, "olleH"]
+  end
+
+  #---
+  # #>
+  describe "#>" do
+    let (:pipe) { Pipetree::Railway.new.extend(Pipetree::Railway::Operator) }
+    it {
+      pipe.> ->(input, options) { input.reverse }
+      # pipe.| B
+      # pipe.% A
+      pipe.("Hallo", {}).must_equal [Pipetree::Railway::Right, "Hallo"]
+     }
+  end
+
+  #---
+  # #inspect
+  Seventeen = ->(*) { snippet }
+  Long      = ->(*) { snippet }
+  Callable  = Object.new # random callable object.
+
+  describe "#inspect" do
+    let (:pipe) { Pipetree::Railway.new.extend(Pipetree::Railway::Operator).&(Aaa, name: "Aaa").<(B, name: "B").<(Seventeen, name: "Seventeen").>(Long, name: "Long").>(Callable, name: "Callable") }
+
+    it { pipe.inspect.must_equal %{[>Aaa,<B,<Seventeen,>Long,>Callable]} }
+
+    it { pipe.inspect(style: :rows).must_equal %{
+ 0 ==================================>Aaa
+ 1 <B====================================
+ 2 <Seventeen============================
+ 3 =================================>Long
+ 4 =============================>Callable} }
+  end
+
+  #---
+  # with aliases
+  it do
+    pipe = Pipetree::Railway.new.extend(Pipetree::Railway::Operator).
+      >(Aaa, name: "pipe.aaa").
+      >(B, name: "pipe.b").
+      >(Aaa, name: "pipe.aaa.aaa")
+
+    pipe.inspect.must_equal %{[>pipe.aaa,>pipe.b,>pipe.aaa.aaa]}
+    pipe.inspect(style: :rows).must_equal %{
+ 0 =============================>pipe.aaa
+ 1 ===============================>pipe.b
+ 2 =========================>pipe.aaa.aaa}
+
+    pipe.>(Long, after: "pipe.b", name: "Long").inspect.must_equal %{[>pipe.aaa,>pipe.b,>Long,>pipe.aaa.aaa]}
+  end
+
+  #---
+  # test decompose array
+  it do
+    pipe = Pipetree::Railway.new.extend(Pipetree::Railway::Operator).
+      &( ->((value, input), options) { input["x"] = value } ) # decomposes input.
+
+    options={key: 1}
+    input = {}
+
+    pipe.([options[:key], input], options).must_equal [Pipetree::Railway::Right, [1, {"x"=>1}]]
+    input.inspect.must_equal %{{"x"=>1}}
+    options.inspect.must_equal %{{:key=>1}}
+  end
+end
+
+class NestedPipeTest < Minitest::Spec
+  R = Pipetree::Railway
+
+  it do
+    nested_pipe = Pipetree::Railway.new.extend(Pipetree::Railway::Operator)
+      .&( ->(input, options) { options["extract"] = true } )
+      .&( ->(input, options) { options["validate"] = options[:success] } )
+
+      # This is basically what Nested() does.
+    pipe = R.new.add(R::Right,
+        R::On.new( R::Right, ->(last, input, options) {
+
+          signal, input = nested_pipe.(input, options)
+
+          [signal, input] } )
+      )
+
+
+    options = { success: true }
+    pipe.(Object, options).must_equal [Pipetree::Railway::Right, Object]
+
+    options.inspect.must_equal %{{:success=>true, \"extract\"=>true, \"validate\"=>true}}
+
+
+    pipe.(Object, options = { success: false }).must_equal [Pipetree::Railway::Left, Object]
+    options.inspect.must_equal %{{:success=>false, \"extract\"=>true, \"validate\"=>false}}
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pipetree
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-12 00:00:00.000000000 Z
+date: 2017-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: uber
@@ -79,19 +79,18 @@ files:
 - README.md
 - Rakefile
 - lib/pipetree.rb
-- lib/pipetree/flow.rb
-- lib/pipetree/flow/inspect.rb
-- lib/pipetree/flow/step_map.rb
 - lib/pipetree/insert.rb
 - lib/pipetree/inspect.rb
+- lib/pipetree/railway.rb
+- lib/pipetree/railway/inspect.rb
+- lib/pipetree/railway/operator.rb
 - lib/pipetree/version.rb
 - pipetree.gemspec
 - test/altering_test.rb
 - test/benchmark_monads.rb
 - test/benchmarking.rb
-- test/flow_test.rb
 - test/inspect_test.rb
-- test/pipetree_test.rb
+- test/railway_test.rb
 - test/test_helper.rb
 homepage: https://github.com/apotonick/pipetree
 licenses:
@@ -122,7 +121,6 @@ test_files:
 - test/altering_test.rb
 - test/benchmark_monads.rb
 - test/benchmarking.rb
-- test/flow_test.rb
 - test/inspect_test.rb
-- test/pipetree_test.rb
+- test/railway_test.rb
 - test/test_helper.rb

data/lib/pipetree/flow/step_map.rb

@@ -1,24 +0,0 @@
-# Map original proc or its name to the wrapped On.
-# This class is solely dedicated for inspect and insert operations, and not
-# involved at run-time at all.
-class Pipetree::Flow::StepMap
-  def initialize
-    @hash = {}
-  end
-
-  def []=(step, (name, original_proc, operator))
-    @hash[step] = Pipetree::Flow::Inspect::Proc.new(name, original_proc, operator)
-  end
-
-  def [](key)
-    @hash[key]
-  end
-
-  def find_proc(original_proc)
-    method = original_proc.is_a?(String) ? :name : :proc
-
-    @hash.find do |step, inspect_proc|
-      inspect_proc.send(method) == original_proc and return step
-    end
-  end
-end

data/lib/pipetree/flow.rb

@@ -1,111 +0,0 @@
-class Pipetree < Array
-  class Flow
-    require "pipetree/flow/inspect"
-    include Inspect
-    require "pipetree/flow/step_map"
-    require "pipetree/insert"
-
-    def initialize(*args)
-      @steps     = Array.new(*args)
-      @step2proc = StepMap.new
-    end
-
-    # TODO: don't inherit from Array, because we don't want Array[].
-
-    module Operators
-      # Optimize the most common steps with Stay/And objects that are faster than procs.
-      def <(proc, options={})
-        _insert On.new(Left, Stay.new(proc)), options, proc, "<"
-      end
-
-      # OnRight-> ? Right, input : Left, input
-      def &(proc, options={})
-        _insert On.new(Right, And.new(proc)), options, proc, "&"
-      end
-
-      # TODO: test me.
-      def >(proc, options={})
-        _insert On.new(Right, Stay.new(proc)), options, proc, ">"
-      end
-
-      def >>(proc, options={})
-        _insert On.new(Right,
-          ->(last, input, options) { [Right, proc.(input, options)] } ), options, proc, ">>"
-      end
-
-      def %(proc, options={})
-        # no condition is needed, and we want to stay on the same track, too.
-        _insert Stay.new(proc), options, proc, "%"
-      end
-
-      # :private:
-      # proc is the original step proc, e.g. Validate.
-      def _insert(step, options, original_proc, operator)
-        options = { append: true }.merge(options)
-
-        insert!(step, options).tap do
-          @step2proc[step] = options[:name], original_proc, operator
-        end
-
-        self
-      end
-
-      # :private:
-      def index(proc) # @step2proc: { <On @proc> => {proc: @proc, name: "trb.validate", operator: "&"} }
-        on = @step2proc.find_proc(proc) and return @steps.index(on)
-      end
-
-      require "uber/delegates"
-      extend Uber::Delegates
-      delegates :@steps, :<<, :each_with_index, :[]=, :delete_at, :insert, :unshift # FIXME: make Insert properly decoupled!
-    end
-    include Operators
-
-    # Actual implementation of Pipetree:Flow. Yes, it's that simple!
-    def call(input, options)
-      input = [Right, input]
-
-      @steps.inject(input) do |memooo, step|
-        last, memo = memooo
-        step.call(last, memo, options)
-      end
-    end
-
-    # Directions emitted by steps.
-    Left  = Class.new
-    Right = Class.new
-
-    # Incoming direction must be Left/Right.
-    class On
-      def initialize(direction, proc)
-        @direction, @proc = direction, proc
-      end
-
-      def call(last, input, options)
-        return [last, input] unless last == @direction # return unless incoming direction is Right (or Left).
-        @proc.(last, input, options)
-      end
-    end
-
-    # Call step proc and return (Right || Left).
-    class And
-      def initialize(proc)
-        @proc = proc
-      end
-
-      def call(last, input, options)
-        @proc.(input, options) ? [Right, input] : [Left,  input]
-      end
-    end
-
-    # Call step proc and return incoming last step.
-    class Stay < And
-      def call(last, input, options)
-        @proc.(input, options)
-        [last, input] # simply pass through the current direction: either [Left, input] or [Right, input].
-      end
-    end
-
-    include Function::Insert::Macros # #insert!
-  end
-end

data/test/flow_test.rb

@@ -1,188 +0,0 @@
-require "test_helper"
-
-require "pipetree/flow"
-
-# pipe = Pipetree[
-#   Pipetree::OnRight.new( ->(value, options) { #puts "|>DESERIALIZATION"
-#       value.nil? ? [Pipetree::Left, value] : [Pipetree::Right, value] } ),
-#   Pipetree::OnRight.new( ->(value, options) { #puts "|>VALIDATION"
-#       value[:ok?] ? [Pipetree::Right, value] : [Pipetree::Left, value] } ),
-#   Pipetree::OnRight.new( ->(value, options) { #puts "|>PERSISTENCE";
-#       value[:persist?] ? [Pipetree::Right, value] : [Pipetree::Left, value] } ),
-#   Pipetree::OnLeft.new( ->(value, options) { #puts "|| INVALID=CALLBACK";
-#       [Pipetree::Left, value] } ),
-#   Pipetree::OnRight.new( ->(value, options) { #puts "|>OK=CALLBACK";
-#       [Pipetree::Right, value] } ),
-#   Pipetree::OnLeft.new( ->(value, options) { #puts "|| SECOND-INVALID=CALLBACK";
-#       [Pipetree::Left, value] } ),
-
-#   Pipetree::OnLeft.new( ->(value, options) { #puts "|| FIXING IT=CALLBACK";
-#       [Pipetree::Right, value] } ),
-# ]
-
-# puts "Pipetree"
-# pipe.({ok?: true}, {})
-
-require "json"
-
-class FlowTest < Minitest::Spec
-  # TODO: test each function from & to > is only called once!
-  # describe "#call" do
-  #   let (:pipe) { Pipetree::Flow.new }
-  #   it do
-  #     pipe.>> ->(*) { puts "snippet" }
-  #     pipe.({},{})
-  #   end
-  # end
-
-  Aaa = ->(*) { "yo" }
-  B   = ->(*) {  }
-
-  let (:pipe) { pipe = Pipetree::Flow.new
-    pipe.& ->(value, options) { value && options["deserializer.result"] = JSON.parse(value) }
-    pipe.& ->(value, options) { options["deserializer.result"]["key"] == 1 ? true : (options["contract.errors"]=false) }
-    pipe.& ->(value, options) { options["deserializer.result"]["key2"] == 2 ? true : (options["contract.errors.2"]="screwd";false) }
-    pipe.< ->(value, options) { options["after_deserialize.fail"]=true }
-    pipe.% ->(value, options) { options["meantime"] = true }
-    pipe.< ->(value, options) { options["after_meantime.left?"]=true; false } # false is ignored.
-
-  }
-
-  # success?
-  it do
-    options = {}
-    pipe.(%{{"key": 1,"key2":2}}, options)#.must_equal ""
-
-    options.must_equal({"deserializer.result"=>{"key"=>1, "key2"=>2}, "meantime"=>true})
-  end
-
-  # invalid?
-  it do
-    options = {}
-    pipe.(%{{"key": 2}}, options)#.must_equal ""
-
-    options.must_equal({"deserializer.result"=>{"key"=>2}, "contract.errors"=>false, "after_deserialize.fail"=>true, "meantime"=>true, "after_meantime.left?"=>true})
-  end
-
-  it do
-    options = {}
-    pipe.(%{{"key": 1,"key2":null}}, options)#.must_equal ""
-
-    options.must_equal({"deserializer.result"=>{"key"=>1, "key2"=>nil}, "contract.errors.2"=>"screwd", "after_deserialize.fail"=>true, "meantime"=>true, "after_meantime.left?"=>true})
-  end
-
-  #---
-  # return value is new input.
-  it do
-    pipe = Pipetree::Flow.new [
-      Pipetree::Flow::On.new(Pipetree::Flow::Right, ->(last, value, options) { [Pipetree::Flow::Right, value.reverse] } )
-    ]
-    pipe.("Hello", {}).must_equal [Pipetree::Flow::Right, "olleH"]
-  end
-
-  #---
-  # #>
-  describe "#>" do
-    let (:pipe) { Pipetree::Flow.new }
-    it {
-      pipe.> ->(input, options) { input.reverse }
-      # pipe.| B
-      # pipe.% A
-      pipe.("Hallo", {}).must_equal [Pipetree::Flow::Right, "Hallo"]
-     }
-  end
-
-  # #>>
-  describe "#>>" do
-    let (:pipe) { Pipetree::Flow.new }
-    it {
-      pipe.>> ->(input, options) { input.reverse }
-      pipe.("Hallo", {}).must_equal [Pipetree::Flow::Right, "ollaH"]
-     }
-  end
-
-  #---
-  # #inspect
-  Seventeen = ->(*) { snippet }
-  Long      = ->(*) { snippet }
-  Callable  = Object.new # random callable object.
-
-  describe "#inspect" do
-    let (:pipe) { Pipetree::Flow.new.&(Aaa).>>(Long).<(B).%(Aaa).<(Seventeen).>(Long).>(Callable) }
-
-    it { pipe.inspect.must_equal %{[&Aaa,>>Long,<B,%Aaa,<Seventeen,>Long,>#<Object:>]} }
-
-    it { pipe.inspect(style: :rows).must_equal %{
- 0 ==================================&Aaa
- 1 ================================>>Long
- 2 <B====================================
- 3 =================%Aaa=================
- 4 <Seventeen============================
- 5 =================================>Long
- 6 ===========================>#<Object:>} }
-  end
-
-  describe "#index" do
-    let (:pipe) { Pipetree::Flow.new.&(Aaa).<(B).%(Aaa, name: "a.triple") }
-
-    it { pipe.index(B).must_equal 1 }
-    it { pipe.index(Aaa).must_equal 0 }
-    # with alias
-    it { pipe.index("a.triple").must_equal 2 }
-
-    # without steps
-    it { Pipetree::Flow.new.index(B).must_equal nil }
-  end
-
-  #---
-  # with aliases
-  it do
-    pipe = Pipetree::Flow.new.
-      >(Aaa, name: "pipe.aaa").
-      >(B, name: "pipe.b").
-      >(Aaa, name: "pipe.aaa.aaa")
-
-    pipe.inspect.must_equal %{[>pipe.aaa,>pipe.b,>pipe.aaa.aaa]}
-    pipe.inspect(style: :rows).must_equal %{
- 0 =============================>pipe.aaa
- 1 ===============================>pipe.b
- 2 =========================>pipe.aaa.aaa}
-
-    pipe.>(Long, after: "pipe.b").inspect.must_equal %{[>pipe.aaa,>pipe.b,>Long,>pipe.aaa.aaa]}
-  end
-
-  #---
-  # test decompose array
-  it do
-    pipe = Pipetree::Flow.new.
-      >>( ->(input, options) { [options[:key], input] } ).    # passes [bla, input] as input.
-      &( ->((value, input), options) { input["x"] = value } ) # decomposes input.
-
-    pipe.(input={}, options={key: 1}).must_equal [Pipetree::Flow::Right, [1, {"x"=>1}]]
-    input.inspect.must_equal %{{"x"=>1}}
-    options.inspect.must_equal %{{:key=>1}}
-  end
-end
-
-#- StepMap
-class StepMapTest < Minitest::Spec
-  it do
-    map = Pipetree::Flow::StepMap.new
-
-    original_proc = ->(*) { snippet }
-    step          = ->(*) { original_proc }
-
-    original_proc2 = ->(*) { snippet }
-    step2          = ->(*) { original_proc2 }
-
-    map[step]  = "my.step", original_proc, ">"
-    map[step2] = "my.step2", original_proc2, ">"
-
-    map.find_proc(original_proc).must_equal step
-    map.find_proc("my.step").must_equal step
-    map.find_proc(original_proc2).must_equal step2
-    map.find_proc("my.step2").must_equal step2
-  end
-end
-
-# TODO: instead of testing #index, test all options like :before, etc.

data/test/pipetree_test.rb

@@ -1,213 +0,0 @@
-require "test_helper"
-
-class PipelineTest < MiniTest::Spec
-  Song   = Struct.new(:title, :artist)
-  Artist = Struct.new(:name)
-  Album  = Struct.new(:ratings, :artists)
-
-
-
-  Getter        = ->(input, options) { "Yo" }
-  StopOnNil     = ->(input, options) { input }
-  SkipRender    = ->(input, *) { input == "Yo" ? input : P::Stop }
-
-  Prepare       = ->(input, options) { "Prepare(#{input})" }
-  Deserialize   = ->(input, options) { "Deserialize(#{input}, #{options[:fragment]})" }
-
-  SkipParse     = ->(input, options) { input }
-  CreateObject  = ->(input, options) { OpenStruct.new }
-
-
-  Setter        = ->(input, options) { "Setter(#{input})" }
-
-  AssignFragment = ->(input, options) { options[:fragment] = input }
-
-  it "linear" do
-    Pipetree[SkipParse, Setter].("doc", {fragment: 1}).must_equal "Setter(doc)"
-
-
-    # parse style.
-    Pipetree[AssignFragment, SkipParse, CreateObject, Prepare].("Bla", {}).must_equal "Prepare(#<OpenStruct>)"
-
-
-    # render style.
-    Pipetree[Getter, StopOnNil, SkipRender, Prepare, Setter].(nil, {}).
-      must_equal "Setter(Prepare(Yo))"
-
-    # pipeline = Representable::Pipeline[SkipParse  , SetResult, ModifyResult]
-    # pipeline.(fragment: "yo!").must_equal "modified object from yo!"
-  end
-
-  Stopping      = ->(input, options) { return Pipetree::Stop if options[:fragment] == "stop!"; input }
-
-
-  it "stopping" do
-    pipeline = Pipetree[SkipParse, Stopping, Prepare]
-    pipeline.(nil, fragment: "oy!").must_equal "Prepare()"
-    pipeline.(nil, fragment: "stop!").must_equal Pipetree::Stop
-  end
-
-  describe "Collect" do
-    Reverse = ->(input, options) { input.reverse }
-    Add = ->(input, options) { "#{input}+" }
-    let(:pipeline) { Pipetree::Collect[Reverse, Add] }
-
-    it { pipeline.(["yo!", "oy!"], {}).must_equal ["!oy+", "!yo+"] }
-
-    describe "Pipeline with Collect" do
-      let(:pipeline) { Pipetree[Reverse, Pipetree::Collect[Reverse, Add]] }
-      it { pipeline.(["yo!", "oy!"], {}).must_equal ["!yo+", "!oy+"] }
-    end
-  end
-
-  #---
-  # >1 arguments
-
-  First  = ->(input, options) { input }
-  Second = ->(input, options, memory) { input }
-
-  it do
-    skip
-    Pipetree[First, Second].("", options={}, memory={})
-  end
-
-  #---
-  #- #index
-  it do
-    A = ->(*) { snippet }
-    B = ->(*) { snippet }
-
-    pipe = Pipetree[A, B]
-    pipe.index(A).must_equal 0
-    pipe.index(B).must_equal 1
-  end
-
-#   ######### collection :ratings
-
-#   let (:ratings) {
-#     dfn = R::Definition.new(:ratings, collection: true, skip_render: ->(*) { false })
-
-#     R::Hash::Binding::Collection.new(dfn)
-#   }
-#   it "render scalar collection" do
-#     doc = {}
-#     P[
-#       R::GetValue,
-#       R::StopOnSkipable,
-#       R::Collect[
-#         R::SkipRender,
-#       ],
-#       R::AssignName,
-#       R::WriteFragment
-#     ].extend(P::Debug).(nil, {represented: Album.new([1,2,3]), binding: ratings, doc: doc, options: {}}).must_equal([1,2,3])
-
-#     doc.must_equal({"ratings"=>[1,2,3]})
-#   end
-
-# ######### collection :songs, extend: SongRepresenter
-#   let (:artists) {
-#     dfn = R::Definition.new(:artists, collection: true, extend: ArtistRepresenter, class: Artist)
-
-#     R::Hash::Binding::Collection.new(dfn)
-#   }
-#   it "render typed collection" do
-#     doc = {}
-#     P[
-#       R::GetValue,
-#       R::StopOnSkipable,
-#       R::Collect[
-#         R::Decorate,
-#         R::Serialize,
-#       ],
-#       R::AssignName,
-#       R::WriteFragment
-#     ].extend(P::Debug).(nil, {represented: Album.new(nil, [Artist.new("Diesel Boy"), Artist.new("Van Halen")]), binding: artists, doc: doc, options: {}}).must_equal([{"name"=>"Diesel Boy"}, {"name"=>"Van Halen"}])
-
-#     doc.must_equal({"artists"=>[{"name"=>"Diesel Boy"}, {"name"=>"Van Halen"}]})
-#   end
-
-# let (:album_model) { Album.new(nil, [Artist.new("Diesel Boy"), Artist.new("Van Halen")]) }
-
-#   it "parse typed collection" do
-#     doc = {"artists"=>[{"name"=>"Diesel Boy"}, {"name"=>"Van Halen"}]}
-#     P[
-#       R::AssignName,
-#       R::ReadFragment,
-#       R::StopOnNotFound,
-#       R::OverwriteOnNil,
-#       # R::SkipParse,
-#       R::Collect[
-#         R::AssignFragment,
-#         R::CreateObject::Class,
-#         R::Decorate,
-#         R::Deserialize,
-#       ],
-#       R::SetValue,
-#     ].extend(P::Debug).(doc, {represented: album_model, binding: artists, doc: doc, options: {}}).must_equal([Artist.new("Diesel Boy"), Artist.new("Van Halen")])
-
-#     album_model.artists.must_equal([Artist.new("Diesel Boy"), Artist.new("Van Halen")])
-#   end
-
-#   # TODO: test with arrays, too, not "only" Pipeline instances.
-#   describe "#Insert Pipeline[], Function, replace: OldFunction" do
-#     let (:pipeline) { P[R::GetValue, R::StopOnSkipable, R::StopOnNil] }
-
-#     it "returns Pipeline instance when passing in Pipeline instance" do
-#       P::Insert.(pipeline, R::Default, replace: R::StopOnSkipable).must_be_instance_of(R::Pipeline)
-#     end
-
-#     it "replaces if exists" do
-#       # pipeline.insert!(R::Default, replace: R::StopOnSkipable)
-
-
-#       P::Insert.(pipeline, R::Default, replace: R::StopOnSkipable).must_equal P[R::GetValue, R::Default, R::StopOnNil]
-#       pipeline.must_equal P[R::GetValue, R::StopOnSkipable, R::StopOnNil]
-#     end
-
-#     it "replaces Function instance" do
-#       pipeline = P[R::Prepare, R::StopOnSkipable, R::StopOnNil]
-#       P::Insert.(pipeline, R::Default, replace: R::Prepare).must_equal P[R::Default, R::StopOnSkipable, R::StopOnNil]
-#       pipeline.must_equal P[R::Prepare, R::StopOnSkipable, R::StopOnNil]
-#     end
-
-#     it "does not replace when not existing" do
-#       P::Insert.(pipeline, R::Default, replace: R::Prepare)
-#       pipeline.must_equal P[R::GetValue, R::StopOnSkipable, R::StopOnNil]
-#     end
-
-#     it "applies on nested Collect" do
-#       pipeline = P[R::GetValue, R::Collect[R::GetValue, R::StopOnSkipable], R::StopOnNil]
-
-#       P::Insert.(pipeline, R::Default, replace: R::StopOnSkipable).extend(P::Debug).inspect.must_equal "Pipeline[GetValue, Collect[GetValue, Default], StopOnNil]"
-#       pipeline.must_equal P[R::GetValue, R::Collect[R::GetValue, R::StopOnSkipable], R::StopOnNil]
-
-
-#       P::Insert.(pipeline, R::Default, replace: R::StopOnNil).extend(P::Debug).inspect.must_equal "Pipeline[GetValue, Collect[GetValue, StopOnSkipable], Default]"
-#     end
-
-#     it "applies on nested Collect with Function::CreateObject" do
-#       pipeline = P[R::GetValue, R::Collect[R::GetValue, R::CreateObject], R::StopOnNil]
-
-#       P::Insert.(pipeline, R::Default, replace: R::CreateObject).extend(P::Debug).inspect.must_equal "Pipeline[GetValue, Collect[GetValue, Default], StopOnNil]"
-#       pipeline.must_equal P[R::GetValue, R::Collect[R::GetValue, R::CreateObject], R::StopOnNil]
-#     end
-#   end
-
-#   describe "Insert.(delete: true)" do
-#     let(:pipeline) { P[R::GetValue, R::StopOnNil] }
-
-#     it do
-#       P::Insert.(pipeline, R::GetValue, delete: true).extend(P::Debug).inspect.must_equal "Pipeline[StopOnNil]"
-#       pipeline.extend(P::Debug).inspect.must_equal "Pipeline[GetValue, StopOnNil]"
-#     end
-#   end
-
-#   describe "Insert.(delete: true) with Collect" do
-#     let(:pipeline) { P[R::GetValue, R::Collect[R::GetValue, R::StopOnSkipable], R::StopOnNil] }
-
-#     it do
-#       P::Insert.(pipeline, R::GetValue, delete: true).extend(P::Debug).inspect.must_equal "Pipeline[Collect[StopOnSkipable], StopOnNil]"
-#       pipeline.extend(P::Debug).inspect.must_equal "Pipeline[GetValue, Collect[GetValue, StopOnSkipable], StopOnNil]"
-#     end
-#   end
-end