pipetree 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 372090919caec356b0dccdfb2c3dc80ff18e565c
-  data.tar.gz: 4c34b1b76303b7df53db05605b2037f2f559b7f9
+  metadata.gz: fb0c97eae32d5e5a171288529691ed79df1a66ab
+  data.tar.gz: eff1309c70264642f6b4a75f8e8e47baa8e7d45d
 SHA512:
-  metadata.gz: b29ec2b9ea9f2503ebf53336ae433fdf54c57eb1d9f0ffb40750ec4d093608978fec321453e357e88fd939359921535eb76ea4fa4f9b1aedc030364cab215723
-  data.tar.gz: 9cc798a6dd1d4d055d627e21533e4212060afb55583dd5766ce76449d1aa54714c18800610281d7de00015184aa5bb8f91d01e564cc9c5916eac018a588f1ce9
+  metadata.gz: 97fde978c2a3c47f32fbb3161c88331b94d9c6e2d1722de2b2c07eedb1552bb93ec2d9b79ebdda5b696df09a28f493200ed4f95529ff769bf742382bd60dd514
+  data.tar.gz: ded7af052db73f8428d8d2c5865e3fddfd3377037a5ec6f6ccd622b552ed72fba12af966f0406418e8ccc9b5c5ece397ca1bf6f8c7027c1c40a2874abb10bd26

data/CHANGES.md

@@ -1,3 +1,7 @@
+# 0.0.3
+
+* Improved insert semantics.
+
 # 0.0.2
 
 * Add `Pipetree::Flow`.

data/lib/pipetree.rb

@@ -1,6 +1,4 @@
 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

data/lib/pipetree/flow.rb

@@ -1,104 +1,109 @@
-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
+class Pipetree < Array
+  class 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={})
+        _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
+      # OnRight-> ? Right, input : Left, input
+      def &(proc, options={})
+        _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
+      # TODO: test me.
+      def >(proc, options={})
+        _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={})
+        _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
+      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, proc, operator)
-      options ||= { append: true } # DISCUSS: needed?
+      # :private:
+      # proc is the original step proc, e.g. Validate.
+      def _insert(step, options, original_proc, operator)
+        name = options[:name]
+        options = { append: true } if options.empty? || options.keys == [:name]
 
-      insert!(step, options).tap do
-        @debug ||= {}
-        @debug[step] = Inspect::Proc.new(proc, operator)
+        insert!(step, options).tap do
+          @step2proc ||= {}
+          @step2proc[step] = Inspect::Proc.new(name, original_proc, operator)
+        end
+      end
+
+      # :private:
+      def index(step) # @step2proc: { <On @proc> => {proc: @proc, name: "trb.validate", operator: "&"} }
+        method = step.is_a?(String) ? :name : :proc
+        @step2proc.find { |on, inspect_proc| inspect_proc.send(method) == step and return super(on) }
       end
     end
-  end
-  include Operators
+    include Operators
 
-  # Actual implementation of Pipetree:Flow. Yes, it's that simple!
-  def call(input, options)
-    input = [Right, input]
+    # 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)
+      inject(input) do |memooo, step|
+        last, memo = memooo
+        step.call(last, memo, options)
+      end
     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
+    # 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
+    # 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)
+      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
-  end
 
-  # Call step proc and return (Right || Left).
-  class And
-    def initialize(proc)
-      @proc = proc
-    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]
+      def call(last, input, options)
+        @proc.(input, options) ? [Right, input] : [Left,  input]
+      end
     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].
+    # 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
-  end
 
 
 
 
 
-  require "pipetree/insert"
-  module Macros
-    def insert!(new_function, options)
-      Pipetree::Insert.(self, new_function, options)
+    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
-  include Macros # FIXME: we shouldn't expose #insert!
 end

data/lib/pipetree/flow/inspect.rb

@@ -3,11 +3,11 @@ require "pipetree/inspect"
 module Pipetree::Flow::Inspect
   include ::Pipetree::Inspect
 
-  Proc = Struct.new(:proc, :operator)
+  Proc = Struct.new(:name, :proc, :operator)
 
   def inspect_for(step)
-    debug = @debug[step]
-    [super(debug.proc), debug.operator]
+    cfg = @step2proc[step]
+    [cfg.name || super(cfg.proc), cfg.operator]
   end
 
   def inspect_line(names)
@@ -18,4 +18,26 @@ module Pipetree::Flow::Inspect
   def inspect_row(index, name)
     "#{index} #{name.last}#{name.first}"
   end
+
+  def inspect_rows(names)
+    string = names.collect do |i, (name, operator)|
+
+      op = "#{operator}#{name}"
+      padding = 38
+
+      proc = if operator == "<"
+        sprintf("%- #{padding}s", op)
+      elsif [">", ">>", "&"].include?(operator.to_s)
+        sprintf("% #{padding}s", op)
+      else
+        pad = " " * ((padding - op.length) / 2)
+        "#{pad}#{op}#{pad}"
+      end
+
+      proc = proc.gsub(" ", "=")
+
+      sprintf("%2d %s", i, proc)
+    end.join("\n")
+    "\n#{string}"
+  end
 end

data/lib/pipetree/insert.rb

@@ -15,24 +15,30 @@ module Pipetree::Function
 
   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[arr.index(old_func)] = new_func
 
