pipetree 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4c06f28009c3c0336a76d69b09ca4ecc1d6821a
-  data.tar.gz: 949fbc15906d193bcabbbf84377d1befc00fdae1
+  metadata.gz: 372090919caec356b0dccdfb2c3dc80ff18e565c
+  data.tar.gz: 4c34b1b76303b7df53db05605b2037f2f559b7f9
 SHA512:
-  metadata.gz: 06ce0641d861248bc44d97b62182327b6133ac57c8cd22223b26c6260436e8b082bae8447eef4c08b3b4c67968a838f74dc87b8dfb44ac8496f6e8bc90b09662
-  data.tar.gz: 224c93d3304b71dfce2bb828d63562336cc6d050ea99b5d9828eb2574908d8f1e76589edb7545590321e47a42740014deaa7d2719aeb8ddf0d85f6a5481ff176
+  metadata.gz: b29ec2b9ea9f2503ebf53336ae433fdf54c57eb1d9f0ffb40750ec4d093608978fec321453e357e88fd939359921535eb76ea4fa4f9b1aedc030364cab215723
+  data.tar.gz: 9cc798a6dd1d4d055d627e21533e4212060afb55583dd5766ce76449d1aa54714c18800610281d7de00015184aa5bb8f91d01e564cc9c5916eac018a588f1ce9

data/CHANGES.md

@@ -0,0 +1,3 @@
+# 0.0.2
+
+* Add `Pipetree::Flow`.

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "benchmark-ips"
+
+gem "dry-monads"
+gem "minitest-line"

data/README.md

@@ -0,0 +1,23 @@
+Example use: trailblazer.to/gems/operation/2.0/pipetree.html
+
+
+Executing a pipetree generated from declarative configuration.
+
+This reduces conditionals at run-time,
+Replaces clumsy module includes to inject or override features (in the correct order) with explicit, (visual!) pipelines
+Speeds up as only the pipelines need to be run without too much decider code.
+
+
+First used in the Representable gem.
+
+
+
+Instead of implementing the perfect API where users can override methods, call `super` or inject their logic, let them construct their own workflow.
+
+This is way less tedious than climbing through `super` calls and callstacks.
+
+
+## TODO
+
+* Catch exceptions and show where in the pipe they were raised.
+* Statically compile pipetrees into Ruby methods to make it lightning fast (paid gem?)

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/setup'
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.test_files = FileList['test/*_test.rb']
+  test.verbose = true
+end

data/lib/pipetree/flow/inspect.rb

@@ -0,0 +1,21 @@
+require "pipetree/inspect"
+
+module Pipetree::Flow::Inspect
+  include ::Pipetree::Inspect
+
+  Proc = Struct.new(:proc, :operator)
+
+  def inspect_for(step)
+    debug = @debug[step]
+    [super(debug.proc), debug.operator]
+  end
+
+  def inspect_line(names)
+    string = names.collect { |i, name| "#{name.last}#{name.first}" }.join(",")
+    "[#{string}]"
+  end
+
+  def inspect_row(index, name)
+    "#{index} #{name.last}#{name.first}"
+  end
+end

data/lib/pipetree/flow.rb

