function_chain 0.0.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fdf003460177adf194c6282fc22e83659bb93c5a
-  data.tar.gz: fcf5395ab9889a3ede9cfbbea020de00644ce4d8
+  metadata.gz: dc0b4ab079683f23b77447d2fb6e092f9795fe12
+  data.tar.gz: 04ff13d4a5d505b157cfce3e1db80074ee8a07b9
 SHA512:
-  metadata.gz: 8b3821ebdc3b4234bbbcaae2bc502c832fa63f6a4e2df14f08b8baa18ea334add047f2e48724901c00609d63a81e193b91001d6e37fef9b9c253cf02fbf5d37a
-  data.tar.gz: 2f9afcd3051e99adfd032558cea80309e09b2c09954f4a6f652fbf1eb721bcb3cf74b9518e37c12979995842b00359c01768c41fde149cc3402aeb2a7d558ee3
+  metadata.gz: 22bd3c36c5c1ca3e3428d91cbcd9f062684cf78d62c7af40545276e662aed4d8d0862cc1fdeb9556f2ad33eab603fa279c9ccc7cd50e7bf0ebd84dbefe6e0653
+  data.tar.gz: a9941e868b78c8de12146dcf099c3891c4683a7d7a74feacf76663e952467a04f5c9003b8eccc0f3bef2b7d709236c6b7ca47d679d98b5b68614f81672c570cc

data/README.md

@@ -70,33 +70,87 @@ chain.call # => LOUIS
   PullChain.new(account, "user/name/upcase").call
   ```
 
-2. **Use << operator**
+2. **Use <<**
   ```ruby
   chain = PullChain.new(account)
   chain << :user << :name << :upcase
   chain.call
   ```
 
-3. **Use add method**
+3. **Use *add***
   ```ruby
+  chain = PullChain.new(account)
   chain.add(:user).add(:name).add(:upcase).call
   ```
 
-4. **Use add_all method**
+4. **Use *add_all***
   ```ruby
+  chain = PullChain.new(account)
   chain.add_all(:user, :name, :upcase).call
   ```
 
+5. **Use *Proc***
+  ```ruby
+  chain = PullChain.new(account)
+  chain << Proc.new { user } << Proc.new { name } << Proc.new { upcase }
+  chain.call
+  ```
+  If you use *lambda* then can't omit block parameter.
+  block parameter is previous chain result.
+  ```ruby
+  chain = PullChain.new(account)
+  chain << lambda { |account| account.user } <<
+           lambda { |user| user.name } <<
+           lambda { |name| name.upcase }
+  chain.call
+  ```
+  *lambda* evaluate by previous chain result, so can call results method direct.
+    ```ruby
+  chain = PullChain.new(account)
+  chain << lambda { |_| user } << lambda { |_| name } << lambda { |_| upcase }
+  chain.call
+  ```
+  if want to omit block parameter, recommend *Proc* use.
+
+6. **Use *add* with block**
+  ```ruby
+  PullChain.new(account).add { user }.add { name }.add { upcase }.call
+  ```
+
 #### Can exist nil value on the way, like a following case
 ```ruby
 user.name = nil
 chain.call # => nil
 ```
 
-#### Insert, Delete, Clear
-insert, insert_all method is insert_all method to chain.  
-delete_at method is delete method from chain.  
-clear method is delete all method from chain.
+#### Insert
+*insert*, *insert_all* is insert method to chain.  
+```ruby
+chain = PullChain.new(account, :user, :upcase)
+chain.insert(1, :name).call
+
+chain = PullChain.new(account, :user)
+chain.insert_all(1, :name, :upcase).call
+```
+*insert* with block
+```ruby
+chain = PullChain.new(account, :user, :upcase)
+chain.insert(1) { name }.call
+```
+#### Delete
+*delete_at* is delete method from chain.
+```ruby
+chain = PullChain.new(account, :user, :name, :upcase)
+chain.delete_at(2)
+chain.call # => Louis
+```
+#### Clear
+*clear* is delete all method from chain.
+```ruby
+chain = PullChain.new(account, :user, :name, :upcase)
+chain.clear
+chain.call # => #<struct Account user=#<struct User name="Louis">>
+```
 
 ### Require arguments on method
 Following example's method is require two arguments.  
@@ -109,18 +163,30 @@ class Foo
 end
 ```
 ###### Solution