-        arr[index] = new_func if func==old_func
-      }
+      # arr.each_with_index { |func, index|
+      #   if func.is_a?(::Pipetree::Collect)
+      #     arr[index] = Collect[*Pipeline::Insert.(func, new_func, replace: old_func)]
+      #   end
+
+      #   arr[index] = new_func if func==old_func
+      # }
+      arr
     end
 
     def delete!(arr, removed_func)
-      arr.delete(removed_func)
+      index = arr.index(removed_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.each_with_index { |func, index|
+      #   if func.is_a?(Collect)
+      #     arr[index] = Collect[*Pipeline::Insert.(func, removed_func, delete: true)]
+      #   end
+      # }
+
+      arr
     end
 
     # TODO: not nested.

data/lib/pipetree/inspect.rb

@@ -7,14 +7,7 @@ module Pipetree::Inspect
     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}"
+    inspect_rows(names)
   end
 
   # open source file to retrieve the constant name.
@@ -27,6 +20,16 @@ module Pipetree::Inspect
     "[#{string}]"
   end
 
+  def inspect_rows(names)
+    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
+
   def inspect_row(index, name)
     "#{index}|>#{name}"
   end

data/lib/pipetree/version.rb

@@ -1,3 +1,3 @@
-module Pipetree
-  VERSION = "0.0.2"
+class Pipetree < Array
+  VERSION = "0.0.3"
 end

data/test/altering_test.rb

@@ -28,6 +28,7 @@ class AlteringTest < Minitest::Spec
   it { Pipetree[].insert!(C, prepend: true).inspect.must_equal %{[C]} }
 end
 
+require "pipetree/flow"
 class FlowInsertTest < Minitest::Spec
   A = ->{ }
   B = ->{ }
@@ -38,7 +39,8 @@ class FlowInsertTest < Minitest::Spec
   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]} }
+  it { pipe = Pipetree::Flow[].>(A).>(C, replace: A).inspect.must_equal %{[>C]} }
+  it { pipe = Pipetree::Flow[].>(A)._insert(A, {delete: true}, nil, nil).inspect.must_equal %{[]} }
 
   # FIXME: add :delete and :replace.
 end

data/test/flow_test.rb

@@ -28,17 +28,17 @@ require "json"
 class FlowTest < Minitest::Spec
   # TODO: test each function from & to > is only called once!
   # describe "#call" do
-  #   let (:pipe) { Pipetree::Flow[] }
+  #   let (:pipe) { Pipetree::Flow.new }
   #   it do
   #     pipe.>> ->(*) { puts "snippet" }
   #     pipe.({},{})
   #   end
   # end
 
-  A = ->(*) {  }
-  B = ->(*) {  }
+  Aaa = ->(*) {  }
+  B   = ->(*) {  }
 
-  let (:pipe) { pipe = Pipetree::Flow[]
+  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) }
@@ -64,7 +64,7 @@ class FlowTest < Minitest::Spec
     options.must_equal({"deserializer.result"=>{"key"=>2}, "contract.errors"=>false, "after_deserialize.fail"=>true, "meantime"=>true, "after_meantime.left?"=>true})
   end
 
-  it "what" do
+  it do
     options = {}
     pipe.(%{{"key": 1,"key2":null}}, options)#.must_equal ""
 
@@ -83,7 +83,7 @@ class FlowTest < Minitest::Spec
   #---
   # #>
   describe "#>" do
-    let (:pipe) { Pipetree::Flow[] }
+    let (:pipe) { Pipetree::Flow.new }
     it {
       pipe.> ->(input, options) { input.reverse }
       # pipe.| B
@@ -94,7 +94,7 @@ class FlowTest < Minitest::Spec
 
   # #>>
   describe "#>>" do
-    let (:pipe) { Pipetree::Flow[] }
+    let (:pipe) { Pipetree::Flow.new }
     it {
       pipe.>> ->(input, options) { input.reverse }
       pipe.("Hallo", {}).must_equal [Pipetree::Flow::Right, "ollaH"]
@@ -103,22 +103,47 @@ class FlowTest < Minitest::Spec
 
   #---
   # #inspect
+  Seventeen = ->(*) { snippet }
+  Long      = ->(*) { snippet }
+
   describe "#inspect" do
-    let (:pipe) { Pipetree::Flow[].&(A).<(B).%(A) }
+    let (:pipe) { Pipetree::Flow.new.&(Aaa).>>(Long).<(B).%(Aaa).<(Seventeen).>(Long) }
 
-    it { pipe.inspect.must_equal %{[&A,<B,%A]} }
+    it { pipe.inspect.must_equal %{[&Aaa,>>Long,<B,%Aaa,<Seventeen,>Long]} }
 
     it { pipe.inspect(style: :rows).must_equal %{
- 0 &A
- 1 <B
- 2 %A} }
+ 0 ==================================&Aaa
+ 1 ================================>>Long
+ 2 <B====================================
+ 3 =================%Aaa=================
+ 4 <Seventeen============================
+ 5 =================================>Long} }
   end
 
   describe "#index" do
-    let (:pipe) { Pipetree::Flow[].&(A).<(B).%(A) }
+    let (:pipe) { Pipetree::Flow.new.&(Aaa).<(B).%(Aaa, name: "a.triple") }
 
     it { pipe.index(B).must_equal 1 }
-    it { pipe.index(A).must_equal 0 }
+    it { pipe.index(Aaa).must_equal 0 }
+    # with alias
+    it { pipe.index("a.triple").must_equal 2 }
+  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
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pipetree
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-01 00:00:00.000000000 Z
+date: 2016-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler