function_chain 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cceaae212ecd1dba66efa5822e61947b5af1bcfa
+  data.tar.gz: 09a02eeac6d159f127d851d615ee543cde23402b
+SHA512:
+  metadata.gz: 05d5b0e5ffae56ce85c88b5459fe7c68580e6872e86e456f2da24a17775c91e4e502905efd14ad8f3df6bd495e39b55b72537a5ce5b415ea63c25f159659a226
+  data.tar.gz: 22c3ec7ae4db1128e6cc75f2580a18345c5b2c8e33a051a22f6b7fa3bf44976ace7eb65253219c9490c1368481a15d395b962060c0dc0d3f037f7e0d962bffb3

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/Guardfile
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+/.idea/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,41 @@
+HashSyntax:
+  EnforcedStyle: ruby19
+  SupportedStyles:
+    - ruby19
+    - hash_rockets
+
+Documentation:
+  Enabled: false
+
+LineLength:
+  Enabled: false
+
+ClassLength:
+  Enabled: false
+
+RegexpLiteral:
+  MaxSlashes: 0
+
+GuardClause:
+  MinBodyLength: 3
+
+TrivialAccessors:
+  AllowPredicates: true
+
+RedundantReturn:
+  AllowMultipleReturnValues: true
+
+RedundantBegin:
+  Enabled: false
+
+SpaceInsideHashLiteralBraces:
+  EnforcedStyle: no_space
+
+Style/Lambda:
+  Enabled: false
+
+Style/Proc:
+  Enabled: false
+
+StringLiterals:
+  EnforcedStyle: double_quotes

data/.travis.yml

@@ -0,0 +1,10 @@
+bundler_args: --without development
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1
+script:  bundle exec rspec
+branches:
+  only:
+    - master

data/Gemfile

@@ -0,0 +1,20 @@
+source "https://rubygems.org"
+
+gem "rake", ">= 0.9"
+gem "rdoc", ">= 3.9"
+
+group :development do
+  gem "guard-rubocop"
+  gem "terminal-notifier-guard"
+  gem "flay"
+  gem "flog"
+end
+
+group :test do
+  gem "coveralls", require: false
+  gem "rubocop", ">= 0.19"
+  gem "rspec", ">= 3"
+  gem "simplecov", ">= 0.9"
+end
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Kenji Suzuki
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,421 @@
+# FunctionChain
+
+[![Build Status](http://img.shields.io/travis/pujoheadsoft/function_chain.svg)][travis]
+[![Coverage Status](http://img.shields.io/coveralls/pujoheadsoft/function_chain.svg)][coveralls]
+[![Code Climate](http://img.shields.io/codeclimate/github/pujoheadsoft/function_chain.svg)][codeclimate]
+
+[travis]: http://travis-ci.org/pujoheadsoft/function_chain
+[coveralls]: https://coveralls.io/r/pujoheadsoft/function_chain
+[codeclimate]: https://codeclimate.com/github/pujoheadsoft/function_chain
+
+## Description
+**FunctionChain** objectifies of the method chain.  
+Chain object can following.
+* Call later.
+* Add method to chain
+* Insert method to chain.
+* Delete method from chain.
+
+## Installation
+    gem install function_chain
+
+## PullChain & RelayChain
+**PullChain & RelayChain** is FunctionChain module's classes.  
+PullChain & RelayChain will support call chain type, each different.
+
+* PullChain to support the call chain type such as the following:
+  ```ruby
+  account.user.name
+  ```
+  If used the PullChain (detail description is [here](#pullchain))
+  ```ruby
+  chain = PullChain.new(account) << :user << :name
+  chain.call
+```
+
+* RelayChain to support the call chain type such as the following:
+  ```ruby
+  filter3(filter2(filter1(value)))
+  ```
+  If used the RelayChain (detail description is [here](#relaychain))
+  ```ruby
+  chain = RelayChain.new >> :filter1 >> :filter2 >> :filter3
+  chain.call("XXX")
+  ```
+
+
+## Usage and documentation
+The following is necessary call to use the PullChain or RelayChain.
+```ruby
+require "function_chain"
+include FunctionChain
+```
+**Note:** This document omit the above code from now on.
+## PullChain
+PullChain is object as represent method call chain.  
+Can inner object's method call of object.
+### Example
+```ruby
+Account = Struct.new(:user)
+User = Struct.new(:name)
+account = Account.new(User.new("Louis"))
+
+chain = PullChain.new(account, :user, :name, :upcase)
+chain.call # => LOUIS
+```
+
+#### Similar
+1. **Strings separated by a slash**
+  ```ruby
+  PullChain.new(account, "user/name/upcase").call
+  ```
+
+2. **Use << operator**
+  ```ruby
+  chain = PullChain.new(account)
+  chain << :user << :name << :upcase
+  chain.call
+  ```
+
+3. **Use add method**
+  ```ruby
+  chain.add(:user).add(:name).add(:upcase).call
+  ```
+
+4. **Use add_all method**
+  ```ruby
+  chain.add_all(:user, :name, :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.
+
+### Require arguments on method
+Following example's method is require two arguments.  
+What should do in this case?
+```ruby
+class Foo
+  def say(speaker, message)
+    puts "#{speaker} said '#{message}'"
+  end
+end
+```
+###### Solution
+1. **Array, format is [Symbol, [\*Args]]**
+  ```ruby
+  chain = PullChain.new(Foo.new) << [:say, ["Andres", "Hello"]]
+  chain.call # => Andres said 'Hello'
+  ```
+
+2. **String**
+  ```ruby
+  chain = PullChain.new(foo) << "say('John', 'Goodbye')"
+  chain.call # => John said 'Goodbye'
+  ```
+
+### Require block on method
+Following example's method is require Block.  
+What should do in this case?
+```ruby
+[1,2,3,4,5].inject(3) { |sum, n| sum + n } # => 18
+```
+
+###### Solution
+
+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**
+  ```ruby
+  chain = PullChain.new([1,2,3,4,5])
+  chain << "inject(3) { |sum, n| sum + n }"
+  chain.call # => 18
+  ```
+
+### Use result on chain
+Like a following example, can use result on chain.
+```ruby
+Foo = Struct.new(:bar)
+Bar = Struct.new(:baz) {
+  def speaker
+    "Julian"
+  end
+}
+class Baz
+  def say(speaker, message)
+    puts "#{speaker} said '#{message}'"
+  end
+end
+foo = Foo.new(Bar.new(Baz.new))
+```
+###### Example: use result on chain
+
+1. **String**  
+  Can use bar instance in backward!
+  ```ruby
+  chain = PullChain.new(foo) << "bar/baz/say(bar.speaker, 'Good!')"
+  chain.call # => Julian said 'Good!'
+  ```
+  Furthermore, can use variable name assigned.  
+  @b is bar instance alias.
+  ```ruby
+  chain = PullChain.new(foo) << "@b = bar/baz/say(b.speaker, 'Cool')"
+  chain.call # => Julian said 'Cool'
+  ```
+
+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.
+  ```ruby
+  chain = PullChain.new(foo) << :bar << :baz
+  arg_reader = lambda { |accessor| next accessor.bar.speaker, "Oh" }
+  chain << [:say, arg_reader]
+  chain.call # => Julian said 'Oh'
+  ```
+
+#### etc
+1. **How to use slash in strings separated by a slash**  
+  Like following, please escaped by backslash.
+  ```ruby
+  chain = PullChain.new("AC") << "concat '\\/DC'"
+  chain.call # => AC/DC
+  ```
+
+2. **Use return_nil_at_error= method, then can ignore error**
+  ```ruby
+  chain = PullChain.new("Test") << :xxx
+  begin
+      chain.call # => undefined method `xxx'
+  rescue
+  end
+  chain.return_nil_at_error = true
+  chain.call # => nil
+  ```
+
+3. **Note:use operator in 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**
+    ```ruby
+    PullChain.new(table, [:[], [:name]]).call # OK
+    ```
+
+  Following is also the same.
+
+  * **<< operator of String**
+    ```ruby
+    PullChain.new("Led", "<< ' Zeppelin'").call # NG syntax error
+    PullChain.new("Led", "self << ' Zeppelin'").call # => "Led Zeppelin"
+    ```
+
+  * **[] operator of Array**
+    ```ruby
+    PullChain.new(%w(Donald Walter), "[1]").call # NG => [1]
+    PullChain.new(%w(Donald Walter), "self[1]").call # OK => Walter
+    ```
+
+4. **Some classes, such Fixnum and Bignum not supported**  
+  ```ruby
+  PullChain.new(999999999999999, "self % 2").call # NG
+  ```
+
+---
+## RelayChain
+RelayChain is object like a connect to function's input from function's output.  
+(methods well as can connect Proc.)
+
+### Example
+```ruby
+class Decorator
+  def decorate1(value)
+    "( #{value} )"
+  end
+  def decorate2(value)
+    "{ #{value} }"
+  end
+end
+
+chain = RelayChain.new(Decorator.new, :decorate1, :decorate2)
+chain.call("Hello") # => { ( Hello ) }
+```
+#### Similar
+1. **Strings separated by a slash**
+  ```ruby
+  chain = RelayChain.new(Decorator.new, "decorate1/decorate2")
+  chain.call("Hello")
+  ```
+
+2. **Use >> operator**
+  ```ruby
+  chain = RelayChain.new(Decorator.new)
+  chain >> :decorate1 >> :decorate2
+  chain.call("Hello")
+  ```
+
+3. **Use Method object**
+  ```ruby
+  chain = RelayChain.new
+  chain >> decorator.method(:decorate1) >> decorator.method(:decorate2)
+  chain.call("Hello")
+  ```
+
+4. **Use add method**
+  ```ruby
+  chain.add(:decorate1).add(:decorate2).call("Hello")
+  ```
+
+5. **Use add_all method**
+  ```ruby
+  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.
+
+### How to connect method of differed instance
+Example, following two class.  
+How to connect method of these class?
+```ruby
+class Decorator
+  def decorate1(value)
+    "( #{value} )"
+  end
+  def decorate2(value)
+    "{ #{value} }"
+  end
+end
+
+class Decorator2
+  def decorate(value)
+    "[ #{value} ]"
+  end
+end
+```
+###### Solution
+1. **Array, format is [instance, Symbol or String of method]**
+  ```ruby
+  # Symbol ver.
+  chain = RelayChain.new(Decorator.new)
+  chain >> :decorate1 >> :decorate2 >> [Decorator2.new, :decorate]
+  chain.call("Hello") # => [ { ( Hello ) } ]
+
+  # String ver.
+  chain = RelayChain.new(Decorator.new)
+  chain >> :decorate1 >> :decorate2 >> [Decorator2.new, "decorate"]
+  chain.call("Hello") # => [ { ( Hello ) } ]
+  ```
+
+2. **String, use registered instance**
+  ```ruby
+  chain = RelayChain.new(Decorator.new)
+
+  # register name and instance
+  chain.add_receiver("d2", Decorator2.new)
+
+  # use registered instance
+  chain >> "/decorate1/decorate2/d2.decorate"
+  chain.call("Hello") # => [ { ( Hello ) } ]
+
+  # add_receiver_table method is register name and instance at once.
+  chain.add_receiver_table({"x" => X.new, "y" => Y.new})
+  ```
+
+### Case of method's output and method's input mismatch
+Following example, decorate output is 1, and union input is 2.  
+How to do connect these methods?
+```ruby
+class Decorator
+  def decorate(value)
+    "#{value} And"
+  end
+  def union(value1, value2)
+    "#{value1} #{value2}"
+  end
+end
+```
+###### Solution
+1. **Define connect method.**
+  ```ruby
+  class Decorator
+    def connect(value)
+      return value, "Palmer"
+    end
+  end
+  chain = RelayChain.new(Decorator.new)
+  chain >> :decorate >> :connect >> :union
+  chain.call("Emerson, Lake") # => Emerson, Lake And Palmer
+  ```
+
+2. **Add lambda or Proc to between these methods.**  
+  lambda's format is following.
+  ```ruby
+  # parameter: chain is chain object.  
+  # parameter: \*args is previous functions output.
+  lambda {|chain, *args| chain.call(next functions arguments) }.
+  ```
+  can call next function by chain object.
+  ```ruby
+  chain = RelayChain.new(Decorator.new)
+  arg_adder = lambda { |chain, value| chain.call(value, "Jerry") }
+  chain >> :decorate >> arg_adder >> :union
+  chain.call("Tom") # => Tom And Jerry
+  ```
+
+### Appendix
+**Chain stop by means of lambda.**
+```ruby
+class Decorator
+  def decorate1(value)
+    "( #{value} )"
+  end
+
+  def decorate2(value)
+    "{ #{value} }"
+  end
+end
+
+def create_stopper(&stop_condition)
+  lambda do |chain, value|
+    # if stop conditions are met then return value
+    if stop_condition.call(value)
+      value
+    else
+      chain.call(value)
+    end
+  end
+end
+
+chain = RelayChain.new(Decorator.new, :decorate1, :decorate2)
+
+# insert_all conditional chain stopper
+chain.insert(1, create_stopper { |value| value =~ /\d/ })
+chain.call("Van Halen 1984") # => ( Van Halen 1984 )     not enclosed to {}
+chain.call("Van Halen Jump") # => { ( Van Halen Jump ) } enclosed to {}
+```
+
+## License
+Released under the MIT License.

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+task default: :spec
+
+task quality: [:flog, :flay]
+
+Dir.glob("tasks/*.rake").each { |each| import each }

data/function_chain.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "function_chain/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "function_chain"
+  spec.version       = FunctionChain::VERSION
+  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.homepage      = "https://github.com/pujoheadsoft/function_chain"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 1.9.3"
+  spec.required_rubygems_version = ">= 1.3.5"
+end

data/lib/function_chain/base_chain.rb

@@ -0,0 +1,110 @@
+module FunctionChain
+  # Base class of PullChain, RelayChain
+  class BaseChain
+    # Add functions to chain
+    def add_all(*functions)
+      insert_all(chain_elements.size, *functions)
+      self
+    end
+
+    # Add function to chain
+    def add(function)
+      insert(chain_elements.size, function)
+    end
+
+    # Insert functions to chain
+    def insert_all(index, *functions)
+      functions.each_with_index { |f, i| insert(index + i, f) }
+      self
+    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)
+      end
+      self
+    end
+
+    # Delete from chain
+    def delete_at(index)
+      chain_elements.delete_at(index)
+      self
+    end
+
+    # Clear function chain
+    def clear
+      chain_elements.clear
+    end
+
+    def to_s
+      "#{self.class}#{chain_elements.map(&:to_s)}"
+    end
+
+    protected
+
+    def do_insert(index, function)
+      chain_element = create_chain_element(function)
+      chain_elements.insert(index, chain_element)
+      def_to_s(chain_element, function)
+    end
+
+    def do_insert_by_string(index, function)
+      function.split(%r{(?<!\\)/}).reject(&:empty?).each_with_index do |f, i|
+        splitted_function = f.gsub(%r{\\/}, "/")
+        chain_element = create_chain_element(splitted_function)
+        chain_elements.insert(index + i, chain_element)
+        def_to_s(chain_element, splitted_function)
+      end
+    end
+
+    def create_chain_element(function)
+      case function
+      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/, "")
+        Not supported type #{function}(#{function.class}),
+        supported type is #{supported_types}.
+        EOF
+      end
+    end
+
+    def def_to_s(target, value)
+      target.singleton_class.class_eval do
+        define_method :to_s do
+          value
+        end
+      end
+    end
+
+    def validate_array_length(arr, expect_length, expect_format)
+      unless expect_length == arr.length
+        message = "Format Wrong #{arr}, expected format is [#{expect_format}]"
+        fail ArgumentError, message
+      end
+    end
+
+    def validate_element_type_of_array(arr, i, expect_types, types_as_string)
+      unless target_is_a_one_of_types?(arr[i], expect_types)
+        fail ArgumentError, "Format Wrong #{arr}," \
+          " second element of array is must be #{types_as_string}"
+      end
+    end
+
+    def target_is_a_one_of_types?(target, types)
+      types.any? { |type| target.is_a? type }
+    end
+
+    def chain_elements
+      @chain_elements ||= []
+    end
+
+    def supported_types
+      [Symbol, Array, String]
+    end
+  end
+end