-1. **Array, format is [Symbol, [\*Args]]**
+1. **_Array_, format is [_Symbol_, [\*args]]**
   ```ruby
   chain = PullChain.new(Foo.new) << [:say, ["Andres", "Hello"]]
   chain.call # => Andres said 'Hello'
   ```
 
-2. **String**
+2. ***String***
   ```ruby
-  chain = PullChain.new(foo) << "say('John', 'Goodbye')"
+  chain = PullChain.new(Foo.new) << "say('John', 'Goodbye')"
   chain.call # => John said 'Goodbye'
   ```
 
+3. ***Proc***
+  ```ruby
+  chain = PullChain.new(Foo.new) << Proc.new { say('Julian', 'Nice to meet you') }
+  chain.call # => Julian said 'Nice to meet you'
+  ```
+
+4. **_add_ with block**
+  ```ruby
+  chain = PullChain.new(Foo.new).add { say('Narciso', 'How do you do?') }
+  chain.call # => Narciso said 'How do you do?'
+  ```
+
 ### Require block on method
 Following example's method is require Block.  
 What should do in this case?
@@ -130,20 +196,34 @@ What should do in this case?
 
 ###### Solution
 
-1. **Array, format is [Symbol, [\*Args, Proc]]**
+1. **_Array_, format is [_Symbol_, [\*args, _Proc_]]**
   ```ruby
   chain = PullChain.new([1,2,3,4,5])
   chain << [:inject, [3, lambda { |sum, n| sum + n }]]
   chain.call # => 18
   ```
 
-2. **String**
+2. **_String_**
   ```ruby
   chain = PullChain.new([1,2,3,4,5])
   chain << "inject(3) { |sum, n| sum + n }"
   chain.call # => 18
   ```
 
+3. **_Proc_**
+  ```ruby
+  chain = PullChain.new([1,2,3,4,5])
+  chain << Proc.new { inject(3) { |sum, n| sum + n } }
+  chain.call # => 18
+  ```
+
+4. **_add_ with block**
+  ```ruby
+  chain = PullChain.new([1,2,3,4,5])
+  chain.add { inject(3) { |sum, n| sum + n } }
+  chain.call # => 18
+  ```
+
 ### Use result on chain
 Like a following example, can use result on chain.
 ```ruby
@@ -162,7 +242,7 @@ foo = Foo.new(Bar.new(Baz.new))
 ```
 ###### Example: use result on chain
 
-1. **String**  
+1. **_String_**  
   Can use bar instance in backward!
   ```ruby
   chain = PullChain.new(foo) << "bar/baz/say(bar.speaker, 'Good!')"
@@ -175,14 +255,14 @@ foo = Foo.new(Bar.new(Baz.new))
   chain.call # => Julian said 'Cool'
   ```
 
-2. **Array**  
-  Can access result by Proc.
+2. **_Array_**  
+  Can access result by *Proc*.
   ```ruby
   chain = PullChain.new(foo) << :bar << :baz
   chain << [:say, Proc.new { next bar.speaker, "Oh" }]
   chain.call # => Julian said 'Oh'
   ```
-  Case of use a lambda, can use result access object explicit.
+  Case of use a *lambda*, can use result access object explicit.
   ```ruby
   chain = PullChain.new(foo) << :bar << :baz
   arg_reader = lambda { |accessor| next accessor.bar.speaker, "Oh" }
@@ -198,7 +278,7 @@ foo = Foo.new(Bar.new(Baz.new))
   chain.call # => AC/DC
   ```
 
