# File lib/needle/interceptor-chain.rb, line 103
    def build( point, service, interceptors )
      return service if interceptors.nil? || interceptors.empty?

      ordered_list =
        interceptors.sort { |a,b|
          a.options[:priority] <=> b.options[:priority] }

      chain = ProxyObjectChainElement.new( service )

      ordered_list.reverse.each do |interceptor|
        factory = interceptor.action.call( point.container )
        instance = factory.new( point, interceptor.options )
        element = InterceptorChainElement.new( instance )
        element.next = chain
        chain = element
      end

      # FIXME: should inherited methods of "Object" be interceptable?
      methods_to_intercept = ( service.class.instance_methods( true ) -
                               Object.instance_methods +
                               service.class.instance_methods( false ) ).uniq

      service = InterceptedServiceProxy.new( chain )
      singleton = class << service; self; end

      methods_to_intercept.each do |method|
        next if method =~ /^__/

        if singleton.instance_methods(false).include? method
          singleton.send( :remove_method, method )
        end

        singleton.class_eval "def \#{method}( *args, &block )\ncontext = InvocationContext.new( :\#{method}, args, block, Hash.new )\n@chain.process_next( context )\nend\n"
      end

      # allow the interceptor to intercept methods not explicitly
      # declared on the reciever.
      if singleton.instance_methods(false).include? "method_missing"
        singleton.send( :remove_method, :method_missing )
      end

      singleton.class_eval "def method_missing( sym, *args, &block )\ncontext = InvocationContext.new( sym, args, block, Hash.new )\n@chain.process_next( context )\nend\n"

      return service
    end