@@ -0,0 +1,104 @@
+class Pipetree::Flow < Array # yes, we could inherit, and so on.
+  require "pipetree/flow/inspect"
+  include Inspect
+
+  module Operators
+    # Optimize the most common steps with Stay/And objects that are faster than procs.
+    def <(proc, options=nil)
+      _insert On.new(Left, Stay.new(proc)), options, proc, "<"
+    end
+
+    # OnRight-> ? Right, input : Left, input
+    def &(proc, options=nil)
+      _insert On.new(Right, And.new(proc)), options, proc, "&"
+    end
+
+    # TODO: test me.
+    def >(proc, options=nil)
+      _insert On.new(Right, Stay.new(proc)), options, proc, ">"
+    end
+
+    def >>(proc, options=nil)
+      _insert On.new(Right,
+        ->(last, input, options) { [Right, proc.(input, options)] } ), options, proc, ">>"
+    end
+
+    def %(proc, options=nil)
+      # 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, proc, operator)
+      options ||= { append: true } # DISCUSS: needed?
+
+      insert!(step, options).tap do
+        @debug ||= {}
+        @debug[step] = Inspect::Proc.new(proc, operator)
+      end
+    end
+  end
+  include Operators
+
+  # Actual implementation of Pipetree:Flow. Yes, it's that simple!
+  def call(input, options)
+    input = [Right, input]
+
+    inject(input) do |memooo, step|
+      last, memo = memooo
+      step.call(last, memo, options)
+    end
+  end
+
+  def index(step) # @debug maps the original user's step proc to the On instance (or any kind of wrapper proc).
+    @debug.find { |on, inspect_proc| inspect_proc.proc == step and return super(on) }
+  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
+
+
+
+
+
+  require "pipetree/insert"
+  module Macros
+    def insert!(new_function, options)
+      Pipetree::Insert.(self, new_function, options)
+    end
+  end
+  include Macros # FIXME: we shouldn't expose #insert!
+end

data/lib/pipetree/insert.rb

@@ -0,0 +1,61 @@
+module Pipetree::Function
+  class Insert
+    def call(arr, func, options)
+      # arr = arr.dup
+      return delete!(arr, func) if options[:delete]
+      return replace!(arr, options[:replace], func) if options[:replace]
+      return before!(arr, options[:before], func)   if options[:before]
+      return after!(arr, options[:after], func)   if options[:after]
+      return append!(arr, options[:append], func)   if options[:append]
+      return prepend!(arr, options[:prepend], func)   if options[:prepend]
+
+      raise "[Pipetree] Unknown command #{options.inspect}" # TODO: test.
+      # arr
+    end
+
+  private
+    def replace!(arr, old_func, new_func)
+      arr.each_with_index { |func, index|
+        if func.is_a?(Collect)
+          arr[index] = Collect[*Pipeline::Insert.(func, new_func, replace: old_func)]
+        end
+
+        arr[index] = new_func if func==old_func
+      }
+    end
+
+    def delete!(arr, removed_func)
+      arr.delete(removed_func)
+
+      # 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
+      }
+    end
+
+    # TODO: not nested.
+    def before!(arr, old_func, new_func)
+      index = arr.index(old_func)
+      arr.insert(index, new_func)
+    end
+
+    def after!(arr, old_func, new_func)
+      index = arr.index(old_func)+1
+      arr.insert(index, new_func)
+    end
+
+    def append!(arr, old_func, new_func)
+      arr << (new_func)
+    end
+
+    def prepend!(arr, old_func, new_func)
+      arr.unshift(new_func)
+    end
+  end
+end
+
+Pipetree::Insert = Pipetree::Function::Insert.new
+
+#FIXME: all methods write to original array.

data/lib/pipetree/inspect.rb

@@ -0,0 +1,33 @@
+module Pipetree::Inspect
+  # TODO: implement for nested
+  # TODO: remove in Representable::Debug.
+  def inspect(options={ style: :line })
+    names = each_with_index.collect do |func, i|
+      [i, inspect_for(func)]
+    end
+
+    return inspect_line(names) if options[:style] == :line
+
+    string = names.collect do |i, name|
+      index = sprintf("%2d", i)
+      inspect_row(index, name)
+    end.join("\n")
+      # name  = sprintf("%-60.300s", name) # no idea what i'm doing here.
+      # "#{index}) #{name} #{func.source_location.join(":")}"
+    "\n#{string}"
+  end
+
+  # open source file to retrieve the constant name.
+  def inspect_for(func)
+    File.readlines(func.source_location[0])[func.source_location[1]-1].match(/^\s+([\w\:]+)/)[1]
+  end
+
+  def inspect_line(names)
+    string = names.collect { |i, name| "#{name}" }.join("|>")
+    "[#{string}]"
+  end
+
+  def inspect_row(index, name)
+    "#{index}|>#{name}"
+  end
+end