-2. **Use return_nil_at_error= method, then can ignore error**
+2. **Use *return_nil_at_error=*, then can ignore error**
   ```ruby
   chain = PullChain.new("Test") << :xxx
   begin
@@ -210,14 +290,14 @@ foo = Foo.new(Bar.new(Baz.new))
   ```
 
 3. **Note:use operator in chain**
-  * **String type chain**
+  * **_String_ type chain**
     ```ruby
     table = {name: %w(Bill Scott Paul)}
     PullChain.new(table, "[:name]").call # => [:name] NG
     PullChain.new(table, "self[:name]").call # => ["Bill", "Scott", "Paul"] OK
     ```
 
-  * **Array type chain**
+  * **_Array_ type chain**
     ```ruby
     PullChain.new(table, [:[], [:name]]).call # OK
     ```
@@ -236,7 +316,7 @@ foo = Foo.new(Bar.new(Baz.new))
     PullChain.new(%w(Donald Walter), "self[1]").call # OK => Walter
     ```
 
-4. **Some classes, such Fixnum and Bignum not supported**  
+4. **Some classes, such *Fixnum* and *Bignum* not supported**  
   ```ruby
   PullChain.new(999999999999999, "self % 2").call # NG
   ```
@@ -244,7 +324,7 @@ foo = Foo.new(Bar.new(Baz.new))
 ---
 ## RelayChain
 RelayChain is object like a connect to function's input from function's output.  
-(methods well as can connect Proc.)
+(methods well as can connect *Proc*.)
 
 ### Example
 ```ruby
@@ -274,27 +354,50 @@ chain.call("Hello") # => { ( Hello ) }
   chain.call("Hello")
   ```
 
-3. **Use Method object**
+3. **Use *Method* object**
   ```ruby
   chain = RelayChain.new
   chain >> decorator.method(:decorate1) >> decorator.method(:decorate2)
   chain.call("Hello")
   ```
 
-4. **Use add method**
+4. **Use _add_**
   ```ruby
+  chain = RelayChain.new(Decorator.new)
   chain.add(:decorate1).add(:decorate2).call("Hello")
   ```
 
-5. **Use add_all method**
+5. **Use _add_all_**
   ```ruby
+  chain = RelayChain.new(Decorator.new)
   chain.add_all(:decorate1, :decorate2).call("Hello")
   ```
 
-#### Insert, Delete, Clear
-insert, insert_all method is insert function to chain.  
-delete_at method is delete function from chain.  
-clear method is delete all function from chain.
+#### Insert
+*insert*, *insert_all* is insert function to chain.
+```ruby
+chain = RelayChain.new(Decorator.new, :decorate2)
+chain.insert(0, :decorate1)
+chain.call("Hello") # => { ( Hello ) }
+
+chain = RelayChain.new(Decorator.new)
+chain.insert_all(0, :decorate1, :decorate2)
+chain.call("Hello") # => { ( Hello ) }
+```
+#### Delete
+*delete_at* is delete function from chain.
+```ruby
+chain = RelayChain.new(Decorator.new, :decorate1, :decorate2)
+chain.delete_at(0)
+chain.call("Hello") # => { Hello }
+```
+#### Clear
+*clear* is delete all function from chain.
+```ruby
+chain = RelayChain.new(Decorator.new, :decorate1, :decorate2)
+chain.clear
+chain.call("Hello") # => nil
+```
 
 ### How to connect method of differed instance
 Example, following two class.  
@@ -316,7 +419,7 @@ class Decorator2
 end
 ```
 ###### Solution
-1. **Array, format is [instance, Symbol or String of method]**
+1. **_Array_, format is [instance, _Symbol_ or _String_ of method]**
   ```ruby
   # Symbol ver.
   chain = RelayChain.new(Decorator.new)
@@ -329,7 +432,7 @@ end
   chain.call("Hello") # => [ { ( Hello ) } ]
   ```
 
-2. **String, use registered instance**
+2. **_String_, use registered instance**
   ```ruby
   chain = RelayChain.new(Decorator.new)
 
@@ -370,7 +473,7 @@ end
   chain.call("Emerson, Lake") # => Emerson, Lake And Palmer
   ```
 
