otaku 0.2.2 → 0.3.0

data/lib/otaku/handler/processor.rb

@@ -0,0 +1,78 @@
+module Otaku
+  class Handler
+    class Processor #:nodoc:
+
+      extend Forwardable
+      %w{file line code eval!}.each do |meth|
+        def_delegator :@magic_proc, meth.to_sym
+      end
+
+      def initialize(block)
+        @magic_proc = MagicProc.new(block)
+      end
+
+      def marshal_dump
+        [@magic_proc]
+      end
+
+      def marshal_load(data)
+        @magic_proc, _ = data
+      end
+
+      private
+
+        class MagicProc < Handler::MagicProc
+
+          def code_fragments
+            ignore, start_marker, arg =
+              [:ignore, :start_marker, :arg].map{|key| code_match_args[key] }
+            [
+              "proc #{start_marker} |#{arg}| ",
+              source_code.sub(ignore, '')
+            ]
+          end
+
+          def sexp_regexp
+            @cache[:sexp_regexp] ||= (
+              Regexp.new([
+                Regexp.quote("s(:iter, s(:call, nil, :"),
+                "(proc|lambda)",
+                Regexp.quote(", s(:arglist)), s(:lasgn, :#{code_match_args[:arg]}), s("),
+              ].join)
+            )
+          end
+
+          def code_match_args
+            @cache[:code_match_args] ||= (
+              arg_idx, marker_idx = 5, 3
+              args = source_code.match(code_regexp)
+              while args && prob_regexp =~ args[1]
+                arg_idx, marker_idx = 4, 2
+                args = source_code.match(revised_regexp(args[1]))
+              end
+              {
+                :ignore => args[1],
+                :start_marker => args[marker_idx],
+                :arg => args[arg_idx]
+              }
+            )
+          end
+
+          def code_regexp
+            /^(.*?(Otaku\.start.*?|lambda|proc|Proc\.new)\s*(do|\{)\s*(\|(\w+)\|\s*))/m
+          end
+
+          def revised_regexp(e)
+            /^(.*?#{Regexp.quote(e)}.*?\s*(\{|do)\s*(\|(\w+)\|)\s*)/m
+          end
+
+          def prob_regexp
+            /Otaku\.start.*?(lambda|proc|Proc\.new)\s*(\{|do)\s*\|\w+\|\s*$/m
+          end
+
+        end
+
+    end
+  end
+end
+

data/otaku.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{otaku}
-  s.version = "0.2.2"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["NgTzeYang"]
-  s.date = %q{2010-07-21}
+  s.date = %q{2010-08-05}
   s.description = %q{}
   s.email = %q{ngty77@gmail.com}
   s.extra_rdoc_files = [
@@ -28,6 +28,9 @@ Gem::Specification.new do |s|
      "lib/otaku/client.rb",
      "lib/otaku/encoder.rb",
      "lib/otaku/handler.rb",
+     "lib/otaku/handler/context.rb",
+     "lib/otaku/handler/magic_proc.rb",
+     "lib/otaku/handler/processor.rb",
      "lib/otaku/server.rb",
      "otaku.gemspec",
      "spec/handler_spec.rb",
@@ -42,7 +45,12 @@ Gem::Specification.new do |s|
   s.test_files = [
     "spec/integration_spec.rb",
      "spec/handler_spec.rb",
-     "spec/spec_helper.rb"
+     "spec/spec_helper.rb",
+     "examples/unittest/client.rb",
+     "examples/unittest/tests/b_test.rb",
+     "examples/unittest/tests/a_test.rb",
+     "examples/unittest/server.rb",
+     "examples/unittest/server2.rb"
   ]
 
   if s.respond_to? :specification_version then

data/spec/handler_spec.rb

@@ -6,30 +6,830 @@ end
 
 Otaku.instance_eval do
   def start(context = {}, &block)
-    Otaku::Handler.new({}, block)
+    Otaku::Handler.new(context, block)
+  end
+end
+
+class Otaku::Handler::Context
+  alias_method :orig_magic_proc, :magic_proc
+  attr_reader :magic_procs
+  def magic_proc(val)
+    (@magic_procs ||= []) << orig_magic_proc(val)
+    @magic_procs.last
   end
 end
 
 describe "Otaku Service Handler" do
 
-  describe '>> initializing context' do
+  describe '>> initializing @context' do
 
     should 'assign to empty anoynmous class instance code when given {}' do
-      Otaku::Handler.new({}, lambda{}).context.should.equal('Class.new{  }.new')
+      Otaku::Handler.new({}, lambda{}).context.code.should.equal('Class.new{  }.new')
     end
 
     should 'assign to non-empty anoynmous class instance code when given {:m1 => v1, :m2 => v2, ...}' do
       encode = lambda{|val| Otaku::Encoder.encode(val).gsub('|','\|') }
-      Otaku::Handler.new({:m1 => 'v|1', :m2 => 'v|2'}, lambda{}).context.should.equal(
+      Otaku::Handler.new({:m1 => 'v|1', :m2 => 'v|2'}, lambda{}).context.code.should.equal(
         'Class.new{ %s; %s }.new' % [
           "def m1; Encoder.decode(%|#{encode['v|1']}|); end",
           "def m2; Encoder.decode(%|#{encode['v|2']}|); end"
       ])
     end
 
+    describe '>>> handling serializing of proc variable' do
+
+      class << self
+
+        def new_otaku_handler(*args, &block)
+          Otaku::Handler.new({:processor => block}, lambda{})
+        end
+
+        def should_have_expected_context(context, code, line)
+          context.magic_procs[0].code.should.equal(code)
+          context.magic_procs[0].file.should.equal(File.expand_path(__FILE__))
+          context.magic_procs[0].line.should.equal(line)
+        end
+
+      end
+
+      no_arg_expected = "lambda { [\"a\", \"b\"].map { |x| puts(x) } }"
+      single_arg_expected = "lambda { |arg| [\"a\", \"b\"].map { |x| puts(x) } }"
+      multiple_args_expected = "lambda { |arg1, arg2| [\"a\", \"b\"].map { |x| puts(x) } }"
+      unlimited_args_expected = "lambda { |*args| [\"a\", \"b\"].map { |x| puts(x) } }"
+
+      {
+      # ////////////////////////////////////////////////////////////////////////
+      # >> Always newlinling (single arg)
+      # ////////////////////////////////////////////////////////////////////////
+        __LINE__ => [
+          lambda do |arg|
+            %w{a b}.map do |x|
+              puts x
+            end
+          end,
+          single_arg_expected
+        ],
+        __LINE__ => [
+          lambda { |arg|
+            %w{a b}.map{|x|
+              puts x
+            }
+          },
+          single_arg_expected
+        ],
+        __LINE__ => [
+          proc do |arg|
+            %w{a b}.map do |x|
+              puts x
+            end
+          end,
+          single_arg_expected
+        ],
+        __LINE__ => [
+          lambda { |arg|
+            %w{a b}.map{|x|
+              puts x
+            }
+          },
+          single_arg_expected
+        ],
+        __LINE__ => [
+          Proc.new do |arg|
+            %w{a b}.map do |x|
+              puts x
+            end
+          end,
+          single_arg_expected
+        ],
+        __LINE__ => [
+          Proc.new { |arg|
+            %w{a b}.map{|x|
+              puts x
+            }
+          },
+          single_arg_expected
+        ],
+      # ////////////////////////////////////////////////////////////////////////
+      # >> Always newlinling (multiple args)
+      # ////////////////////////////////////////////////////////////////////////
+        __LINE__ => [
+          lambda do |arg1, arg2|
+            %w{a b}.map do |x|
+              puts x
+            end
+          end,
+          multiple_args_expected
+        ],
+        __LINE__ => [
+          lambda { |arg1, arg2|
+            %w{a b}.map{|x|
+              puts x
+            }
+          },
+          multiple_args_expected
+        ],
+        __LINE__ => [
+          proc do |arg1, arg2|
+            %w{a b}.map do |x|
+              puts x
+            end
+          end,
+          multiple_args_expected
+        ],
+        __LINE__ => [
+          lambda { |arg1, arg2|
+            %w{a b}.map{|x|
+              puts x
+            }
+          },
+          multiple_args_expected
+        ],
+        __LINE__ => [
+          Proc.new do |arg1, arg2|
+            %w{a b}.map do |x|
+              puts x
+            end
+          end,
+          multiple_args_expected
+        ],
+        __LINE__ => [
+          Proc.new { |arg1, arg2|
+            %w{a b}.map{|x|
+              puts x
+            }
+          },
+          multiple_args_expected
+        ],
+      # ////////////////////////////////////////////////////////////////////////
+      # >> Always newlinling (unlimited args)
+      # ////////////////////////////////////////////////////////////////////////
+        __LINE__ => [
+          lambda do |*args|
+            %w{a b}.map do |x|
+              puts x
+            end
+          end,
+          unlimited_args_expected
+        ],
+        __LINE__ => [
+          lambda { |*args|
+            %w{a b}.map{|x|
+              puts x
+            }
+          },
+          unlimited_args_expected
+        ],
+        __LINE__ => [
+          proc do |*args|
+            %w{a b}.map do |x|
+              puts x
+            end
+          end,
+          unlimited_args_expected
+        ],
+        __LINE__ => [
+          lambda { |*args|
+            %w{a b}.map{|x|
+              puts x
+            }
+          },
+          unlimited_args_expected
+        ],
+        __LINE__ => [
+          Proc.new do |*args|
+            %w{a b}.map do |x|
+              puts x
+            end
+          end,
+          unlimited_args_expected
+        ],
+        __LINE__ => [
+          Proc.new { |*args|
+            %w{a b}.map{|x|
+              puts x
+            }
+          },
+          unlimited_args_expected
+        ],
+      # ////////////////////////////////////////////////////////////////////////
+      # >> Always newlinling (no arg)
+      # ////////////////////////////////////////////////////////////////////////
+        __LINE__ => [
+          lambda do
+            %w{a b}.map do |x|
+              puts x
+            end
+          end,
+          no_arg_expected
+        ],
+        __LINE__ => [
+          lambda {
+            %w{a b}.map{|x|
+              puts x
+            }
+          },
+          no_arg_expected
+        ],
+        __LINE__ => [
+          proc do
+            %w{a b}.map do |x|
+              puts x
+            end
+          end,
+          no_arg_expected
+        ],
+        __LINE__ => [
+          lambda {
+            %w{a b}.map{|x|
+              puts x
+            }
+          },
+          no_arg_expected
+        ],
+        __LINE__ => [
+          Proc.new do
+            %w{a b}.map do |x|
+              puts x
+            end
+          end,
+          no_arg_expected
+        ],
+        __LINE__ => [
+          Proc.new {
+            %w{a b}.map{|x|
+              puts x
+            }
+          },
+          no_arg_expected
+        ],
+      # ////////////////////////////////////////////////////////////////////////
+      # >> Partial newlining (single arg)
+      # ////////////////////////////////////////////////////////////////////////
+        __LINE__ => [
+          lambda do |arg|
+            %w{a b}.map do |x| puts x end
+          end,
+          single_arg_expected
+        ],
+        __LINE__ => [
+          lambda { |arg|
+            %w{a b}.map{|x| puts x }
+          },
+          single_arg_expected
+        ],
+        __LINE__ => [
+          proc do |arg|
+            %w{a b}.map do |x| puts x end
+          end,
+          single_arg_expected
+        ],
+        __LINE__ => [
+          lambda { |arg|
+            %w{a b}.map{|x| puts x }
+          },
+          single_arg_expected
+        ],
+        __LINE__ => [
+          Proc.new do |arg|
+            %w{a b}.map do |x| puts x end
+          end,
+          single_arg_expected
+        ],
+        __LINE__ => [
+          Proc.new { |arg|
+            %w{a b}.map{|x| puts x }
+          },
+          single_arg_expected
+        ],
+      # ////////////////////////////////////////////////////////////////////////
+      # >> Partial newlining (multiple args)
+      # ////////////////////////////////////////////////////////////////////////
+        __LINE__ => [
+          lambda do |arg1, arg2|
+            %w{a b}.map do |x| puts x end
+          end,
+          multiple_args_expected
+        ],
+        __LINE__ => [
+          lambda { |arg1, arg2|
+            %w{a b}.map{|x| puts x }
+          },
+          multiple_args_expected
+        ],
+        __LINE__ => [
+          proc do |arg1, arg2|
+            %w{a b}.map do |x| puts x end
+          end,
+          multiple_args_expected
+        ],
+        __LINE__ => [
+          lambda { |arg1, arg2|
+            %w{a b}.map{|x| puts x }
+          },
+          multiple_args_expected
+        ],
+        __LINE__ => [
+          Proc.new do |arg1, arg2|
+            %w{a b}.map do |x| puts x end
+          end,
+          multiple_args_expected
+        ],
+        __LINE__ => [
+          Proc.new { |arg1, arg2|
+            %w{a b}.map{|x| puts x }
+          },
+          multiple_args_expected
+        ],
+      # ////////////////////////////////////////////////////////////////////////
+      # >> Partial newlining (unlimited args)
+      # ////////////////////////////////////////////////////////////////////////
+        __LINE__ => [
+          lambda do |*args|
+            %w{a b}.map do |x| puts x end
+          end,
+          unlimited_args_expected
+        ],
+        __LINE__ => [
+          lambda { |*args|
+            %w{a b}.map{|x| puts x }
+          },
+          unlimited_args_expected
+        ],
+        __LINE__ => [
+          proc do |*args|
+            %w{a b}.map do |x| puts x end
+          end,
+          unlimited_args_expected
+        ],
+        __LINE__ => [
+          lambda { |*args|
+            %w{a b}.map{|x| puts x }
+          },
+          unlimited_args_expected
+        ],
+        __LINE__ => [
+          Proc.new do |*args|
+            %w{a b}.map do |x| puts x end
+          end,
+          unlimited_args_expected
+        ],
+        __LINE__ => [
+          Proc.new { |*args|
+            %w{a b}.map{|x| puts x }
+          },
+          unlimited_args_expected
+        ],
+      # ////////////////////////////////////////////////////////////////////////
+      # >> Partial newlining (no args)
+      # ////////////////////////////////////////////////////////////////////////
+        __LINE__ => [
+          lambda do
+            %w{a b}.map do |x| puts x end
+          end,
+          no_arg_expected
+        ],
+        __LINE__ => [
+          lambda {
+            %w{a b}.map{|x| puts x }
+          },
+          no_arg_expected
+        ],
+        __LINE__ => [
+          proc do
+            %w{a b}.map do |x| puts x end
+          end,
+          no_arg_expected
+        ],
+        __LINE__ => [
+          lambda {
+            %w{a b}.map{|x| puts x }
+          },
+          no_arg_expected
+        ],
+        __LINE__ => [
+          Proc.new do
+            %w{a b}.map do |x| puts x end
+          end,
+          no_arg_expected
+        ],
+        __LINE__ => [
+          Proc.new {
+            %w{a b}.map{|x| puts x }
+          },
+          no_arg_expected
+        ],
+      # ////////////////////////////////////////////////////////////////////////
+      # >> No newlining (single arg)
+      # ////////////////////////////////////////////////////////////////////////
+        __LINE__ => [
+          lambda do |arg| %w{a b}.map do |x| puts x end end,
+          single_arg_expected
+        ],
+        __LINE__ => [
+          lambda { |arg| %w{a b}.map{|x| puts x } },
+          single_arg_expected
+        ],
+        __LINE__ => [
+          proc do |arg| %w{a b}.map do |x| puts x end end,
+          single_arg_expected
+        ],
+        __LINE__ => [
+          lambda { |arg| %w{a b}.map{|x| puts x } },
+          single_arg_expected
+        ],
+        __LINE__ => [
+          Proc.new do |arg| %w{a b}.map do |x| puts x end end,
+          single_arg_expected
+        ],
+        __LINE__ => [
+          Proc.new { |arg| %w{a b}.map{|x| puts x } },
+          single_arg_expected
+        ],
+      # ////////////////////////////////////////////////////////////////////////
+      # >> No newlining (multiple args)
+      # ////////////////////////////////////////////////////////////////////////
+        __LINE__ => [
+          lambda do |arg1, arg2| %w{a b}.map do |x| puts x end end,
+          multiple_args_expected
+        ],
+        __LINE__ => [
+          lambda { |arg1, arg2| %w{a b}.map{|x| puts x } },
+          multiple_args_expected
+        ],
+        __LINE__ => [
+          proc do |arg1, arg2| %w{a b}.map do |x| puts x end end,
+          multiple_args_expected
+        ],
+        __LINE__ => [
+          lambda { |arg1, arg2| %w{a b}.map{|x| puts x } },
+          multiple_args_expected
+        ],
+        __LINE__ => [
+          Proc.new do |arg1, arg2| %w{a b}.map do |x| puts x end end,
+          multiple_args_expected
+        ],
+        __LINE__ => [
+          Proc.new { |arg1, arg2| %w{a b}.map{|x| puts x } },
+          multiple_args_expected
+        ],
+      # ////////////////////////////////////////////////////////////////////////
+      # >> No newlining (unlimited args)
+      # ////////////////////////////////////////////////////////////////////////
+        __LINE__ => [
+          lambda do |*args| %w{a b}.map do |x| puts x end end,
+          unlimited_args_expected
+        ],
+        __LINE__ => [
+          lambda { |*args| %w{a b}.map{|x| puts x } },
+          unlimited_args_expected
+        ],
+        __LINE__ => [
+          proc do |*args| %w{a b}.map do |x| puts x end end,
+          unlimited_args_expected
+        ],
+        __LINE__ => [
+          lambda { |*args| %w{a b}.map{|x| puts x } },
+          unlimited_args_expected
+        ],
+        __LINE__ => [
+          Proc.new do |*args| %w{a b}.map do |x| puts x end end,
+          unlimited_args_expected
+        ],
+        __LINE__ => [
+          Proc.new { |*args| %w{a b}.map{|x| puts x } },
+          unlimited_args_expected
+        ],
+      # ////////////////////////////////////////////////////////////////////////
+      # >> No newlining (no args)
+      # ////////////////////////////////////////////////////////////////////////
+        __LINE__ => [
+          lambda do %w{a b}.map do |x| puts x end end,
+          no_arg_expected
+        ],
+        __LINE__ => [
+          lambda { %w{a b}.map{|x| puts x } },
+          no_arg_expected
+        ],
+        __LINE__ => [
+          proc do %w{a b}.map do |x| puts x end end,
+          no_arg_expected
+        ],
+        __LINE__ => [
+          lambda { %w{a b}.map{|x| puts x } },
+          no_arg_expected
+        ],
+        __LINE__ => [
+          Proc.new do %w{a b}.map do |x| puts x end end,
+          no_arg_expected
+        ],
+        __LINE__ => [
+          Proc.new { %w{a b}.map{|x| puts x } },
+          no_arg_expected
+        ],
+      }.each do |debug, (block, expected)|
+        should "handle proc variable [##{debug}]" do
+          magic_proc = Otaku::Handler::MagicProc.new(block)
+          encoded = Otaku::Encoder.encode(magic_proc).gsub('|','\|')
+          context = Otaku::Handler.new({:processor => block}, lambda{}).context
+          context.code.should.equal \
+            'Class.new{ %s }.new' % "def processor; Encoder.decode(%|#{encoded}|).eval!; end"
+          should_have_expected_context(context, expected, debug.succ)
+        end
+      end
+
+      # No args
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler(1, 2) do
+            %w{a b}.map{|x| puts x }
+          end
+        ).context, no_arg_expected, __LINE__ - 3)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler do
+            %w{a b}.map{|x| puts x }
+          end
+        ).context, no_arg_expected, __LINE__ - 3)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler 1, 2 do
+            %w{a b}.map{|x| puts x }
+          end
+        ).context, no_arg_expected, __LINE__ - 3)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler(1, 2) do %w{a b}.map{|x| puts x } end
+        ).context, no_arg_expected, __LINE__ - 1)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler do %w{a b}.map{|x| puts x } end
+        ).context, no_arg_expected, __LINE__ - 1)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler 1, 2 do %w{a b}.map{|x| puts x } end
+        ).context, no_arg_expected, __LINE__ - 1)
+      end
+
+      should "handle block using { ... } [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler(1, 2) {
+            %w{a b}.map{|x| puts x }
+          }
+        ).context, no_arg_expected, __LINE__ - 3)
+      end
+
+      should "handle block using { ... } [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler {
+            %w{a b}.map{|x| puts x }
+          }
+        ).context, no_arg_expected, __LINE__ - 3)
+      end
+
+      should "handle block using { ... } [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler(1, 2) { %w{a b}.map{|x| puts x } }
+        ).context, no_arg_expected, __LINE__ - 1)
+      end
+
+      should "handle block using { ... } [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler { %w{a b}.map{|x| puts x } }
+        ).context, no_arg_expected, __LINE__ - 1)
+      end
+
+      # Single arg
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler(1, 2) do |arg|
+            %w{a b}.map{|x| puts x }
+          end
+        ).context, single_arg_expected, __LINE__ - 3)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler do |arg|
+            %w{a b}.map{|x| puts x }
+          end
+        ).context, single_arg_expected, __LINE__ - 3)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler 1, 2 do |arg|
+            %w{a b}.map{|x| puts x }
+          end
+        ).context, single_arg_expected, __LINE__ - 3)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler(1, 2) do |arg| %w{a b}.map{|x| puts x } end
+        ).context, single_arg_expected, __LINE__ - 1)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler do |arg| %w{a b}.map{|x| puts x } end
+        ).context, single_arg_expected, __LINE__ - 1)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler 1, 2 do |arg| %w{a b}.map{|x| puts x } end
+        ).context, single_arg_expected, __LINE__ - 1)
+      end
+
+      should "handle block using { ... } [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler(1, 2) { |arg|
+            %w{a b}.map{|x| puts x }
+          }
+        ).context, single_arg_expected, __LINE__ - 3)
+      end
+
+      should "handle block using { ... } [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler { |arg|
+            %w{a b}.map{|x| puts x }
+          }
+        ).context, single_arg_expected, __LINE__ - 3)
+      end
+
+      should "handle block using { ... } [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler(1, 2) { |arg| %w{a b}.map{|x| puts x } }
+        ).context, single_arg_expected, __LINE__ - 1)
+      end
+
+      should "handle block using { ... } [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler { |arg| %w{a b}.map{|x| puts x } }
+        ).context, single_arg_expected, __LINE__ - 1)
+      end
+
+      # Multiple args
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler(1, 2) do |arg1, arg2|
+            %w{a b}.map{|x| puts x }
+          end
+        ).context, multiple_args_expected, __LINE__ - 3)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler do |arg1, arg2|
+            %w{a b}.map{|x| puts x }
+          end
+        ).context, multiple_args_expected, __LINE__ - 3)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler 1, 2 do |arg1, arg2|
+            %w{a b}.map{|x| puts x }
+          end
+        ).context, multiple_args_expected, __LINE__ - 3)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler(1, 2) do |arg1, arg2| %w{a b}.map{|x| puts x } end
+        ).context, multiple_args_expected, __LINE__ - 1)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler do |arg1, arg2| %w{a b}.map{|x| puts x } end
+        ).context, multiple_args_expected, __LINE__ - 1)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler 1, 2 do |arg1, arg2| %w{a b}.map{|x| puts x } end
+        ).context, multiple_args_expected, __LINE__ - 1)
+      end
+
+      should "handle block using { ... } [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler(1, 2) { |arg1, arg2|
+            %w{a b}.map{|x| puts x }
+          }
+        ).context, multiple_args_expected, __LINE__ - 3)
+      end
+
+      should "handle block using { ... } [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler { |arg1, arg2|
+            %w{a b}.map{|x| puts x }
+          }
+        ).context, multiple_args_expected, __LINE__ - 3)
+      end
+
+      should "handle block using { ... } [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler(1, 2) { |arg1, arg2| %w{a b}.map{|x| puts x } }
+        ).context, multiple_args_expected, __LINE__ - 1)
+      end
+
+      should "handle block using { ... } [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler { |arg1, arg2| %w{a b}.map{|x| puts x } }
+        ).context, multiple_args_expected, __LINE__ - 1)
+      end
+
+      # Unlimited args
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler(1, 2) do |*args|
+            %w{a b}.map{|x| puts x }
+          end
+        ).context, unlimited_args_expected, __LINE__ - 3)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler do |*args|
+            %w{a b}.map{|x| puts x }
+          end
+        ).context, unlimited_args_expected, __LINE__ - 3)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler 1, 2 do |*args|
+            %w{a b}.map{|x| puts x }
+          end
+        ).context, unlimited_args_expected, __LINE__ - 3)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler(1, 2) do |*args| %w{a b}.map{|x| puts x } end
+        ).context, unlimited_args_expected, __LINE__ - 1)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler do |*args| %w{a b}.map{|x| puts x } end
+        ).context, unlimited_args_expected, __LINE__ - 1)
+      end
+
+      should "handle block using do ... end [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler 1, 2 do |*args| %w{a b}.map{|x| puts x } end
+        ).context, unlimited_args_expected, __LINE__ - 1)
+      end
+
+      should "handle block using { ... } [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler(1, 2) { |*args|
+            %w{a b}.map{|x| puts x }
+          }
+        ).context, unlimited_args_expected, __LINE__ - 3)
+      end
+
+      should "handle block using { ... } [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler { |*args|
+            %w{a b}.map{|x| puts x }
+          }
+        ).context, unlimited_args_expected, __LINE__ - 3)
+      end
+
+      should "handle block using { ... } [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler(1, 2) { |*args| %w{a b}.map{|x| puts x } }
+        ).context, unlimited_args_expected, __LINE__ - 1)
+      end
+
+      should "handle block using { ... } [##{__LINE__}]" do
+        should_have_expected_context((
+          new_otaku_handler { |*args| %w{a b}.map{|x| puts x } }
+        ).context, unlimited_args_expected, __LINE__ - 1)
+      end
+
+    end
+
   end
 
-  describe '>> initializing proc' do
+  describe '>> initializing @processor' do
 
     expected = "lambda { |watever| [\"a\", \"b\"].map { |x| puts(x) } }"
 
@@ -135,7 +935,7 @@ describe "Otaku Service Handler" do
       ),
     }.each do |debug, block|
       should "handle proc as variable [##{debug}]" do
-        Otaku::Handler.new({}, block).proc.should.equal(expected)
+        Otaku::Handler.new({}, block).processor.code.should.equal(expected)
       end
     end
 
@@ -144,7 +944,7 @@ describe "Otaku Service Handler" do
         %w{a b}.map do |x|
           puts x
         end
-      end.proc.should.equal(expected)
+      end.processor.code.should.equal(expected)
     end
 
     should "handle block using do ... end [##{__LINE__}]" do
@@ -152,29 +952,29 @@ describe "Otaku Service Handler" do
         %w{a b}.map do |x|
           puts x
         end
-      end.proc.should.equal(expected)
+      end.processor.code.should.equal(expected)
     end
 
     should "handle block using do ... end [##{__LINE__}]" do
       Otaku.start({}) do |watever|
         %w{a b}.map do |x| puts x end
-      end.proc.should.equal(expected)
+      end.processor.code.should.equal(expected)
     end
 
     should "handle block using do ... end [##{__LINE__}]" do
       Otaku.start do |watever|
         %w{a b}.map do |x| puts x end
-      end.proc.should.equal(expected)
+      end.processor.code.should.equal(expected)
     end
 
     should "handle block using do ... end [##{__LINE__}]" do
       Otaku.start({}) do |watever| %w{a b}.map do |x| puts x end end.
-        proc.should.equal(expected)
+        processor.code.should.equal(expected)
     end
 
     should "handle block using do ... end [##{__LINE__}]" do
       Otaku.start do |watever| %w{a b}.map do |x| puts x end end.
-        proc.should.equal(expected)
+        processor.code.should.equal(expected)
     end
 
     should "handle block using { ... } [##{__LINE__}]" do
@@ -182,7 +982,7 @@ describe "Otaku Service Handler" do
         %w{a b}.map do |x|
           puts x
         end
-      }.proc.should.equal(expected)
+      }.processor.code.should.equal(expected)
     end
 
     should "handle block using { ... } [##{__LINE__}]" do
@@ -190,39 +990,111 @@ describe "Otaku Service Handler" do
         %w{a b}.map do |x|
           puts x
         end
-      }.proc.should.equal(expected)
+      }.processor.code.should.equal(expected)
     end
 
     should "handle block using { ... } [##{__LINE__}]" do
       Otaku.start({}) { |watever|
         %w{a b}.map { |x| puts x }
-      }.proc.should.equal(expected)
+      }.processor.code.should.equal(expected)
     end
 
     should "handle block using { ... } [##{__LINE__}]" do
       Otaku.start { |watever|
         %w{a b}.map { |x| puts x }
-      }.proc.should.equal(expected)
+      }.processor.code.should.equal(expected)
     end
 
     should "handle block using { ... } [##{__LINE__}]" do
-      Otaku.start({}) { |watever| %w{a b}.map { |x| puts x } }.proc.should.equal(expected)
+      Otaku.start({}) { |watever| %w{a b}.map { |x| puts x } }.processor.code.should.equal(expected)
     end
 
     should "handle block using { ... } [##{__LINE__}]" do
-      Otaku.start { |watever| %w{a b}.map { |x| puts x } }.proc.should.equal(expected)
+      Otaku.start { |watever| %w{a b}.map { |x| puts x } }.processor.code.should.equal(expected)
     end
 
     should "leave __FILE__ as __FILE__ [##{__LINE__}]" do
-      Otaku.start { |watever| __FILE__ }.proc.should.
+      Otaku.start { |watever| __FILE__ }.processor.code.should.
         equal("lambda { |watever| __FILE__ }" % File.expand_path('spec/handler_spec.rb'))
     end
 
     should "leave __LINE__ as __LINE__ [##{__LINE__}]" do
-      Otaku.start { |watever| __LINE__ }.proc.should.
+      Otaku.start { |watever| __LINE__ }.processor.code.should.
         equal("lambda { |watever| __LINE__ }")
     end
 
+    should "handle block with context variable as proc [##{__LINE__}]" do
+      Otaku.start(:processor => lambda {'dummy'}) { |watever|
+        %w{a b}.map do |x|
+          puts x
+        end
+      }.processor.code.should.equal(expected)
+    end
+
+    should "handle block with context variable as proc [##{__LINE__}]" do
+      Otaku.start(:processor => proc {'dummy'}) { |watever|
+        %w{a b}.map do |x|
+          puts x
+        end
+      }.processor.code.should.equal(expected)
+    end
+
+    should "handle block with context variable as proc [##{__LINE__}]" do
+      Otaku.start(:processor => Proc.new {'dummy'}) { |watever|
+        %w{a b}.map do |x|
+          puts x
+        end
+      }.processor.code.should.equal(expected)
+    end
+
+    should "handle block with context variable as proc [##{__LINE__}]" do
+      Otaku.start(:processor => lambda {'dummy'}) do |watever|
+        %w{a b}.map do |x|
+          puts x
+        end
+      end.processor.code.should.equal(expected)
+    end
+
+    should "handle block with context variable as proc [##{__LINE__}]" do
+      Otaku.start(:processor => proc {'dummy'}) do |watever|
+        %w{a b}.map do |x|
+          puts x
+        end
+      end.processor.code.should.equal(expected)
+    end
+
+    should "handle block with context variable as proc [##{__LINE__}]" do
+      Otaku.start(:processor => proc {|arg| 'dummy'}) do |watever|
+        %w{a b}.map do |x|
+          puts x
+        end
+      end.processor.code.should.equal(expected)
+    end
+
+    should "handle block with context variable as proc [##{__LINE__}]" do
+      Otaku.start(:processor => proc {|arg1, arg2| 'dummy'}) do |watever|
+        %w{a b}.map do |x|
+          puts x
+        end
+      end.processor.code.should.equal(expected)
+    end
+
+    should "handle block with context variable as proc [##{__LINE__}]" do
+      Otaku.start(:processor => proc {|*args| 'dummy'}) do |watever|
+        %w{a b}.map do |x|
+          puts x
+        end
+      end.processor.code.should.equal(expected)
+    end
+
+    should "handle block with context variable as proc [##{__LINE__}]" do
+      Otaku.start(:processor => Proc.new {'dummy'}) do |watever|
+        %w{a b}.map do |x|
+          puts x
+        end
+      end.processor.code.should.equal(expected)
+    end
+
   end
 
   describe '>> fetching root' do
@@ -231,13 +1103,23 @@ describe "Otaku Service Handler" do
     end
   end
 
-  describe '>> processing specified data' do
+  describe '>> processing magic variables' do
+
+    should "reflect __FILE__ captured when the proc was 1st defined [##{__LINE__}]" do
+      Otaku.start(:processor => lambda { __FILE__ }) { |watever| processor.call }.
+        process(:fake_data).should.equal(File.expand_path(__FILE__))
+    end
 
-    should 'reflect __FILE__ captured when the proc was 1st defined' do
+    should "reflect __FILE__ captured when the proc was 1st defined [##{__LINE__}]" do
       Otaku.start{ |watever| __FILE__ }.process(:fake_data).should.equal(File.expand_path(__FILE__))
     end
 
-    should 'reflect __LINE__ captured when the proc was 1st defined' do
+    should "reflect __LINE__ captured when the proc was 1st defined [##{__LINE__}]" do
+      Otaku.start(:processor => lambda { __LINE__ }) { |watever| processor.call }.
+        process(:fake_data).should.equal(__LINE__.pred)
+    end
+
+    should "reflect __LINE__ captured when the proc was 1st defined [##{__LINE__}]" do
       Otaku.start{ |watever| __LINE__ }.process(:fake_data).should.equal(__LINE__)
     end