data/lib/pipetree/version.rb

@@ -1,3 +1,3 @@
 module Pipetree
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/pipetree.rb

@@ -1,3 +1,57 @@
-module Pipetree
+class Pipetree < Array
+  VERSION = "0.0.1"
 
+  # 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
 end

data/test/altering_test.rb

@@ -0,0 +1,44 @@
+require "test_helper"
+
+class AlteringTest < Minitest::Spec
+  A = ->(*) { }
+  B = ->(*) { }
+  C = ->(*) { }
+
+  # 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]} }
+end
+
+class FlowInsertTest < Minitest::Spec
+  A = ->{ }
+  B = ->{ }
+  C = ->{ }
+
+  it { pipe = Pipetree::Flow[].>(A).>(B).inspect.must_equal %{[>A,>B]} }
+  it { pipe = Pipetree::Flow[].>(A).>(B, before: A).inspect.must_equal %{[>B,>A]} }
+  it { pipe = Pipetree::Flow[].>(A).>(B).>(C, after: A).inspect.must_equal %{[>A,>C,>B]} }
+  it { pipe = Pipetree::Flow[].>(A).>(C, append: true).inspect.must_equal %{[>A,>C]} }
+  it { pipe = Pipetree::Flow[].>(A).>(C, prepend: true).inspect.must_equal %{[>C,>A]} }
+  # it { pipe = Pipetree::Flow[].>(A).>(C, replace: A).inspect.must_equal %{[>C]} }
+
+  # FIXME: add :delete and :replace.
+end

data/test/benchmark_monads.rb