-2. **Add lambda or Proc to between these methods.**  
+2. **Add *lambda* or *Proc* to between these methods.**  
   lambda's format is following.
   ```ruby
   # parameter: chain is chain object.  
@@ -385,9 +488,15 @@ end
   chain >> :decorate >> arg_adder >> :union
   chain.call("Tom") # => Tom And Jerry
   ```
+  can write as follows by *add* with block.
+  ```ruby
+  chain = RelayChain.new(Decorator.new)
+  chain.add(:decorate).add { |chain, value| chain.call(value, "Jerry") }.add(:union)
+  chain.call("Tom") # => Tom And Jerry
+  ```
 
 ### Appendix
-**Chain stop by means of lambda.**
+**Chain stop by means of *lambda*.**
 ```ruby
 class Decorator
   def decorate1(value)

data/function_chain.gemspec

@@ -9,11 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Kenji Suzuki"]
   spec.email         = ["pujoheadsoft@gmail.com"]
   spec.summary       = "FunctionChain objectifies of the method chain."
-  spec.description   = <<-EOF.gsub(/^\s+|\n/, "")
-    FunctionChain objectifies of the method chain.
-    chain objects can call later or add chain or insert chain or delete chain.
-    supported chain type is following: foo.bar.baz, baz(bar(foo(value))).
-  EOF
+  spec.description   = "FunctionChain objectifies of the method chain. chain objects can call later or add chain or insert chain or delete chain. supported chain type is following: foo.bar.baz, baz(bar(foo(value)))."
   spec.homepage      = "https://github.com/pujoheadsoft/function_chain"
   spec.license       = "MIT"
 

data/lib/function_chain/base_chain.rb

@@ -8,8 +8,10 @@ module FunctionChain
     end
 
     # Add function to chain
-    def add(function)
-      insert(chain_elements.size, function)
+    #
+    # Example: add(value) or add { your code }
+    def add(function = nil, &block)
+      insert(chain_elements.size, function, &block)
     end
 
     # Insert functions to chain
@@ -19,11 +21,14 @@ module FunctionChain
     end
 
     # Insert function to chain
-    def insert(index, function)
-      if function.is_a? String
-        do_insert_by_string(index, function)
-      else
-        do_insert(index, function)
+    #
+    # Example: insert(i, value) or insert(i) { your code }
+    def insert(index, function = nil, &block)
+      validate_exclusive_value(function, block)
+      case function
+      when String then do_insert_by_string(index, function)
+      when NilClass then do_insert(index, block)
+      else do_insert(index, function)
       end
       self
     end
@@ -37,6 +42,7 @@ module FunctionChain
     # Clear function chain
     def clear
       chain_elements.clear
+      self
     end
 
     def to_s
@@ -65,11 +71,11 @@ module FunctionChain
       when Symbol then create_chain_element_by_symbol(function)
       when Array then create_chain_element_by_array(function)
       when String then create_chain_element_by_string(function)
-      else
-        fail ArgumentError, <<-EOF.gsub(/^\s+|\n/, "")
+      when Proc then create_chain_element_by_proc(function)
+      else fail ArgumentError, <<-EOF.gsub(/^\s+|\n/, "")
         Not supported type #{function}(#{function.class}),
         supported type is #{supported_types}.
-        EOF
+      EOF
       end
     end
 
@@ -104,7 +110,19 @@ module FunctionChain
     end
 
     def supported_types
-      [Symbol, Array, String]
+      [Symbol, Array, String, Proc]
+    end
+
+    def validate_exclusive_value(function, block)
+      prefix = nil
+      if function.nil? && block.nil?
+        prefix = "Both value and the block is unspecified."
+      elsif function && block
+        prefix = "Both of value and block is specified."
+      end
+      if prefix
+        fail ArgumentError, "#{prefix} Please specify either value or block."
+      end
     end
   end
 end

data/lib/function_chain/pull_chain.rb

@@ -247,6 +247,12 @@ module FunctionChain
       end
     end
 
+    def create_chain_element_by_proc(proc)
+      create_common_chain_element do |receiver|
+        next "#{proc}", receiver.instance_eval(&proc)
+      end
+    end
+
     def execute(receiver, name, *args, &block)
       receiver.__send__(name, *args, &block)
     end

data/lib/function_chain/relay_chain.rb

@@ -193,7 +193,7 @@ module FunctionChain
     protected
 
     def supported_types
-      super() | [Method, Proc]
+      super() | [Method]
     end
 
     private
@@ -201,7 +201,6 @@ module FunctionChain
     def create_chain_element(function)
       case function
       when Method then create_chain_element_by_method(function)
-      when Proc then function
       else super(function)
       end
     end
@@ -242,6 +241,10 @@ module FunctionChain
       end
     end
 
+    def create_chain_element_by_proc(proc)
+      proc
+    end
+
     def receiver_table
       @receiver_table ||= {}
     end

data/lib/function_chain/version.rb

@@ -1,3 +1,3 @@
 module FunctionChain
-  VERSION = "0.0.2"
+  VERSION = "1.0.0"
 end

data/spec/function_chain_spec.rb

@@ -116,6 +116,21 @@ describe FunctionChain::PullChain do
     expect(chain.call).to eq("AC".concat("/DC"))
   end
 
+  it "[success case] proc type function" do
+    chain = PullChain.new(@city) << Proc.new { bookstore }
+    chain << Proc.new { shelves[:programing] } << Proc.new { books[1] }
+    chain << Proc.new { title }
+    title = @city.bookstore.shelves[:programing].books[1].title
+    expect(chain.call).to eq(title)
+  end
+
+  it "[success case] block type function" do
+    chain = PullChain.new(@city).add { bookstore }
+    chain.add { shelves[:programing] }.add { books[1] }.add { title }
+    title = @city.bookstore.shelves[:programing].books[1].title
+    expect(chain.call).to eq(title)
+  end
+
   it "[success case] mix type string, symbol, array" do
     chain = PullChain.new(@city)
     chain.add_all(:bookstore, "shelves[:programing]")
@@ -124,14 +139,21 @@ describe FunctionChain::PullChain do
     expect(chain.call).to eq(title)
   end
 
-  it "[success case] insert_all" do
+  it "[success case] insert" do
     chain = PullChain.new(@city, "/bookstore/shelves[:programing]/title")
     chain.insert(2, "books[1]")
     title = @city.bookstore.shelves[:programing].books[1].title
     expect(chain.call).to eq(title)
   end
 
-  it "[success case] inserts" do
+  it "[success case] insert block" do
+    chain = PullChain.new(@city, "/bookstore/shelves[:programing]/title")
+    chain.insert(2) { books[1] }
+    title = @city.bookstore.shelves[:programing].books[1].title
+    expect(chain.call).to eq(title)
+  end
+
+  it "[success case] insert_all" do
     chain = PullChain.new(@city, "/bookstore/title")
     chain.insert_all(1, "shelves[:programing]", "books[1]")
     title = @city.bookstore.shelves[:programing].books[1].title
@@ -224,6 +246,38 @@ describe FunctionChain::PullChain do
     end.to raise_error(ArgumentError)
   end
 
+  it "[fail case] add empty" do
+    msg = "Both value and the block is unspecified. " \
+          "Please specify either value or block."
+    expect do
+      PullChain.new(@city).add
+    end.to raise_error(ArgumentError, msg)
+  end
+
+  it "[fail case] add both arg & block" do
+    msg = "Both of value and block is specified. " \
+          "Please specify either value or block."
+    expect do
+      PullChain.new(@city).add(:bookstore) {}
+    end.to raise_error(ArgumentError, msg)
+  end
+
+  it "[fail case] insert empty" do
+    msg = "Both value and the block is unspecified. " \
+          "Please specify either value or block."
+    expect do
+      PullChain.new(@city).insert(0)
+    end.to raise_error(ArgumentError, msg)
+  end
+
+  it "[fail case] insert both arg & block" do
+    msg = "Both of value and block is specified. " \
+          "Please specify either value or block."
+    expect do
+      PullChain.new(@city).insert(0, :bookstore) {}
+    end.to raise_error(ArgumentError, msg)
+  end
+
   %w(! " ' # % & ( ) = ~ \\ ` @ [ ] * + < > ? 1 ; : . , ^).each do |e|
     it "[fail case] ArgumentError:wrong format variable define #{e}" do
       expect do
