otaku 0.1.0 → 0.2.0

data/HISTORY.txt

@@ -1,3 +1,18 @@
+=== 0.2.0 2010-07-19
+
+= Features
+* it is now possible to specify which ruby to run the server in [#ngty]
+* officially support MRI-1.8.7, MRI-1.9.1, JRUBY-1.5.1 & REE-1.8.7 [#ngty]
+
+= Maintenance
+* split single file into separate files for readability [#ngty]
+* use RubyParser instead of ParseTree [#ngty]
+
+= Issues
+* magic variable __FILE__ works as expected, but not __LINE__, in fact, __LINE__ reflects the
+  line no starting from the line where the source code is extracted from (not sure if we wanna
+  fix this problem though, unless someone explicitely ask for it)
+
 === 0.1.0 2010-07-18
 
 first gem release! [#ngty]

data/README.rdoc

@@ -56,6 +56,7 @@ Otaku ships with the following defaults:
   Otaku.port            # >> 10999
   Otaku.init_wait_time  # >> 2
   Otaku.log_file        # >> '/tmp/otaku.log'
+  Otaku.ruby            # >> 'ruby' # (the current in-use ruby)
 
 Configuring can be done via:
 

data/Rakefile

@@ -5,7 +5,7 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "otaku"
-    gem.summary = %Q{Dead simple server/client service built using eventmachine}
+    gem.summary = %Q{Dead simple service framework built on eventmachine}
     gem.description = %Q{}
     gem.email = "ngty77@gmail.com"
     gem.homepage = "http://github.com/ngty/otaku"
@@ -13,8 +13,7 @@ begin
     gem.add_development_dependency "bacon", ">= 0"
     gem.add_dependency "eventmachine", ">= 0.12.10"
     gem.add_dependency "ruby2ruby", ">= 1.2.4"
-    # TODO: Should eventually remove requirement for ParseTree !!
-    gem.add_dependency "ParseTree", ">= 3.0.5"
+    gem.add_dependency "ruby_parser", ">= 2.0.4"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/otaku.rb

@@ -3,25 +3,25 @@ require 'eventmachine'
 require 'logger'
 require 'base64'
 require 'ruby2ruby'
+require 'ruby_parser'
 
-# TODO: Preliminary try, should be removed eventually !! Should use RubyParser instead.
-require 'parse_tree'
-require 'parse_tree_extensions'
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'otaku/encoder'
+require 'otaku/handler'
+require 'otaku/server'
+require 'otaku/client'
 
 module Otaku
 
   class HandlerNotDefinedError < Exception ; end
   class DataProcessError < Exception ; end
 
-  # //////////////////////////////////////////////////////////////////////////////////////////
-  # Otaku
-  # //////////////////////////////////////////////////////////////////////////////////////////
-
   DEFAULTS = {
+    :ruby => 'ruby',
     :address => '127.0.0.1',
     :port => 10999,
     :log_file => '/tmp/otaku.log',
-    :init_wait_time => 2
+    :init_wait_time => 2 * (RUBY_PLATFORM =~ /java/i ? 3 : 1)
   }
 
   class << self
@@ -57,167 +57,6 @@ module Otaku
 
   end
 
-  # //////////////////////////////////////////////////////////////////////////////////////////
-  # Otaku::Encoder
-  # //////////////////////////////////////////////////////////////////////////////////////////
-
-  module Encoder
-    class << self
-
-      def encode(thing)
-        Base64.encode64(Marshal.dump(thing))
-      end
-
-      def decode(thing)
-        Marshal.load(Base64.decode64(thing))
-      end
-
-    end
-  end
-
-  # //////////////////////////////////////////////////////////////////////////////////////////
-  # Otaku::Handler
-  # //////////////////////////////////////////////////////////////////////////////////////////
-
-  class Handler
-
-    def initialize(context, handler)
-      @context = __context_as_code__(context)
-      @proc = __proc_as_code__(handler)
-    end
-
-    def [](data)
-      eval(@context).instance_exec(data, &eval(@proc))
-    end
-
-    private
-
-      def __proc_as_code__(block)
-        Ruby2Ruby.new.process(block.to_sexp)
-      end
-
-      def __context_as_code__(methods_hash)
-        'Class.new{ %s }.new' %
-          methods_hash.map do |method, val|
-            "def #{method}; Encoder.decode(%|#{Encoder.encode(val).gsub('|','\|')}|); end"
-          end.join('; ')
-      end
-
-  end
-
-  # //////////////////////////////////////////////////////////////////////////////////////////
-  # Otaku::Server
-  # //////////////////////////////////////////////////////////////////////////////////////////
-
-  module Server
-
-    class << self
-
-      attr_accessor :handler
-
-      def start(other_process=false)
-        other_process ? run_evented_server : (
-          # print '[Otaku] initializing at %s:%s ... ' % [Otaku.address, Otaku.port] # DBUG
-          run_server_script
-          # puts 'done [pid#%s]' % @process.pid # DEBUG
-        )
-      end
-
-      def run_evented_server
-        log 'started with pid #%s' % Process.pid,
-          'listening at %s:%s' % [Otaku.address, Otaku.port]
-        EventMachine::run { EventMachine::start_server(Otaku.address, Otaku.port, EM) }
-      end
-
-      def run_server_script
-        args = Encoder.encode({
-          :config => Otaku.config,
-          :handler => @handler
-        })
-        @process = IO.popen(%|ruby #{__FILE__} "#{args.gsub('"','\"')}"|,'r')
-        sleep Otaku.init_wait_time
-      end
-
-      def stop
-        Process.kill('SIGHUP', @process.pid) if @process
-      end
-
-      def log(*msgs)
-        @logger ||= Logger.new(Otaku.log_file)
-        msgs.each{|msg| @logger << "[Otaku] %s\n" % msg }
-      end
-
-      def cleanup
-        @logger.close
-      end
-
-    end
-
-    private
-
-      module EM #:nodoc:
-
-        def receive_data(data)
-          log 'receives data: %s' % data.inspect
-          result = process_data(data)
-          log 'returning result: %s' % result.inspect
-          send_data(Encoder.encode(result))
-        end
-
-        def process_data(data)
-          begin
-            Server.handler[data]
-          rescue
-            error = DataProcessError.new($!.inspect)
-            log(error.inspect)
-            error
-          end
-        end
-
-        def log(*msg)
-          Server.log(*msg)
-        end
-
-      end
-
-  end
-
-  # //////////////////////////////////////////////////////////////////////////////////////////
-  # Otaku::Client
-  # //////////////////////////////////////////////////////////////////////////////////////////
-
-  module Client
-
-    class << self
-      def get(data)
-        EventMachine::run do
-          EventMachine::connect(Otaku.address, Otaku.port, EM).
-            execute(data) do |data|
-              @result = Encoder.decode(data)
-            end
-        end
-        @result
-      end
-    end
-
-    private
-
-      module EM #:nodoc:
-
-        def receive_data(data)
-          result = @callback.call(data)
-          result.is_a?(DataProcessError) ? raise(result) : result
-          EventMachine::stop_event_loop # ends loop & resumes program flow
-        end
-
-        def execute(method, &callback)
-          @callback = callback
-          send_data(method)
-        end
-
-      end
-
-  end
 end
 
 if $0 == __FILE__ && (encoded_data = ARGV[0])

data/lib/otaku/client.rb

@@ -0,0 +1,34 @@
+module Otaku
+  module Client
+
+    class << self
+      def get(data)
+        EventMachine::run do
+          EventMachine::connect(Otaku.address, Otaku.port, EM).
+            execute(data) do |data|
+              @result = Encoder.decode(data)
+            end
+        end
+        @result
+      end
+    end
+
+    private
+
+      module EM #:nodoc:
+
+        def receive_data(data)
+          result = @callback.call(data)
+          result.is_a?(DataProcessError) ? raise(result) : result
+          EventMachine::stop_event_loop # ends loop & resumes program flow
+        end
+
+        def execute(method, &callback)
+          @callback = callback
+          send_data(method)
+        end
+
+      end
+
+  end
+end

data/lib/otaku/encoder.rb

@@ -0,0 +1,15 @@
+module Otaku
+  module Encoder
+    class << self
+
+      def encode(thing)
+        Base64.encode64(Marshal.dump(thing))
+      end
+
+      def decode(thing)
+        Marshal.load(Base64.decode64(thing))
+      end
+
+    end
+  end
+end

data/lib/otaku/handler.rb

@@ -0,0 +1,101 @@
+module Otaku
+  class Handler
+
+    def initialize(context, handler)
+      @context = __context_as_code__(context)
+      @proc = __proc_as_code__(handler)
+    end
+
+    def [](data)
+      eval(@context).instance_exec(data, &eval(@proc))
+    end
+
+    private
+
+      def __context_as_code__(methods_hash)
+        'Class.new{ %s }.new' %
+          methods_hash.map do |method, val|
+            "def #{method}; Encoder.decode(%|#{Encoder.encode(val).gsub('|','\|')}|); end"
+          end.sort.join('; ')
+      end
+
+      def __proc_as_code__(block)
+        MagicProc.new(block).to_code
+      end
+
+      class MagicProc
+
+        RUBY_PARSER = RubyParser.new
+        RUBY_2_RUBY = Ruby2Ruby.new
+
+        def initialize(block)
+          @block = block
+        end
+
+        def to_code
+          code, remaining = code_fragments
+
+          while frag = remaining[frag_regexp,1]
+            begin
+              sexp = RUBY_PARSER.parse(code += frag, File.expand_path(@file))
+              return RUBY_2_RUBY.process(sexp) if sexp.inspect =~ sexp_regexp
+            rescue SyntaxError, Racc::ParseError, NoMethodError
+              remaining.sub!(frag,'')
+            end
+          end
+        end
+
+        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
+          @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 frag_regexp
+          @frag_regexp ||= (
+            end_marker = {'do' => 'end', '{' => '\}'}[code_match_args[:start_marker]]
+            /^(.*?\W#{end_marker})/m
+          )
+        end
+
+        def code_regexp
+          @code_regexp ||=
+            /^(.*?(Otaku\.start.*?|lambda|proc|Proc\.new)\s*(do|\{)\s*\|(\w+)\|\s*)/m
+        end
+
+        def code_match_args
+          @code_match_args ||= (
+            args = source_code.match(code_regexp)
+            {
+              :ignore => args[1],
+              :start_marker => args[3],
+              :arg => args[4]
+            }
+          )
+        end
+
+        def source_code
+          @source_code ||= (
+            @file, line_no = /^#<Proc:0x[0-9A-Fa-f]+@(.+):(\d+).*?>$/.match(@block.inspect)[1..2]
+            @line_no = line_no.to_i
+            File.readlines(@file)[@line_no.pred .. -1].join
+          )
+        end
+
+      end
+
+  end
+end

data/lib/otaku/server.rb

@@ -0,0 +1,72 @@
+module Otaku
+  module Server
+
+    class << self
+
+      attr_accessor :handler
+
+      def start(other_process=false)
+        other_process ? run_evented_server : (
+          # print '[Otaku] initializing at %s:%s ... ' % [Otaku.address, Otaku.port] # DEBUG
+          run_server_script
+          # puts 'done [pid#%s]' % @process.pid # DEBUG
+        )
+      end
+
+      def run_evented_server
+        log 'started with pid #%s' % Process.pid,
+          'listening at %s:%s' % [Otaku.address, Otaku.port]
+        EventMachine::run { EventMachine::start_server(Otaku.address, Otaku.port, EM) }
+      end
+
+      def run_server_script
+        script = File.join(File.dirname(__FILE__), '..', 'otaku.rb')
+        args = Encoder.encode(:config => Otaku.config, :handler => @handler)
+        @process = IO.popen(%|#{Otaku.ruby} #{script} "#{args.gsub('"','\"')}"|,'r')
+        sleep Otaku.init_wait_time
+      end
+
+      def stop
+        Process.kill('SIGHUP', @process.pid) if @process
+      end
+
+      def log(*msgs)
+        @logger ||= Logger.new(Otaku.log_file)
+        msgs.each{|msg| @logger << "[Otaku] %s\n" % msg }
+      end
+
+      def cleanup
+        @logger.close
+      end
+
+    end
+
+    private
+
+      module EM #:nodoc:
+
+        def receive_data(data)
+          log 'receives data: %s' % data.inspect
+          result = process_data(data)
+          log 'returning result: %s' % result.inspect
+          send_data(Encoder.encode(result))
+        end
+
+        def process_data(data)
+          begin
+            Server.handler[data]
+          rescue
+            error = DataProcessError.new($!.inspect)
+            log(error.inspect)
+            error
+          end
+        end
+
+        def log(*msg)
+          Server.log(*msg)
+        end
+
+      end
+
+  end
+end

data/otaku.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{otaku}
+  s.version = "0.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["NgTzeYang"]
+  s.date = %q{2010-07-19}
+  s.description = %q{}
+  s.email = %q{ngty77@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "HISTORY.txt",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/otaku.rb",
+     "lib/otaku/client.rb",
+     "lib/otaku/encoder.rb",
+     "lib/otaku/handler.rb",
+     "lib/otaku/server.rb",
+     "otaku.gemspec",
+     "spec/handler_spec.rb",
+     "spec/integration_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/ngty/otaku}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Dead simple service framework built on eventmachine}
+  s.test_files = [
+    "spec/integration_spec.rb",
+     "spec/handler_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bacon>, [">= 0"])
+      s.add_runtime_dependency(%q<eventmachine>, [">= 0.12.10"])
+      s.add_runtime_dependency(%q<ruby2ruby>, [">= 1.2.4"])
+      s.add_runtime_dependency(%q<ruby_parser>, [">= 2.0.4"])
+    else
+      s.add_dependency(%q<bacon>, [">= 0"])
+      s.add_dependency(%q<eventmachine>, [">= 0.12.10"])
+      s.add_dependency(%q<ruby2ruby>, [">= 1.2.4"])
+      s.add_dependency(%q<ruby_parser>, [">= 2.0.4"])
+    end
+  else
+    s.add_dependency(%q<bacon>, [">= 0"])
+    s.add_dependency(%q<eventmachine>, [">= 0.12.10"])
+    s.add_dependency(%q<ruby2ruby>, [">= 1.2.4"])
+    s.add_dependency(%q<ruby_parser>, [">= 2.0.4"])
+  end
+end
+

data/spec/handler_spec.rb

@@ -0,0 +1,228 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+Otaku::Handler.class_eval do
+  attr_reader :context, :proc
+end
+
+Otaku.instance_eval do
+  def start(context = {}, &block)
+    Otaku::Handler.new({}, block)
+  end
+end
+
+describe "Otaku Service Handler" 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')
+    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(
+        'Class.new{ %s; %s }.new' % [
+          "def m1; Encoder.decode(%|#{encode['v|1']}|); end",
+          "def m2; Encoder.decode(%|#{encode['v|2']}|); end"
+      ])
+    end
+
+  end
+
+  describe '>> initializing proc' do
+
+    expected = "proc { |watever| [\"a\", \"b\"].map { |x| puts(x) } }"
+
+    {
+    # ////////////////////////////////////////////////////////////////////////
+    # >> Always newlinling
+    # ////////////////////////////////////////////////////////////////////////
+      __LINE__ => (
+        lambda do |watever|
+          %w{a b}.map do |x|
+            puts x
+          end
+        end
+      ),
+      __LINE__ => (
+        lambda { |watever|
+          %w{a b}.map{|x|
+            puts x
+          }
+        }
+      ),
+      __LINE__ => (
+        proc do |watever|
+          %w{a b}.map do |x|
+            puts x
+          end
+        end
+      ),
+      __LINE__ => (
+        proc { |watever|
+          %w{a b}.map{|x|
+            puts x
+          }
+        }
+      ),
+      __LINE__ => (
+        Proc.new do |watever|
+          %w{a b}.map do |x|
+            puts x
+          end
+        end
+      ),
+      __LINE__ => (
+        Proc.new { |watever|
+          %w{a b}.map{|x|
+            puts x
+          }
+        }
+      ),
+    # ////////////////////////////////////////////////////////////////////////
+    # >> Partial newlining
+    # ////////////////////////////////////////////////////////////////////////
+      __LINE__ => (
+        lambda do |watever|
+          %w{a b}.map do |x| puts x end
+        end
+      ),
+      __LINE__ => (
+        lambda { |watever|
+          %w{a b}.map{|x| puts x }
+        }
+      ),
+      __LINE__ => (
+        proc do |watever|
+          %w{a b}.map do |x| puts x end
+        end
+      ),
+      __LINE__ => (
+        proc { |watever|
+          %w{a b}.map{|x| puts x }
+        }
+      ),
+      __LINE__ => (
+        Proc.new do |watever|
+          %w{a b}.map do |x| puts x end
+        end
+      ),
+      __LINE__ => (
+        Proc.new { |watever|
+          %w{a b}.map{|x| puts x }
+        }
+      ),
+    # ////////////////////////////////////////////////////////////////////////
+    # >> No newlining
+    # ////////////////////////////////////////////////////////////////////////
+      __LINE__ => (
+        lambda do |watever| %w{a b}.map do |x| puts x end end
+      ),
+      __LINE__ => (
+        lambda { |watever| %w{a b}.map{|x| puts x } }
+      ),
+      __LINE__ => (
+        proc do |watever| %w{a b}.map do |x| puts x end end
+      ),
+      __LINE__ => (
+        proc { |watever| %w{a b}.map{|x| puts x } }
+      ),
+      __LINE__ => (
+        Proc.new do |watever| %w{a b}.map do |x| puts x end end
+      ),
+      __LINE__ => (
+        Proc.new { |watever| %w{a b}.map{|x| puts x } }
+      ),
+    }.each do |debug, block|
+      should "handle proc as variable [##{debug}]" do
+        Otaku::Handler.new({}, block).proc.should.equal(expected)
+      end
+    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
+
+    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
+
+    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
+
+    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
+
+    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
+
+    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
+
+    should "handle block using { ... } [##{__LINE__}]" do
+      Otaku.start({}) { |watever|
+        %w{a b}.map do |x|
+          puts x
+        end
+      }.proc.should.equal(expected)
+    end
+
+    should "handle block using { ... } [##{__LINE__}]" do
+      Otaku.start { |watever|
+        %w{a b}.map do |x|
+          puts x
+        end
+      }.proc.should.equal(expected)
+    end
+
+    should "handle block using { ... } [##{__LINE__}]" do
+      Otaku.start({}) { |watever|
+        %w{a b}.map { |x| puts x }
+      }.proc.should.equal(expected)
+    end
+
+    should "handle block using { ... } [##{__LINE__}]" do
+      Otaku.start { |watever|
+        %w{a b}.map { |x| puts x }
+      }.proc.should.equal(expected)
+    end
+
+    should "handle block using { ... } [##{__LINE__}]" do
+      Otaku.start({}) { |watever| %w{a b}.map { |x| puts x } }.proc.should.equal(expected)
+    end
+
+    should "handle block using { ... } [##{__LINE__}]" do
+      Otaku.start { |watever| %w{a b}.map { |x| puts x } }.proc.should.equal(expected)
+    end
+
+    should "handle __FILE__ correctly [##{__LINE__}]" do
+      Otaku.start { |watever| __FILE__ }.proc.should.
+        equal("proc { |watever| \"%s\" }" % File.expand_path('spec/handler_spec.rb'))
+    end
+
+    should "handle __LINE__ incorrectly [##{__LINE__}]" do
+      Otaku.start { |watever| __LINE__ }.proc.should.
+        equal("proc { |watever| 1 }")
+    end
+
+  end
+
+end

data/spec/integration_spec.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Otaku Service" do
+
+  describe '>> starting' do
+
+    after do
+      Otaku.stop
+    end
+
+    should 'raise Otaku::HandlerNotDefinedError when processing wo specified proc' do
+      lambda { Otaku.start }.should.raise(Otaku::HandlerNotDefinedError)
+    end
+
+  end
+
+  describe '>> processing' do
+
+    after do
+      Otaku.stop
+    end
+
+    should 'succeed w proc that has no contextual reference' do
+      Otaku.start{|data| '~ %s ~' % data }
+      Otaku.process('hello').should.equal '~ hello ~'
+    end
+
+    should 'raise Otaku::DataProcessError w proc that has contextual reference yet has no specified context' do
+      mark = '*'
+      Otaku.start{|data| '%s %s %s' % [mark, data, mark] }
+      lambda { Otaku.process('hello') }.should.raise(Otaku::DataProcessError).
+        message.should.match(/#<NameError: undefined local variable or method `mark' for /)
+    end
+
+    should 'succeed w proc that has contextual reference & has context specified' do
+      Otaku.start(:mark => '*') {|data| '%s %s %s' % [mark, data, mark] }
+      Otaku.process('hello').should.equal('* hello *')
+    end
+
+    should 'reflect __FILE__ as captured when declaring proc' do
+      Otaku.start{|data| __FILE__ }
+      Otaku.process(:watever_data).should.equal(File.expand_path(__FILE__))
+    end
+
+    should 'not reflect __LINE__ as captured when declaring proc' do
+      Otaku.start{|data| __LINE__ }
+      Otaku.process(:watever_data).should.not.equal(__LINE__.pred)
+    end
+
+  end
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: otaku
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - NgTzeYang
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-18 00:00:00 +08:00
+date: 2010-07-19 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -65,19 +65,19 @@ dependencies:
   type: :runtime
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: ParseTree
+  name: ruby_parser
   prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 13
+        hash: 7
         segments: 
-        - 3
+        - 2
         - 0
-        - 5
-        version: 3.0.5
+        - 4
+        version: 2.0.4
   type: :runtime
   version_requirements: *id004
 description: ""
@@ -98,7 +98,13 @@ files:
 - Rakefile
 - VERSION
 - lib/otaku.rb
-- spec/processing_spec.rb
+- lib/otaku/client.rb
+- lib/otaku/encoder.rb
+- lib/otaku/handler.rb
+- lib/otaku/server.rb
+- otaku.gemspec
+- spec/handler_spec.rb
+- spec/integration_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/ngty/otaku
@@ -133,7 +139,8 @@ rubyforge_project:
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Dead simple server/client service built using eventmachine
+summary: Dead simple service framework built on eventmachine
 test_files: 
-- spec/processing_spec.rb
+- spec/integration_spec.rb
+- spec/handler_spec.rb
 - spec/spec_helper.rb

data/spec/processing_spec.rb

@@ -1,30 +0,0 @@
-require File.join(File.dirname(__FILE__), 'spec_helper')
-
-describe "Otaku doing processing" do
-
-  after do
-    Otaku.stop
-  end
-
-  should 'succeed when using proc that has no contextual reference' do
-    Otaku.start{|data| '~ %s ~' % data }
-    Otaku.process('hello').should.equal '~ hello ~'
-  end
-
-  should 'fail when using proc that has contextual reference yet has no specified context' do
-    mark = '*'
-    Otaku.start{|data| '%s %s %s' % [mark, data, mark] }
-    lambda { Otaku.process('hello') }.should.raise(Otaku::DataProcessError).
-      message.should.match(/#<NameError: undefined local variable or method `mark' for /)
-  end
-
-  should 'succeed when using proc that has contextual reference & has context specified' do
-    Otaku.start(:mark => '*') {|data| '%s %s %s' % [mark, data, mark] }
-    Otaku.process('hello').should.equal('* hello *')
-  end
-
-  should 'raise Otaku::HandlerNotDefinedError when processing wo specified proc' do
-    lambda { Otaku.start }.should.raise(Otaku::HandlerNotDefinedError)
-  end
-
-end