@@ -0,0 +1,180 @@
+require "test_helper"
+
+
+require "dry-monads"
+
+class EitherCalculator
+  include Dry::Monads::Either::Mixin
+
+  attr_accessor :input
+
+  def calculate(input)
+    Right(input).bind do |value|
+      # puts "|>DESERIALIZATION"
+      value.nil? ? Left(value) : Right(value)
+    end.bind do |value|
+      # puts "|>VALIDATION"
+      value[:ok?] ? Right(value) : Left(value)
+    end.bind do |value|
+      # puts "|>PERSISTENCE"
+      value[:persist?] ? Right(value) : Left(value)
+    end.or do |value|
+      # puts "|| INVALID=CALLBACK"
+      Left(value)
+    end.bind do |value|
+      # puts "|> OK=CALLBACK"
+      Right(value)
+    end.or do |value|
+      # puts "|| SECOND-INVALID=CALLBACK"
+      Left(value)
+    end.or do |value|
+      # puts "|| FIXING IT=CALLBACK"
+      Right(value)
+    end
+    # .bind do |value|
+    #   puts "|> WHATEVER HAPPENED=CALLBACK"
+    #   Right(value)
+    # end
+  end
+end
+
+# EitherCalculator instance
+c = EitherCalculator.new
+
+# If everything went right
+# c.calculate(nil)
+# c.calculate({})
+c.calculate({ok?: true})
+# c.calculate({ok?: true, persist?: true})
+
+require "pipetree/flow"
+
+# 254.186k (± 1.2%) i/s -      1.289M in   5.071256s # pure dry-monads
+# 268.407k (± 1.6%) i/s -      1.353M in   5.043612s # pipetree-flow
+
+pipe = Pipetree::Flow[
+  Pipetree::Flow::On.new(Pipetree::Flow::Right, ->(last, value, options) { #puts "|>DESERIALIZATION"
+      value.nil? ? [Pipetree::Flow::Left, value] : [Pipetree::Flow::Right, value] } ),
+  Pipetree::Flow::On.new(Pipetree::Flow::Right, ->(last, value, options) { #puts "|>VALIDATION"
+      value[:ok?] ? [Pipetree::Flow::Right, value] : [Pipetree::Flow::Left, value] } ),
+  Pipetree::Flow::On.new(Pipetree::Flow::Right, ->(last, value, options) { #puts "|>PERSISTENCE";
+      value[:persist?] ? [Pipetree::Flow::Right, value] : [Pipetree::Flow::Left, value] } ),
+  Pipetree::Flow::On.new(Pipetree::Flow::Left, ->(last, value, options) { #puts "|| INVALID=CALLBACK";
+      [Pipetree::Flow::Left, value] } ),
+  Pipetree::Flow::On.new(Pipetree::Flow::Right, ->(last, value, options) { #puts "|>OK=CALLBACK";
+      [Pipetree::Flow::Right, value] } ),
+  Pipetree::Flow::On.new(Pipetree::Flow::Left, ->(last, value, options) { #puts "|| SECOND-INVALID=CALLBACK";
+      [Pipetree::Flow::Left, value] } ),
+
+  Pipetree::Flow::On.new(Pipetree::Flow::Left, ->(last, value, options) { #puts "|| FIXING IT=CALLBACK";
+      [Pipetree::Flow::Right, value] } ),
+]
+
+puts "Pipetree"
+pipe.({ok?: true}, {})
+
+ # exit
+
+
+flow = Pipetree::Flow[]
+flow.& ->(value, options) {
+  #puts "|>DESERIALIZATION"
+  !value.nil? }
+flow.& ->(value, options) {
+  #puts "|>VALIDATION"
+  value[:ok?] }
+flow.& ->(value, options) {
+  #puts "|>PERSISTENCE";
+  value[:persist?] }
+flow.< ->(value, options) {
+  #puts "< INVALID=CALLBACK";
+  value }
+flow.& ->(value, options) {
+  #puts "<>OK=CALLBACK";
+  value }
+flow.< ->(value, options) {
+  #puts "< SECOND-INVALID=CALLBACK";
+  value }
+flow.< ->(value, options) {
+  #puts "|| FIXING IT=CALLBACK"
+  value }
+
+puts "FLOW"
+flow.({ok?: true}, {})
+
+require "benchmark/ips"
+Benchmark.ips do |x|
+  x.report { c.calculate({ok?: true}) }
+  x.report { pipe.({ok?: true}, {}) }
+  x.report { flow.({ok?: true}, {}) }
+end
+
+
+
+
+# puts result = c.calculate
+
+
+M = Dry::Monads
+
+maybe_user = M.Maybe(true).bind do |u|
+  M.Maybe(nil).bind do |a|
+    M.Maybe(raise)
+  end
+end
+
+class A
+  def call
+  end
+end
+
+# Benchmark.ips do |x|
+#   x.report { A.new(1) } # 3.059M (± 4.4%) i/s -     15.302M in   5.012694s
+#   x.report { [A, 1] }   # 6.606M (± 2.9%) i/s -     33.042M in   5.007420s
+# end
+
+#   proc = ->(*) {  }
+#   a = A.new
+# Benchmark.ips do |x|
+#   x.report { proc.is_a?(Proc) }
+#   x.report { a.()  }
+# end
+
+
+
+
+# 258.340k (± 1.0%) i/s -      1.297M in   5.020288s
+# 266.743k (± 0.9%) i/s -      1.345M in   5.043017s
+# 215.273k (± 1.0%) i/s -      1.089M in   5.060944s
+
+
+class A
+  def initialize
+    @b = B.new
+  end
+
+  class B
+    def b
+      "B"
+    end
+  end
+
+  def b
+    @b.b
+  end
+end
+
+class One
+  def b
+    b_internal
+  end
+
+  def b_internal
+    "B"
+  end
+end
+
+Benchmark.ips do |x|
+  x.report { A.new.b }
+  x.report { One.new.b }
+end

data/test/benchmarking.rb