@@ -231,7 +285,6 @@ describe FunctionChain::PullChain do
       end.to raise_error(ArgumentError)
     end
   end
-
 end
 
 describe FunctionChain::RelayChain do
@@ -379,6 +432,15 @@ describe FunctionChain::RelayChain do
     expect(chain.call(array)).to eq(value)
   end
 
+  it "[success case] use block" do
+    chain = RelayChain.new
+    chain.add { |c, arr| c.call(arr.select(&:even?)) }
+    chain.add { |_, arr| arr.map { |num| num * 10 } }
+    array = [1, 2, 3, 4, 5]
+    value = array.select(&:even?).map { |num| num * 10 }
+    expect(chain.call(array)).to eq(value)
+  end
+
   it "[success case] stop of chain" do
     chain = RelayChain.new(@decorator)
     chain.add_all(:decorate1, :decorate2, [@enclose_decorator, :decorate])
@@ -388,6 +450,14 @@ describe FunctionChain::RelayChain do
     expect(chain.call("Montgomery")).to eq(decorated_value)
   end
 
+  it "[success case] stop of chain block ver" do
+    chain = RelayChain.new(@decorator)
+    chain.add_all(:decorate1, :decorate2, [@enclose_decorator, :decorate])
+    chain.insert(2) { |_, value| value }
+    decorated_value = @decorator.decorate2(@decorator.decorate1("Montgomery"))
+    expect(chain.call("Montgomery")).to eq(decorated_value)
+  end
+
   it "[success case] to_s" do
     chain = RelayChain.new
     stopper = lambda { |_, value| value }
@@ -414,4 +484,36 @@ describe FunctionChain::RelayChain do
     end.to raise_error(ArgumentError)
   end
 
+  it "[fail case] add empty" do
+    msg = "Both value and the block is unspecified. " \
+          "Please specify either value or block."
+    expect do
+      RelayChain.new(@decorator).add
+    end.to raise_error(ArgumentError, msg)
+  end
+
+  it "[fail case] add both arg & block" do
+    msg = "Both of value and block is specified. " \
+          "Please specify either value or block."
+    expect do
+      RelayChain.new(@decorator).add(:decorate1) {}
+    end.to raise_error(ArgumentError, msg)
+  end
+
+  it "[fail case] insert empty" do
+    msg = "Both value and the block is unspecified. " \
+          "Please specify either value or block."
+    expect do
+      RelayChain.new(@decorator).insert(0)
+    end.to raise_error(ArgumentError, msg)
+  end
+
+  it "[fail case] insert both arg & block" do
+    msg = "Both of value and block is specified. " \
+          "Please specify either value or block."
+    expect do
+      RelayChain.new(@decorator).insert(0, :decorate1) {}
+    end.to raise_error(ArgumentError, msg)
+  end
+
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: function_chain
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors:
 - Kenji Suzuki
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-15 00:00:00.000000000 Z
+date: 2014-10-22 00:00:00.000000000 Z
 dependencies: []
-description: 'FunctionChain objectifies of the method chain.chain objects can call
-  later or add chain or insert chain or delete chain.supported chain type is following:
+description: 'FunctionChain objectifies of the method chain. chain objects can call
+  later or add chain or insert chain or delete chain. supported chain type is following:
   foo.bar.baz, baz(bar(foo(value))).'
 email:
 - pujoheadsoft@gmail.com
@@ -19,11 +19,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .coveralls.yml
-- .gitignore
-- .rspec
-- .rubocop.yml
-- .travis.yml
+- ".coveralls.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -49,12 +49,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.3.5
 requirements: []