pipetree 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fb0c97eae32d5e5a171288529691ed79df1a66ab
-  data.tar.gz: eff1309c70264642f6b4a75f8e8e47baa8e7d45d
+  metadata.gz: 13019affb084e0a3dc4470feec4f21c904a1af83
+  data.tar.gz: ea2b5913c8afad622ad624cd77736c9b6a601304
 SHA512:
-  metadata.gz: 97fde978c2a3c47f32fbb3161c88331b94d9c6e2d1722de2b2c07eedb1552bb93ec2d9b79ebdda5b696df09a28f493200ed4f95529ff769bf742382bd60dd514
-  data.tar.gz: ded7af052db73f8428d8d2c5865e3fddfd3377037a5ec6f6ccd622b552ed72fba12af966f0406418e8ccc9b5c5ece397ca1bf6f8c7027c1c40a2874abb10bd26
+  metadata.gz: 521d4af02d44620e9a510a8e9703d843cda87aaccc02962d9b194881c837f56d3d1b4d9d77d0e5d127c66f9f24333ccabc94af763679eea3b98709b28d4ccf98
+  data.tar.gz: f49f1e93b4371a6282f71bfc24ab6241a86d118810cf0ab35a44f88f43adcd12529e6ad8fbac6ac8bbc156897ede6ad1fd9eabdcc368b70adc9b0f426373ce00

data/.travis.yml

@@ -0,0 +1,8 @@
+rvm:
+  - 1.9.3
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3.1
+before_install:
+  - gem install bundler

data/Gemfile

@@ -3,6 +3,4 @@ source "https://rubygems.org"
 gemspec
 
 gem "benchmark-ips"
-
-gem "dry-monads"
 gem "minitest-line"

data/README.md

@@ -16,6 +16,15 @@ Instead of implementing the perfect API where users can override methods, call `
 
 This is way less tedious than climbing through `super` calls and callstacks.
 
+## Installation
+
+In your `Gemfile`.
+
+```ruby
+gem "pipetree"
+```
+
+Pipetree runs with Ruby >= 1.9.3.
 
 ## TODO
 

data/lib/pipetree/flow/inspect.rb

@@ -5,7 +5,7 @@ module Pipetree::Flow::Inspect
 
   Proc = Struct.new(:name, :proc, :operator)
 
-  def inspect_for(step)
+  def inspect_func(step)
     cfg = @step2proc[step]
     [cfg.name || super(cfg.proc), cfg.operator]
   end

data/lib/pipetree/flow/step_map.rb

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

@@ -2,6 +2,8 @@ class Pipetree < Array
   class Flow < Array # yes, we could inherit, and so on.
     require "pipetree/flow/inspect"
     include Inspect
+    require "pipetree/flow/step_map"
+    require "pipetree/insert"
 
     module Operators
       # Optimize the most common steps with Stay/And objects that are faster than procs.
@@ -32,19 +34,17 @@ class Pipetree < Array
       # :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]
+        options = { append: true }.merge(options)
 
         insert!(step, options).tap do
-          @step2proc ||= {}
-          @step2proc[step] = Inspect::Proc.new(name, original_proc, operator)
+          @step2proc ||= StepMap.new
+          @step2proc[step] = options[: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) }
+      def index(proc) # @step2proc: { <On @proc> => {proc: @proc, name: "trb.validate", operator: "&"} }
+        on = @step2proc.find_proc(proc) and return super(on)
       end
     end
     include Operators
@@ -94,16 +94,6 @@ class Pipetree < Array
       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!
+    include Function::Insert::Macros # #insert!
   end
 end

data/lib/pipetree/insert.rb

@@ -2,12 +2,10 @@ 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]
+      operations = [:delete, :replace, :before, :after, :append, :prepend]
+
+      # replace!(arr, options[:replace], func)
+      options.keys.reverse.each { |k| operations.include?(k) and return send("#{k}!", arr, options[k], func) }
 
       raise "[Pipetree] Unknown command #{options.inspect}" # TODO: test.
       # arr
@@ -27,7 +25,7 @@ module Pipetree::Function
       arr
     end
 
-    def delete!(arr, removed_func)
+    def delete!(arr, _, removed_func)
       index = arr.index(removed_func)
       arr.delete_at(index)
 
@@ -59,6 +57,12 @@ 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
 

data/lib/pipetree/inspect.rb

@@ -3,7 +3,7 @@ module Pipetree::Inspect
   # TODO: remove in Representable::Debug.
   def inspect(options={ style: :line })
     names = each_with_index.collect do |func, i|
-      [i, inspect_for(func)]
+      [i, inspect_func(func)]
     end
 
     return inspect_line(names) if options[:style] == :line
@@ -11,8 +11,17 @@ module Pipetree::Inspect
   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]
+  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]
   end
 
   def inspect_line(names)

data/lib/pipetree/version.rb

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

data/test/altering_test.rb

@@ -1,9 +1,9 @@
 require "test_helper"
 
 class AlteringTest < Minitest::Spec
-  A = ->(*) { }
+  A = ->(*) { "bla ruby 1.9 needs that" }
   B = ->(*) { }
-  C = ->(*) { }
+  C = ->(*) { "otherwise it'll confuse empty procs" }
 
   # constructor.
   it do
@@ -26,6 +26,9 @@ class AlteringTest < Minitest::Spec
 
   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"
@@ -41,6 +44,5 @@ class FlowInsertTest < Minitest::Spec
   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)._insert(A, {delete: true}, nil, nil).inspect.must_equal %{[]} }
-
   # FIXME: add :delete and :replace.
 end

data/test/flow_test.rb

@@ -35,7 +35,7 @@ class FlowTest < Minitest::Spec
   #   end
   # end
 
-  Aaa = ->(*) {  }
+  Aaa = ->(*) { "yo" }
   B   = ->(*) {  }
 
   let (:pipe) { pipe = Pipetree::Flow.new
@@ -105,11 +105,12 @@ class FlowTest < Minitest::Spec
   # #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) }
+    let (:pipe) { Pipetree::Flow.new.&(Aaa).>>(Long).<(B).%(Aaa).<(Seventeen).>(Long).>(Callable) }
 
-    it { pipe.inspect.must_equal %{[&Aaa,>>Long,<B,%Aaa,<Seventeen,>Long]} }
+    it { pipe.inspect.must_equal %{[&Aaa,>>Long,<B,%Aaa,<Seventeen,>Long,>#<Object:>]} }
 
     it { pipe.inspect(style: :rows).must_equal %{
  0 ==================================&Aaa
@@ -117,7 +118,8 @@ class FlowTest < Minitest::Spec
  2 <B====================================
  3 =================%Aaa=================
  4 <Seventeen============================
- 5 =================================>Long} }
+ 5 =================================>Long
+ 6 ===========================>#<Object:>} }
   end
 
   describe "#index" do
@@ -145,6 +147,39 @@ class FlowTest < Minitest::Spec
 
     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/inspect_test.rb

@@ -6,8 +6,9 @@ class InspectTest < Minitest::Spec
 
   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] }
+  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
@@ -25,9 +26,10 @@ class InspectTest < Minitest::Spec
  7|>M::AlphaConstant
  8|>M::Beta
  9|>M::AlphaConstant
-10|>M::Beta}
+10|>M::Beta
+11|>#<Object:>}
   end
 
   # different separator
-  it { ::Pipetree[M::AlphaConstant,M::Beta].inspect.must_equal %{[M::AlphaConstant|>M::Beta]} }
+  it { ::Pipetree[M::AlphaConstant,M::Beta,Callable].inspect.must_equal %{[M::AlphaConstant|>M::Beta|>#<Object:>]} }
 end

data/test/pipetree_test.rb

@@ -71,6 +71,17 @@ class PipelineTest < MiniTest::Spec
     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) {
@@ -147,6 +158,8 @@ class PipelineTest < MiniTest::Spec
 
 #     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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pipetree
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-05 00:00:00.000000000 Z
+date: 2016-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -59,6 +59,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".travis.yml"
 - CHANGES.md
 - Gemfile
 - README.md
@@ -66,6 +67,7 @@ files:
 - 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/version.rb