otaku 0.2.1 → 0.2.2

data/.gitignore

@@ -19,3 +19,4 @@ rdoc
 pkg
 
 ## PROJECT::SPECIFIC
+tmp/*

data/HISTORY.txt

@@ -1,5 +1,24 @@
+=== 0.2.2 2010-07-21
+
+= Features
+* $LOAD_PATH include the directory where the file calling Otaku.start is located, thus
+  user no longer need to verbosely define the full path of the file to require [#ngty]
+
+= Maintenance
+* magic variable __FILE__ is now derived the same way as __LINE__ (see below) [#ngty]
+
+= Bug Fixes
+* magic variable __LINE__ now works as expected (the line where the proc is defined in file,
+  instead of the string eval line) [#ngty]
+* fixed unexpected failure in specs as a result of using installed otaku, instead of the
+  one under current project directory (by passing -I when running the sub-process server
+  script) [#ngty]
+
 === 0.2.1 2010-07-19
 
+= Maintenance
+* logging support is moved directly under Otaku module [#ngty]
+
 = Bug Fixes
 * closing of logger is done ONLY if the logger has been initialized [#ngty]
 

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.2.2

data/lib/otaku.rb

@@ -5,7 +5,6 @@ require 'base64'
 require 'ruby2ruby'
 require 'ruby_parser'
 
-# $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'otaku/encoder'
 require 'otaku/handler'
 require 'otaku/server'
@@ -39,6 +38,10 @@ module Otaku
       end
     end
 
+    def root
+      File.expand_path(File.dirname(__FILE__))
+    end
+
     def start(context = {}, &handler)
       raise HandlerNotDefinedError unless block_given?
       Server.handler = Handler.new(context, handler)

data/lib/otaku/handler.rb

@@ -3,11 +3,17 @@ module Otaku
 
     def initialize(context, handler)
       @context = __context_as_code__(context)
-      @proc = __proc_as_code__(handler)
+      magic_proc = MagicProc.new(handler)
+      @proc, @file, @line = [:code, :file, :line].map{|meth| magic_proc.send(meth) }
     end
 
-    def [](data)
-      eval(@context).instance_exec(data, &eval(@proc))
+    def process(data)
+      (instance = eval(@context, nil, '(generated class)', 1)).
+        instance_exec(data, &(block = eval(@proc, nil, @file, @line)))
+    end
+
+    def root
+      File.dirname(@file)
     end
 
     private
@@ -19,81 +25,98 @@ module Otaku
           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
 
+        attr_reader :file, :line, :code
+
         def initialize(block)
           @block = block
+          extract_file_and_line_and_code
         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,'')
+        private
+
+          def extract_file_and_line_and_code
+            code, remaining = code_fragments
+
+            while frag = remaining[frag_regexp,1]
+              begin
+                sexp = RUBY_PARSER.parse(replace_magic_vars(code += frag))
+                if sexp.inspect =~ sexp_regexp
+                  @code = revert_magic_vars(RUBY_2_RUBY.process(sexp)).sub('proc {','lambda {')
+                  break
+                end
+              rescue SyntaxError, Racc::ParseError, NoMethodError
+                remaining.sub!(frag,'')
+              end
             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 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 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 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_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 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
+          def source_code
+            @source_code ||= (
+              file, line = /^#<Proc:0x[0-9A-Fa-f]+@(.+):(\d+).*?>$/.match(@block.inspect)[1..2]
+              @file = File.expand_path(file)
+              @line = line.to_i
+              File.readlines(@file)[@line.pred .. -1].join
+            )
+          end
+
+          def replace_magic_vars(code)
+            %w{__FILE__ __LINE__}.inject(code) do |code, var|
+              code.gsub(var, "%|((#{var}))|")
+            end
+          end
+
+          def revert_magic_vars(code)
+            %w{__FILE__ __LINE__}.inject(code) do |code, var|
+              code.gsub(%|"((#{var}))"|, var)
+            end
+          end
 
       end
 

data/lib/otaku/server.rb

@@ -20,9 +20,10 @@ module Otaku
       end
 
       def run_server_script
-        script = File.join(File.dirname(__FILE__), '..', 'otaku.rb')
+        script = File.join(Otaku.root, 'otaku.rb')
         args = Encoder.encode(:config => Otaku.config, :handler => @handler)
-        @process = IO.popen(%|#{Otaku.ruby} #{script} "#{args.gsub('"','\"')}"|,'r')
+        load_paths = [@handler.root, Otaku.root].join(' -I')
+        @process = IO.popen(%|#{Otaku.ruby} -I#{load_paths} #{script} "#{args.gsub('"','\"')}"|,'r')
         sleep Otaku.init_wait_time
       end
 
@@ -45,7 +46,7 @@ module Otaku
 
         def process_data(data)
           begin
-            Server.handler[data]
+            Server.handler.process(data)
           rescue
             error = DataProcessError.new($!.inspect)
             log(error.inspect)

data/otaku.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{otaku}
-  s.version = "0.2.1"
+  s.version = "0.2.2"
 
   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.date = %q{2010-07-21}
   s.description = %q{}
   s.email = %q{ngty77@gmail.com}
   s.extra_rdoc_files = [

data/spec/handler_spec.rb

@@ -31,7 +31,7 @@ describe "Otaku Service Handler" do
 
   describe '>> initializing proc' do
 
-    expected = "proc { |watever| [\"a\", \"b\"].map { |x| puts(x) } }"
+    expected = "lambda { |watever| [\"a\", \"b\"].map { |x| puts(x) } }"
 
     {
     # ////////////////////////////////////////////////////////////////////////
@@ -59,7 +59,7 @@ describe "Otaku Service Handler" do
         end
       ),
       __LINE__ => (
-        proc { |watever|
+        lambda { |watever|
           %w{a b}.map{|x|
             puts x
           }
@@ -98,7 +98,7 @@ describe "Otaku Service Handler" do
         end
       ),
       __LINE__ => (
-        proc { |watever|
+        lambda { |watever|
           %w{a b}.map{|x| puts x }
         }
       ),
@@ -125,7 +125,7 @@ describe "Otaku Service Handler" do
         proc do |watever| %w{a b}.map do |x| puts x end end
       ),
       __LINE__ => (
-        proc { |watever| %w{a b}.map{|x| puts x } }
+        lambda { |watever| %w{a b}.map{|x| puts x } }
       ),
       __LINE__ => (
         Proc.new do |watever| %w{a b}.map do |x| puts x end end
@@ -213,14 +213,32 @@ describe "Otaku Service Handler" do
       Otaku.start { |watever| %w{a b}.map { |x| puts x } }.proc.should.equal(expected)
     end
 
-    should "handle __FILE__ correctly [##{__LINE__}]" do
+    should "leave __FILE__ as __FILE__ [##{__LINE__}]" do
       Otaku.start { |watever| __FILE__ }.proc.should.
-        equal("proc { |watever| \"%s\" }" % File.expand_path('spec/handler_spec.rb'))
+        equal("lambda { |watever| __FILE__ }" % File.expand_path('spec/handler_spec.rb'))
     end
 
-    should "handle __LINE__ incorrectly [##{__LINE__}]" do
+    should "leave __LINE__ as __LINE__ [##{__LINE__}]" do
       Otaku.start { |watever| __LINE__ }.proc.should.
-        equal("proc { |watever| 1 }")
+        equal("lambda { |watever| __LINE__ }")
+    end
+
+  end
+
+  describe '>> fetching root' do
+    should 'return directory of current file' do
+      Otaku.start { |watever| __LINE__ }.root.should.equal(File.expand_path(File.dirname(__FILE__)))
+    end
+  end
+
+  describe '>> processing specified data' do
+
+    should 'reflect __FILE__ captured when the proc was 1st defined' 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
+      Otaku.start{ |watever| __LINE__ }.process(:fake_data).should.equal(__LINE__)
     end
 
   end

data/spec/integration_spec.rb

@@ -42,9 +42,19 @@ describe "Otaku Service" do
       Otaku.process(:watever_data).should.equal(File.expand_path(__FILE__))
     end
 
-    should 'not reflect __LINE__ as captured when declaring proc' do
+    should 'reflect __LINE__ as captured when declaring proc' do
       Otaku.start{|data| __LINE__ }
-      Otaku.process(:watever_data).should.not.equal(__LINE__.pred)
+      Otaku.process(:watever_data).should.equal(__LINE__.pred)
+    end
+
+    should 'have $LOAD_PATH include Otaku.root' do
+      Otaku.start{|data| $LOAD_PATH }
+      Otaku.process(:watever_data).should.include(Otaku.root)
+    end
+
+    should 'have $LOAD_PATH include Otaku::Server#handler.root' do
+      Otaku.start{|data| $LOAD_PATH }
+      Otaku.process(:watever_data).should.include(Otaku::Server.handler.root)
     end
 
   end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: otaku
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: false
   segments: 
   - 0
   - 2
-  - 1
-  version: 0.2.1
+  - 2
+  version: 0.2.2
 platform: ruby
 authors: 
 - NgTzeYang
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-19 00:00:00 +08:00
+date: 2010-07-21 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency