function_chain 0.0.1

data/lib/function_chain/pull_chain.rb

@@ -0,0 +1,297 @@
+require "function_chain/base_chain"
+
+module FunctionChain
+  # == PullChain
+  # PullChain is object as represent method call chain.
+  # Can inner object's method call of object.
+  #
+  # Chain is object, so can call later.
+  #
+  # Supported call chain type is like a
+  #   account.user.name
+  #
+  # Unsupported call chain type is like a
+  #   filter3(filter2(filter1(value)))
+  # (RelayChain to support such type.)
+  #
+  # === Example
+  #   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.
+  #   # Strings separated by a slash
+  #   PullChain.new(account, "user/name/upcase").call
+  #
+  #   # use << operator.
+  #   chain = PullChain.new(account)
+  #   chain << :user << :name << :upcase
+  #   chain.call
+  #
+  #   # use add method.
+  #   chain.add(:user).add(:name).add(:upcase).call
+  #
+  #   # use add_all method.
+  #   chain.add_all(:user, :name, :upcase).call
+  #
+  # can exist nil value on the way, like a following case.
+  #   user.name = nil
+  #   chain.call # => nil
+  #
+  # 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 is required two arguments.
+  #   class Foo
+  #     def say(speaker, message)
+  #       puts "#{speaker} said '#{message}'"
+  #     end
+  #   end
+  #
+  # Solution1:Array, format is [Symbol, [*Args]].
+  #   chain = PullChain.new(Foo.new) << [:say, ["Andres", "Hello"]]
+  #   chain.call => Andres said 'Hello'
+  #
+  # Solution2:String
+  #   chain = PullChain.new(foo) << "say('John', 'Goodbye')"
+  #   chain.call => John said 'Goodbye'
+  #
+  # === Require block on method
+  # [1,2,3,4,5].inject(3) { |sum, n| sum + n } # => 18
+  #
+  # Solution1:Array, format is [Symbol, [*Args, Proc]].
+  #   chain = PullChain.new([1,2,3,4,5])
+  #   chain << [:inject, [3, lambda { |sum, n| sum + n }]]
+  #   chain.call # => 18
+  #
+  # Solution2:String
+  #   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.
+  # Example1:String
+  #   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))
+  #
+  #   # can use bar instance in backward!
+  #   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.
+  #   chain = PullChain.new(foo) << "@b = bar/baz/say(b.speaker, 'Cool')"
+  #   chain.call # => Julian said 'Cool'
+  #
+  # Example2:Array
+  # can access result by Proc.
+  #   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.
+  #   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
+  # How to use slash in strings separated by a slash.
+  # like following, please escaped by backslash.
+  #   chain = PullChain.new("AC") << "concat '\\/DC'"
+  #   chain.call # => AC/DC
+  #
+  # Use return_nil_at_error= method, then can ignore error.
+  #   chain = PullChain.new("Test") << :xxx
+  #   begin
+  #     chain.call # => undefined method `xxx'
+  #   rescue
+  #   end
+  #   chain.return_nil_at_error = true
+  #   chain.call # => nil
+  #
+  # Note:use operator in string type chain
+  #   table = {name: %w(Bill Scott Paul)}
+  #   PullChain.new(table, "[:name]").call # NG
+  #   PullChain.new(table, "self[:name]").call # OK
+  #   # Array type chain
+  #   PullChain.new(table, [:[], [:name]]).call # OK
+  #
+  # following is also the same.
+  #   # <<operator of String
+  #   PullChain.new("Led", "self << ' Zeppelin'").call
+  #   # []operator of Array
+  #   PullChain.new(%w(Donald Walter), "self[1]").call
+  #
+  # Some classes, such Fixnum and Bignum not supported.
+  #   # NG
+  #   PullChain.new(999999999999999, "self % 2").call
+  #
+  class PullChain < BaseChain
+    attr_writer :return_nil_at_error
+
+    # Initialize chain
+    #
+    # initialize(receiver, *functions)
+    # receiver: starting point of method call.
+    # *functions: more than one symbol, string, array.
+    def initialize(receiver, *functions)
+      @start_receiver = receiver
+      @return_nil_at_error = false
+      add_all(*functions)
+    end
+
+    # Call to all added method.
+    def call
+      @result_accessor = Object.new
+      begin
+        chain_elements.reduce(@start_receiver) do |receiver, chain_element|
+          break receiver if receiver.nil?
+          chain_element.call receiver
+        end
+      rescue
+        raise unless return_nil_at_error?
+      end
+    end
+
+    def return_nil_at_error?
+      @return_nil_at_error
+    end
+
+    private
+
+    attr_accessor :result_accessor
+
+    def create_common_chain_element(&block)
+      lambda do |receiver|
+        name, result = block.call(receiver)
+        define_result_access_method(name, result)
+        result
+      end
+    end
+
+    def define_result_access_method(name, result)
+      result_accessor.singleton_class.class_eval do
+        define_method name do
+          result
+        end
+      end
+    end
+
+    def create_chain_element_by_symbol(symbol)
+      create_common_chain_element do |receiver|
+        next symbol, execute(receiver, symbol)
+      end
+    end
+
+    def create_chain_element_by_array(array)
+      validate_array_length(array, 2, "symbol, [*args] or Proc")
+      validate_element_type_of_array(array, 1, [Array, Proc], "[*args] or Proc")
+
+      do_create_chain_element_by_array(array[0], array[1])
+    end
+
+    def do_create_chain_element_by_array(name, array_function_param)
+      create_common_chain_element do |receiver|
+        args, block = extract_args_and_block(array_function_param)
+        next name, execute(receiver, name, *args, &block)
+      end
+    end
+
+    def extract_args_and_block(array_function_param)
+      if array_function_param.is_a? Proc
+        return result_accessor.instance_eval(&array_function_param)
+      end
+      if array_function_param.last.is_a? Proc
+        return array_function_param[0...-1], array_function_param.last
+      end
+      array_function_param
+    end
+
+    def create_chain_element_by_string(string)
+      name, function = split_to_name_and_function(string)
+      create_common_chain_element do |receiver|
+        next name, execute_by_string(receiver, function)
+      end
+    end
+
+    def split_to_name_and_function(string)
+      name = string
+      function = string
+
+      md = string.match(/^@.+?=/)
+      if md
+        name = md[0][1...-1].strip
+        validate_variable_name_format(name)
+        function = string.sub(md[0], "").strip
+      end
+
+      return name, function
+    end
+
+    def validate_variable_name_format(name)
+      if name =~ /^[^a-zA-Z_]/
+        fail ArgumentError, "wrong format variable defined #{name}"
+      end
+    end
+
+    def execute(receiver, name, *args, &block)
+      receiver.__send__(name, *args, &block)
+    end
+
+    def execute_by_string(receiver, function)
+      begin
+        inject_result_accessor(receiver)
+        receiver.instance_eval(function)
+      rescue => ex
+        raise ex, "#{receiver}.#{function}"
+      ensure
+        eject_result_accessor(receiver)
+      end
+    end
+
+    def inject_result_accessor(receiver)
+      store_method_missing(receiver)
+      define_intercepted_method_missing(receiver)
+    end
+
+    def store_method_missing(receiver)
+      receiver.singleton_class.class_eval do
+        alias_method :original_method_missing, :method_missing
+      end
+    end
+
+    def define_intercepted_method_missing(receiver)
+      # interception method_missing
+      accessor = result_accessor
+      receiver.singleton_class.class_eval do
+        define_method :method_missing do |name, *args, &block|
+          super(name, *args, &block) unless accessor.respond_to? name
+          accessor.send(name, *args, &block)
+        end
+      end
+    end
+
+    def eject_result_accessor(receiver)
+      # cleanup to interception
+      receiver.singleton_class.class_eval do
+        alias_method :method_missing, :original_method_missing
+        undef_method :original_method_missing
+      end
+    end
+
+    alias_method :<<, :add
+  end
+end

data/lib/function_chain/relay_chain.rb

@@ -0,0 +1,251 @@
+require "function_chain/base_chain"
+
+module FunctionChain
+  # == RelayChain
+  # RelayChain is object like a connect to
+  # function's input from function's output.
+  # (methods well as can connect Proc.)
+  #
+  # Chain is object, so can call later.
+  #
+  # Supported call chain type is like a
+  #   filter3(filter2(filter1(value))).
+  #
+  # Unsupported call chain type is like a
+  #   account.user.name
+  # (PullChain to support such type.)
+  #
+  # === Example
+  #   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.
+  #   # Strings separated by a slash
+  #   chain = RelayChain.new(Decorator.new, "decorate1/decorate2")
+  #   chain.call("Hello")
+  #
+  #   # use >> operator.
+  #   chain = RelayChain.new(Decorator.new)
+  #   chain >> :decorate1 >> :decorate2
+  #   chain.call("Hello")
+  #
+  #   # use Method object
+  #   chain = RelayChain.new
+  #   chain >> decorator.method(:decorate1) >> decorator.method(:decorate2)
+  #   chain.call("Hello")
+  #
+  #   # use add method
+  #   chain.add(:decorate1).add(:decorate2).call("Hello")
+  #
+  #   # use add_all method
+  #   chain.add_all(:decorate1, :decorate2).call("Hello")
+  #
+  # 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.
+  # Introduce how to connect method of these class.
+  #   class Decorator
+  #     def decorate1(value) "( #{value} )" end
+  #     def decorate2(value) "{ #{value} }" end
+  #   end
+  #   class Decorator2
+  #     def decorate(value) "[ #{value} ]" end
+  #   end
+  #
+  # Solution1:Array, format is [instance, Symbol or String of method]
+  #   chain = RelayChain.new(Decorator.new)
+  #   chain >> :decorate1 >> :decorate2 >> [Decorator2.new, :decorate]
+  #   # String ver.
+  #   # chain >> :decorate1 >> :decorate2 >> [Decorator2.new, "decorate"]
+  #   chain.call("Hello") # => [ { ( Hello ) } ]
+  #
+  # Solution2:String, use registered instance.
+  #   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?
+  #   class Decorator
+  #     def decorate(value)
+  #       "#{value} And"
+  #     end
+  #     def union(value1, value2)
+  #       "#{value1} #{value2}"
+  #     end
+  #   end
+  #
+  # Solution1:define connect method.
+  #   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
+  #
+  # Solution2:add lambda or Proc to between these methods.
+  #   lambda's format is following.
+  #     lambda {|chain, *args| chain.call(next function's arguments) }.
+  #   lambda's parameter:chain is chain object.
+  #   lambda's parameter:*args is previous function's output.
+  #   can call next function by chain object.
+  #
+  #   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.
+  #
+  #   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 {}
+  #
+  class RelayChain < BaseChain
+    # Initialize chain
+    #
+    # initialize(common_receiver = nil, *functions)
+    # common_receiver:used if the instance is omitted
+    # *functions: more than one symbol, string, array, method, proc
+    def initialize(common_receiver = nil, *functions)
+      @common_receiver = common_receiver
+      @index = 0
+      add_all(*functions)
+    end
+
+    # Call to all added function.
+    def call(*args)
+      begin
+        return if last?
+        chain_element = chain_elements[@index]
+        @index += 1
+        chain_element.call(self, *args)
+      ensure
+        @index = 0
+      end
+    end
+
+    # Whether chain last
+    def last?
+      @index == chain_elements.length
+    end
+
+    # add receiver
+    # use by string type function.
+    #
+    # add_receiver(name, receiver)
+    # name:receiver's name
+    # receiver:register this receiver
+    def add_receiver(name, receiver)
+      receiver_table[name] = receiver
+      self
+    end
+
+    # register name and instance at once.
+    #
+    # add_receiver_table(table)
+    # table:hash {receiver's name as String => receiver, ...}
+    def add_receiver_table(table)
+      receiver_table.merge! table
+      self
+    end
+
+    protected
+
+    def supported_types
+      super() | [Method, Proc]
+    end
+
+    private
+
+    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
+
+    def create_common_chain_element(&block)
+      lambda do |chain, *args|
+        chain.last? ? block.call(*args) : chain.call(*block.call(*args))
+      end
+    end
+
+    def create_chain_element_by_method(method)
+      create_common_chain_element { |*args| method.call(*args) }
+    end
+
+    def create_chain_element_by_array(arr)
+      validate_array_length(arr, 2, "receiver, symbol or string of receiver's method name")
+      validate_element_type_of_array(arr, 1, [Symbol, String], "[Symbol or String]")
+
+      create_common_chain_element { |*args| arr[0].__send__(arr[1], *args) }
+    end
+
+    def create_chain_element_by_symbol(symbol)
+      create_common_chain_element do |*args|
+        @common_receiver.__send__(symbol, *args)
+      end
+    end
+
+    def create_chain_element_by_string(string)
+      create_common_chain_element do |*args|
+        index = string.index(".")
+        if index
+          receiver_key = string[0...index]
+          receiver_method = string[index + 1..-1]
+          receiver_table[receiver_key].send(receiver_method, *args)
+        else
+          @common_receiver.__send__(string, *args)
+        end
+      end
+    end
+
+    def receiver_table
+      @receiver_table ||= {}
+    end
+
+    alias_method :>>, :add
+  end
+end

data/lib/function_chain/version.rb

@@ -0,0 +1,3 @@
+module FunctionChain
+  VERSION = "0.0.1"
+end

data/lib/function_chain.rb

@@ -0,0 +1,13 @@
+require "function_chain/version"
+require "function_chain/pull_chain"
+require "function_chain/relay_chain"
+
+module FunctionChain
+  module_function
+
+  # Shortcut to
+  # PullChain.new(receiver, *functions).call
+  def pull(receiver, *functions)
+    PullChain.new(receiver, *functions).call
+  end
+end