@@ -0,0 +1,59 @@
+require "test_helper"
+
+require "benchmark/ips"
+#  0.020000   0.000000   0.020000 (  0.023401)
+#  0.050000   0.000000   0.050000 (  0.057883)
+Return = ->(params, payload, read, write) {
+  read["bla"]
+  write["bla."] = Object
+  params
+}
+# Return = ->(params, payload) {
+#   payload[:read]["bla"]
+#   payload[:write]["bla."] = Object
+#   params
+# }
+
+pipe = Pipetree[
+  *(99999.times.collect{ Return })
+]
+
+# puts Benchmark.measure { pipe.("bla", {}, {}, {}) }
+
+
+
+#---
+# replacing result AND options.
+Return1 = ->(input, options) {
+  result = input + "*"
+
+  result
+}
+
+pipe1 = Pipetree[
+  *(99999.times.collect{ Return1 })
+]
+
+class Pipetree2 < Pipetree
+  def call(input, options)
+    inject(input) do |memo, step|
+      res, options = evaluate(step, memo, options)
+      return(Stop) if Stop == res
+      res
+    end
+
+  end
+end
+
+Return2 = ->(input, options) {
+  [(result = (input + "*")), options]
+}
+
+pipe2 = Pipetree2[
+  *(99999.times.collect{ Return2 })
+]
+
+Benchmark.ips do |x|
+  x.report { pipe1.("", {}) }
+  x.report { pipe2.("", {}) }
+end

data/test/flow_test.rb

@@ -0,0 +1,125 @@
+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[] }
+  #   it do
+  #     pipe.>> ->(*) { puts "snippet" }
+  #     pipe.({},{})
+  #   end
+  # end
+
+  A = ->(*) {  }
+  B = ->(*) {  }
+
+  let (:pipe) { pipe = Pipetree::Flow[]
+    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 "what" 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[
+      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[] }
+    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[] }
+    it {
+      pipe.>> ->(input, options) { input.reverse }
+      pipe.("Hallo", {}).must_equal [Pipetree::Flow::Right, "ollaH"]
+     }
+  end
+
+  #---
+  # #inspect
+  describe "#inspect" do
+    let (:pipe) { Pipetree::Flow[].&(A).<(B).%(A) }
+
+    it { pipe.inspect.must_equal %{[&A,<B,%A]} }
+
+    it { pipe.inspect(style: :rows).must_equal %{
+ 0 &A
+ 1 <B
+ 2 %A} }
+  end
+
+  describe "#index" do
+    let (:pipe) { Pipetree::Flow[].&(A).<(B).%(A) }
+
+    it { pipe.index(B).must_equal 1 }
+    it { pipe.index(A).must_equal 0 }
+  end
+end
+
+# TODO: instead of testing #index, test all options like :before, etc.

data/test/inspect_test.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+
+class InspectTest < Minitest::Spec
+  module M
+  end
+
+  M::AlphaConstant = ->(*) { }
+  M::Beta          = ->(*) { }
+
+  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] }
+
+  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}
+  end
+
+  # different separator
+  it { ::Pipetree[M::AlphaConstant,M::Beta].inspect.must_equal %{[M::AlphaConstant|>M::Beta]} }
+end

data/test/pipetree_test.rb

@@ -0,0 +1,200 @@
+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
+
+#   ######### 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

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require "minitest/autorun"
+require "pipetree"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pipetree
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-05 00:00:00.000000000 Z
+date: 2016-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -59,9 +59,24 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGES.md
+- Gemfile
+- README.md
+- Rakefile
 - lib/pipetree.rb
+- lib/pipetree/flow.rb
+- lib/pipetree/flow/inspect.rb
+- lib/pipetree/insert.rb
+- lib/pipetree/inspect.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/test_helper.rb
 homepage: https://github.com/apotonick/pipetree
 licenses:
 - MIT
@@ -82,9 +97,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.6.3
 signing_key: 
 specification_version: 4
 summary: Functional nested pipeline dialect that reduces runtime logic, overriding
   and awkward module inclusion.
-test_files: []
+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/test_helper.rb