rufus-lua 1.1.1 → 1.1.2

data/CHANGELOG.txt

@@ -2,6 +2,18 @@
 = rufus-lua CHANGELOG.txt
 
 
+== rufus-lua - 1.1.2    released 2014/09/13
+
+- properly turn Ruby nils into Lua nils (Christopher Saunders)
+- get rid of Lib.strlen (as suggested by Stas Ukolov)
+- let Ruby callbacks accept Lua functions as arguments (Gian Perrone)
+- add #set_error_handler (based on an initial request by Nathanael Jones)
+- fix unstack issue when returning table (https://github.com/lywaterman)
+- use "{filename}:#{lineno}" as eval chunk name (suggested by Nathanael Jones)
+- wrap Ruby callbacks in CallbackState (Nathanael Jones)
+- accept Ruby symbols containing \0 character (Nathanael Jones)
+
+
 == rufus-lua - 1.1.1    released 2014/07/01
 
 - move from bacon to rspec

data/CREDITS.txt

@@ -11,9 +11,17 @@ Scott Persinger  https://github.com/scottpersinger
 
 == contributors
 
+Christopher Saunders  https://github.com/csaunders
+Gian Perrone  https://github.com/quidrex
 Matthew Nielsen  https://github.com/xunker
 Nathanael Jones  https://github.com/nathanaeljones
 
+
+== feedback
+
+Stas Ukolov  https://github.com/ukoloff
+
+
 == inspiration
 
   http://rubyluabridge.rubyforge.org/

data/README.md

@@ -168,6 +168,87 @@ lua = Rufus::Lua::State.new
 lua.eval('print("hello")', nil, 'myluastuff/hello.lua', 77)
 ```
 
+### set_error_handler
+
+`set_error_handler` gives a little bit of control on how error messages are prepared when errors occur in the Lua interpreter.
+
+Here are set of examples for each of the possible error handler kind: Lua code, Ruby block, `:traceback`.
+
+```ruby
+require 'rufus-lua'
+
+lua = Rufus::Lua::State.new
+
+#
+# no error handler
+
+begin
+  lua.eval('error("ouch!")')
+rescue => e
+  puts(e)
+end
+  # --> eval:pcall : '[string "line"]:1: ouch!' (2 LUA_ERRRUN)
+
+#
+# Lua error handler
+
+lua.set_error_handler(%{
+  function (msg)
+    return 'something went wrong: ' .. string.gmatch(msg, ": (.+)$")()
+  end
+})
+
+begin
+  lua.eval('error("ouch!")')
+rescue => e
+  puts(e)
+end
+  # --> eval:pcall : 'something went wrong: ouch!' (2 LUA_ERRRUN)
+
+#
+# Ruby block error handler
+
+lua.set_error_handler do |msg|
+  ([ msg.split.last ] * 3).join(' ')
+end
+
+begin
+  lua.eval('error("ouch!")')
+rescue => e
+  puts(e)
+end
+  # --> eval:pcall : 'ouch! ouch! ouch!' (2 LUA_ERRRUN)
+
+#
+# prepackaged :traceback handler
+
+lua.set_error_handler(:traceback)
+
+begin
+  lua.eval('error("ouch!")')
+rescue => e
+  puts(e)
+end
+  # -->
+  #   eval:pcall : '[string "line"]:1: ouch!
+  #   stack traceback:
+  #   	[C]: in function 'error'
+  #   	[string "line"]:1: in main chunk' (2 LUA_ERRRUN)
+
+#
+# unset the error handler
+
+lua.set_error_handler(nil)
+
+begin
+  lua.eval('error("ouch!")')
+rescue => e
+  puts(e)
+end
+  # --> eval:pcall : '[string "line"]:1: ouch!' (2 LUA_ERRRUN)
+  # (back to default)
+```
+
 
 ## compiling liblua.dylib
 
@@ -216,7 +297,7 @@ sudo cp src/liblua.dylib /usr/local/lib/liblua.5.1.4.dylib
 
 ## tested with
 
-ruby 1.8.7p72, ruby 1.9.1p0, jruby 1.2.0
+ruby 1.9.1p0, jruby 1.2.0
 jruby 1.1.6 has an issue with errors raised inside of Ruby functions (callbacks)
 
 ruby-ffi 0.4.0 and 0.5.0

data/lib/rufus/lua/error.rb

@@ -25,25 +25,29 @@
 
 module Rufus::Lua
 
+  # error codes from 0 to 5
+  #
+  LUA_ERRS = %w[ 0 LUA_YIELD LUA_ERRRUN LUA_ERRSYNTAX LUA_ERRMEM LUA_ERRERR ]
+
   #
   # An error class for rufus-lua.
   #
   class LuaError < RuntimeError
 
     attr_reader :kind, :errcode, :msg
-    attr_reader :binding, :filename, :lineno
+    attr_reader :bndng, :filename, :lineno
 
     attr_reader :original_backtrace
 
-    def initialize(kind, errcode, msg, binding, filename, lineno)
+    def initialize(kind, errcode, msg, bndng, filename, lineno)
 
-      super("#{kind} : '#{msg}' (#{errcode})")
+      super("#{kind} : '#{msg}' (#{errcode} #{LUA_ERRS[errcode]})")
 
       @kind = kind
       @errcode = errcode
       @msg = msg
 
-      @binding = binding
+      @bndng = bndng
       @filename = filename
       @lineno = lineno
     end

data/lib/rufus/lua/lib.rb

@@ -77,8 +77,6 @@ module Lua
     #
     # attach functions
 
-    attach_function :strlen, [ :string ], :int
-
     attach_function :lua_close, [ :pointer ], :void
 
     attach_function :luaL_openlibs, [ :pointer ], :void
@@ -118,6 +116,16 @@ module Lua
     attach_function :lua_pushstring, [ :pointer, :string ], :pointer
     attach_function :lua_pushlstring, [ :pointer, :pointer, :int ], :pointer
 
+    attach_function :lua_remove, [ :pointer, :int ], :void
+      # removes the value at the given stack index, shifting down all elts above
+
+    #attach_function :lua_pushvalue, [ :pointer, :int ], :void
+      # pushes a copy of the value at the given index to the top of the stack
+    #attach_function :lua_insert, [ :pointer, :int ], :void
+      # moves the top elt to the given index, shifting up all elts above
+    #attach_function :lua_replace, [ :pointer, :int ], :void
+      # pops the top elt and override the elt at given index with it
+
     attach_function :lua_rawgeti, [ :pointer, :int, :int ], :void
 
     attach_function :luaL_newstate, [], :pointer

data/lib/rufus/lua/objects.rb

@@ -42,6 +42,7 @@ module Rufus::Lua
       @pointer = pointer
       @ref = Lib.luaL_ref(@pointer, LUA_REGISTRYINDEX)
         # this pops the object out of the stack !
+      @error_handler = 0
     end
 
     # Frees the reference to this object
@@ -60,7 +61,7 @@ module Rufus::Lua
     #
     def load_onto_stack
 
-      fail RuntimeError.new(
+      raise RuntimeError.new(
         "#{self.class} got freed, cannot re-access it directly"
       ) unless @ref
 
@@ -286,7 +287,7 @@ module Rufus::Lua
       h = self.to_h
 
       pure && h.keys.find { |k| not [ Float ].include?(k.class) } &&
-        raise("cannot turn hash into array, some keys are not numbers")
+        fail('cannot turn hash into array, some keys are not numbers')
 
       a_keys = (1..objlen).to_a.collect { |k| k.to_f }
       keys = a_keys + (h.keys - a_keys)

data/lib/rufus/lua/state.rb

@@ -86,14 +86,15 @@ module Rufus::Lua
 
     # This method holds the 'eval' mechanism.
     #
-    def loadstring_and_call(s, binding, filename, lineno)
+    def loadstring_and_call(s, bndng, filename, lineno)
 
       bottom = stack_top
+      chunk = filename ? "#{filename}:#{lineno}" : 'line'
 
-      err = Lib.luaL_loadbuffer(@pointer, s, Lib.strlen(s), 'line')
-      fail_if_error('eval:compile', err, binding, filename, lineno)
+      err = Lib.luaL_loadbuffer(@pointer, s, s.length, chunk)
+      fail_if_error('eval:compile', err, bndng, filename, lineno)
 
-      pcall(bottom, 0, binding, filename, lineno) # arg_count is set to 0
+      pcall(bottom, 0, bndng, filename, lineno) # arg_count is set to 0
     end
 
     # Returns a string representation of the state's stack.
@@ -188,7 +189,8 @@ module Rufus::Lua
     def stack_pop
 
       r = stack_fetch
-      stack_unstack
+      stack_unstack if r.class != Rufus::Lua::Table
+
       r
     end
 
@@ -200,7 +202,7 @@ module Rufus::Lua
       new_top = 0 if new_top < 0
         #
         # there are no safeguard in Lua, setting top to -2 work well
-        # when the stack is crowed, but it has bad side effects when the
+        # when the stack is crowded, but it has bad side effects when the
         # stack is empty... Now safeguarding by ourselves.
 
       Lib.lua_settop(@pointer, new_top)
@@ -222,8 +224,8 @@ module Rufus::Lua
         when Fixnum then Lib.lua_pushinteger(@pointer, o)
         when Float then Lib.lua_pushnumber(@pointer, o)
 
-        when String then Lib.lua_pushlstring(@pointer, o, o.unpack('C*').size)
-        when Symbol then Lib.lua_pushstring(@pointer, o.to_s)
+        when String then Lib.lua_pushlstring(@pointer, o, o.bytesize)
+        when Symbol then Lib.lua_pushlstring(@pointer, o.to_s, o.to_s.bytesize)
 
         when Hash then stack_push_hash(o)
         when Array then stack_push_array(o)
@@ -269,6 +271,27 @@ module Rufus::Lua
       Lib.lua_getfield(@pointer, LUA_GLOBALSINDEX, name)
     end
 
+    # Loads a field of the table currently on the top of the stack
+    #
+    def stack_load_field(name)
+
+      Lib.lua_getfield(@pointer, -1, name)
+    end
+
+    # Loads a path (for example "debug.traceback") on top of the stack.
+    #
+    def stack_load_path(path)
+
+      ps = path.split('.')
+
+      stack_load_global(ps.shift)
+
+      while ps.first
+        stack_load_field(ps.shift)
+        Lib.lua_remove(@pointer, -2)
+      end
+    end
+
     # Loads the Lua object registered with the given ref on top of the stack
     #
     def stack_load_ref(ref)
@@ -294,14 +317,14 @@ module Rufus::Lua
     #
     # Will raise an error in case of failure.
     #
-    def pcall(stack_bottom, arg_count, binding, filename, lineno)
+    def pcall(stack_bottom, arg_count, bndng, filename, lineno)
 
       #err = Lib.lua_pcall(@pointer, 0, 1, 0)
-        # when there's only 1 return value, use LUA_MULTRET (-1) the
-        # rest of the time
+        # When there's only 1 return value.
+        # Use LUA_MULTRET (-1) the rest of the time
 
-      err = Lib.lua_pcall(@pointer, arg_count, LUA_MULTRET, 0)
-      fail_if_error('eval:pcall', err, binding, filename, lineno)
+      err = Lib.lua_pcall(@pointer, arg_count, LUA_MULTRET, @error_handler)
+      fail_if_error('eval:pcall', err, bndng, filename, lineno)
 
       return_result(stack_bottom)
     end
@@ -320,21 +343,14 @@ module Rufus::Lua
     # This method will raise an error with err > 0, else it will immediately
     # return.
     #
-    def fail_if_error(kind, err, binding, filename, lineno)
+    def fail_if_error(kind, err, bndng, filename, lineno)
 
       return if err < 1
 
-      # TODO :
-      #
-      # LUA_ERRRUN: a runtime error.
-      # LUA_ERRMEM: memory allocation error. For such errors, Lua does not call
-      #   the error handler function.
-      # LUA_ERRERR: error while running the error handler function.
-
       s = Lib.lua_tolstring(@pointer, -1, nil).read_string
       Lib.lua_settop(@pointer, -2)
 
-      fail LuaError.new(kind, err, s, binding, filename, lineno)
+      fail LuaError.new(kind, err, s, bndng, filename, lineno)
     end
 
     # Given the name of a Lua global variable, will return its value (or nil
@@ -347,6 +363,17 @@ module Rufus::Lua
     end
   end
 
+  class CallbackState
+    include StateMixin
+
+    def initialize(pointer)
+
+      @pointer = pointer
+      @callbacks = []
+      @error_handler = 0
+    end
+  end
+
   #
   # A Lua state, wraps a Lua runtime.
   #
@@ -389,13 +416,44 @@ module Rufus::Lua
       # garbage collection (Scott).
 
       @callbacks = []
+
+      @error_handler = 0
+    end
+
+    def set_error_handler(lua_code=nil, &block)
+
+      if lua_code == nil && block
+
+        function('_ruby_error_handler', &block)
+        stack_load_path('_ruby_error_handler')
+        @error_handler = stack_top
+
+      elsif lua_code == nil
+
+        Lib.lua_remove(@pointer, @error_handler) if @error_handler > 0
+        @error_handler = 0
+
+      elsif lua_code == :traceback
+
+        stack_load_path('debug.traceback')
+        @error_handler = stack_top
+
+      else
+
+        lua_code = lua_code.strip
+        lua_code = 'return ' + lua_code unless lua_code.match(/^return\s+/)
+
+        r = self.eval(lua_code)
+        r.send(:load_onto_stack)
+        @error_handler = stack_top
+      end
     end
 
     # Evaluates a piece (string) of Lua code within the state.
     #
-    def eval(s, binding=nil, filename=nil, lineno=nil)
+    def eval(s, bndng=nil, filename=nil, lineno=nil)
 
-      loadstring_and_call(s, binding, filename, lineno)
+      loadstring_and_call(s, bndng, filename, lineno)
     end
 
     # Returns a value set at the 'global' level in the state.
@@ -462,24 +520,24 @@ module Rufus::Lua
     #
     def function(name, opts={}, &block)
 
-      raise 'please pass a block for the body of the function' unless block
+      fail 'please pass a block for the body of the function' unless block
 
       to_ruby = opts[:to_ruby]
 
       callback = Proc.new do |state|
 
+        s = CallbackState.new(state)
         args = []
 
         loop do
 
-          break if stack_top == 0 # never touch stack[0] !!
+          break if s.stack_top == 0 # never touch stack[0] !!
 
-          arg = stack_fetch
-          break if arg.class == Rufus::Lua::Function
+          arg = s.stack_fetch
 
           args.unshift(arg)
 
-          stack_unstack unless args.first.is_a?(Rufus::Lua::Table)
+          s.stack_unstack unless args.first.is_a?(Rufus::Lua::Ref)
         end
 
         while args.size < block.arity
@@ -491,7 +549,7 @@ module Rufus::Lua
 
         result = block.call(*args)
 
-        stack_push(result)
+        s.stack_push(result)
 
         1
       end
@@ -538,7 +596,7 @@ module Rufus::Lua
     #
     def close
 
-      raise "State already closed" unless @pointer
+      fail 'State already closed' unless @pointer
       Lib.lua_close(@pointer)
       @pointer = nil
     end
@@ -547,7 +605,7 @@ module Rufus::Lua
     #
     def gc_count
 
-      raise "State got closed, cannot proceed" unless @pointer
+      fail 'State got closed, cannot proceed' unless @pointer
       Lib.lua_gc(@pointer, LUA_GCCOUNT, 0)
     end
 
@@ -555,7 +613,7 @@ module Rufus::Lua
     #
     def gc_collect!
 
-      raise "State got closed, cannot proceed" unless @pointer
+      fail 'State got closed, cannot proceed' unless @pointer
       Lib.lua_gc(@pointer, LUA_GCCOLLECT, 0)
     end
 
@@ -563,7 +621,7 @@ module Rufus::Lua
     #
     def gc_stop
 
-      raise "State got closed, cannot proceed" unless @pointer
+      fail 'State got closed, cannot proceed' unless @pointer
       Lib.lua_gc(@pointer, LUA_GCSTOP, 0)
     end
 
@@ -571,7 +629,7 @@ module Rufus::Lua
     #
     def gc_resume
 
-      raise "State got closed, cannot proceed" unless @pointer
+      fail 'State got closed, cannot proceed' unless @pointer
       Lib.lua_gc(@pointer, LUA_GCRESTART, 0)
     end
 

data/lib/rufus/lua/utils.rb

@@ -48,6 +48,7 @@ module Rufus::Lua
       when Float then o.to_s
       when TrueClass then o.to_s
       when FalseClass then o.to_s
+      when NilClass then 'nil'
 
       when Hash then to_lua_table_s(o)
       when Array then to_lua_table_s(o)

data/lib/rufus/lua/version.rb

@@ -26,7 +26,7 @@
 module Rufus
 module Lua
 
-  VERSION = '1.1.1'
+  VERSION = '1.1.2'
 end
 end
 

data/spec/coroutines_spec.rb

@@ -68,15 +68,12 @@ describe Rufus::Lua::State do
     #
     it 'yields the right value' do
 
-      pending 'yield across callback no worky on Lua 5.1.x'
-
       @s.function :host_function do
         'success'
       end
       r = @s.eval(%{
         function routine()
           coroutine.yield(host_function())
-          --coroutine.yield("success") -- that works :-(
         end
         co = coroutine.create(routine)
         a, b = coroutine.resume(co)
@@ -85,6 +82,55 @@ describe Rufus::Lua::State do
 
       expect(r).to eq([ true, 'success' ])
     end
+
+    it 'executes a ruby function within a coroutine' do
+
+      run_count = 0
+
+      @s.function :host_function do
+        run_count += 1
+      end
+      r = @s.eval(%{
+        function routine()
+          host_function()
+          coroutine.yield()
+          host_function()
+          coroutine.yield()
+        end
+        co = coroutine.create(routine)
+        a, b = coroutine.resume(co)
+        a, b = coroutine.resume(co)
+        return { a, b }
+      }).to_ruby
+
+      expect(r).to eq([ true])
+      expect(run_count).to eq(2)
+    end
+
+    it 'executes a ruby function (with arguments) within a coroutine' do
+
+      run_count = 0
+      last_arguments = nil
+
+      @s.function :host_function, { :to_ruby => true } do |*args|
+        run_count += 1
+        last_arguments = args
+        0
+      end
+      r = @s.eval(%{
+        function routine()
+          host_function("hi")
+          coroutine.yield()
+        end
+        co = coroutine.create(routine)
+        a, b = coroutine.resume(co)
+        return { a, b }
+      }).to_ruby
+
+      expect(r).to eq([ true ])
+      expect(run_count).to eq(1)
+      expect(last_arguments).to eq([ "hi" ])
+    end
   end
 end
 

data/spec/error_handler_spec.rb

@@ -0,0 +1,222 @@
+
+#
+# Specifying rufus-lua
+#
+# Tue Jul 22 21:07:10 JST 2014
+#
+
+require 'spec_base'
+
+
+describe 'State and error handler' do
+
+  before do
+    @s = Rufus::Lua::State.new
+  end
+  after do
+    @s.close
+  end
+
+  describe '#set_error_handler(lua_code)' do
+
+    it 'registers a function as error handler' do
+
+      le = nil
+
+      @s.set_error_handler(%{
+        function (e)
+          return e .. '\\n' .. debug.traceback()
+        end
+      })
+
+      @s.eval(%{
+        function f ()
+          error("in f")
+        end
+      }, nil, 'mystuff.lua', 77)
+      begin
+        @s.eval('f()', nil, 'mymain.lua', 88)
+      rescue Rufus::Lua::LuaError => le
+      end
+
+      expect(le.message).to eq(%{
+eval:pcall : '[string "mystuff.lua:77"]:3: in f
+stack traceback:
+	[string "line"]:2: in function <[string "line"]:1>
+	[C]: in function 'error'
+	[string "mystuff.lua:77"]:3: in function 'f'
+	[string "mymain.lua:88"]:1: in main chunk' (2 LUA_ERRRUN)
+      }.strip)
+
+      expect(@s.send(:stack_top)).to eq(1)
+    end
+
+    it 'sets the error handler in a permanent way' do
+
+      le = nil
+
+      @s.set_error_handler(%{
+        function (e)
+          return 'something went wrong: ' .. string.gmatch(e, ": (.+)$")()
+        end
+      })
+
+      begin
+        @s.eval('error("a")')
+      rescue Rufus::Lua::LuaError => le
+      end
+
+      expect(le.msg).to eq('something went wrong: a')
+
+      begin
+        @s.eval('error("b")')
+      rescue Rufus::Lua::LuaError => le
+      end
+
+      expect(le.msg).to eq('something went wrong: b')
+    end
+
+    context 'CallbackState' do
+
+      # Setting an error handler on the calling state or even directly
+      # on the CallbackState doesn't have any effect.
+      # Any error handler seems bypassed.
+
+      it 'has no effect' do
+
+        e = nil
+
+        @s.set_error_handler(%{
+          function (e) return 'bad: ' .. string.gmatch(e, ": (.+)$")() end
+        })
+        f = @s.function(:do_fail) { fail('in style') }
+        begin
+          @s.eval('do_fail()')
+        rescue Exception => e
+        end
+
+        expect(e.class).to eq(RuntimeError)
+      end
+    end
+  end
+
+  describe '#set_error_handler(:traceback)' do
+
+    it 'sets a vanilla debug.traceback() error handler' do
+
+      le = nil
+
+      @s.set_error_handler(:traceback)
+
+      @s.eval(%{
+        function f ()
+          error("in f")
+        end
+      }, nil, 'mystuff.lua', 77)
+      begin
+        @s.eval('f()', nil, 'mymain.lua', 88)
+      rescue Rufus::Lua::LuaError => le
+      end
+
+      expect(le.message).to eq(%{
+eval:pcall : '[string "mystuff.lua:77"]:3: in f
+stack traceback:
+	[C]: in function 'error'
+	[string "mystuff.lua:77"]:3: in function 'f'
+	[string "mymain.lua:88"]:1: in main chunk' (2 LUA_ERRRUN)
+      }.strip)
+    end
+  end
+
+  describe '#set_error_handler(:backtrace)' do
+
+    it 'sets a special handler that provides a merged Ruby then Lua backtrace'
+      # does it make any sense?
+  end
+
+  describe '#set_error_handler(&ruby_block)' do
+
+    it 'sets a Ruby callback as handler' do
+
+      le = nil
+
+      @s.set_error_handler do |msg|
+        ([ msg.split.last ] * 3).join(' ')
+      end
+
+      begin
+        @s.eval('error("tora")')
+      rescue Rufus::Lua::LuaError => le
+      end
+
+      expect(le.msg).to eq('tora tora tora')
+    end
+  end
+
+  describe '#set_error_handler(nil)' do
+
+    it 'unsets the current error handler' do
+
+      le = nil
+
+      # set
+
+      @s.set_error_handler(%{
+        function (e)
+          return 'something went wrong: ' .. string.gmatch(e, ": (.+)$")()
+        end
+      })
+
+      begin
+        @s.eval('error("a")')
+      rescue Rufus::Lua::LuaError => le
+      end
+
+      expect(le.msg).to eq('something went wrong: a')
+
+      # unset
+
+      @s.set_error_handler(nil)
+
+      begin
+        @s.eval('error("b")')
+      rescue Rufus::Lua::LuaError => le
+      end
+
+      expect(le.msg).to eq('[string "line"]:1: b')
+      expect(@s.send(:stack_top)).to eq(0)
+    end
+  end
+
+  describe '#set_error_handler(x)' do
+
+    it 'pops the previous handler from the stack' do
+
+      le = nil
+
+      expect(@s.send(:stack_top)).to eq(0)
+
+      @s.set_error_handler(%{ function (e) return "a" end })
+      #@s.set_error_handler(:traceback)
+      #@s.set_error_handler do |msg| return msg * 2; end
+
+      #@s.send(:print_stack)
+
+      expect(@s.send(:stack_top)).to eq(1)
+
+      @s.set_error_handler(%{ function (e) return "b" end })
+
+      #@s.send(:print_stack)
+
+      expect(@s.send(:stack_top)).to eq(1)
+
+      begin
+        @s.eval('error("Z")')
+      rescue Rufus::Lua::LuaError => le
+      end
+
+      expect(le.msg).to eq('b')
+    end
+  end
+end
+

data/spec/eval_spec.rb

@@ -72,6 +72,28 @@ describe Rufus::Lua::State do
       expect(@s.eval('return 1, 2')).to eq [ 1.0, 2.0 ]
     end
 
+    it 'returns multiple values (tables included)' do
+
+      r = @s.eval('return 1, 2, {}')
+
+      expect(r.class).to eq Array
+      expect(r[0, 2]).to eq [ 1.0, 2.0 ]
+      expect(r[2].class).to eq Rufus::Lua::Table
+      expect(r[2].size).to eq 0
+    end
+
+    it 'returns multiple values (tables included) (take 2)' do
+
+      r = @s.eval('return { "hello", "world" }, 2, { 3 }')
+
+      expect(r[0].class).to eq Rufus::Lua::Table
+      expect(r[0][1]).to eq 'hello'
+      expect(r[0][2]).to eq 'world'
+      expect(r[1]).to eq 2.0
+      expect(r[2].class).to eq Rufus::Lua::Table
+      expect(r[2][1]).to eq 3.0
+    end
+
     it 'returns false' do
 
       expect(@s.eval('return false')).to eq false
@@ -82,6 +104,17 @@ describe Rufus::Lua::State do
       expect(@s.eval('return true')).to eq true
     end
 
+    it 'returns tables' do
+
+      r = @s.eval('return { "hello", "world", 2 }')
+
+      expect(r.class).to eq Rufus::Lua::Table
+      expect(r[0]).to eq nil
+      expect(r[1]).to eq 'hello'
+      expect(r[2]).to eq 'world'
+      expect(r[3]).to eq 2.0
+    end
+
     it 'accepts a binding optional argument'
 
     it 'accepts a filename and a lineno optional arguments' do
@@ -92,6 +125,10 @@ describe Rufus::Lua::State do
       rescue Rufus::Lua::LuaError => le
       end
 
+      expect(le.kind).to eq('eval:pcall')
+      expect(le.msg).to eq('[string "/nada/virtual.lua:63"]:1: 77')
+      expect(le.errcode).to eq(2)
+
       expect(le.filename).to eq('/nada/virtual.lua')
       expect(le.lineno).to eq(63)
 
@@ -113,8 +150,11 @@ describe Rufus::Lua::State do
         expect(le.msg).to eq('[string "line"]:1: 77')
         expect(le.errcode).to eq(2)
 
+        expect(le.message).to eq(
+          "eval:pcall : '[string \"line\"]:1: 77' (2 LUA_ERRRUN)")
+
         expect(le.filename).to eq(__FILE__)
-        expect(le.lineno).to eq(__LINE__ - 9)
+        expect(le.lineno).to eq(__LINE__ - 12)
 
         expect(le.original_backtrace.first).to match(/\/lua\/state\.rb:/)
         expect(le.backtrace.first).to match(/\/eval_spec\.rb:/)

data/spec/rfunctions_spec.rb

@@ -52,6 +52,19 @@ describe Rufus::Lua::State do
       expect(message).to eq 'obandegozaimasu'
     end
 
+    it 'works with function arguments' do
+
+      message = nil
+
+      @s.function :exec do |fun|
+        message = fun.call()
+      end
+
+      @s.eval("exec(function() return 'foobar' end)")
+
+      expect(message).to eq 'foobar'
+    end
+
     it 'binds functions inside of Lua tables' do
 
       @s.eval('lib = {}')
@@ -147,11 +160,11 @@ describe Rufus::Lua::State do
     it 'raise exceptions (Ruby -> Lua -> Ruby and back)' do
 
       @s.function :do_fail do
-        raise "fail!"
+        raise 'fail!'
       end
 
       expect(lambda {
-        @s.eval("return do_fail()")
+        @s.eval('return do_fail()')
       }).to raise_error(RuntimeError)
     end
 

data/spec/string_spec.rb

@@ -41,6 +41,20 @@ describe 'lua strings' do
 
       expect(f.call(s).to_h).to eq({ 's' => s, 'l' => 8.0 })
     end
+
+    it 'accept symbols containing the \0 character' do
+
+      s = [ 65, 66, 0, 67, 0, 0, 68, 0 ].pack('c*').to_sym
+
+      f = @s.eval(%{
+        f = function(s)
+          return { s = s, l = string.len(s) }
+        end
+        return f
+      })
+
+      expect(f.call(s).to_h).to eq({ 's' => s.to_s, 'l' => 8.0 })
+    end
   end
 end
 

data/spec/utils_spec.rb

@@ -31,6 +31,15 @@ describe Rufus::Lua do
         '{ ["a"] = "A", ["b"] = 2 }'
       )
     end
+
+    it 'turns Ruby NilClass into Lua nil representation' do
+
+      expect(Rufus::Lua.to_lua_s(
+        {'a' => nil}
+      )).to eq(
+        '{ ["a"] = nil }'
+      )
+    end
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rufus-lua
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-30 00:00:00.000000000 Z
+date: 2014-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -85,6 +85,7 @@ files:
 - spec/eval_spec.rb
 - spec/state_spec.rb
 - spec/spec_base.rb
+- spec/error_handler_spec.rb
 - spec/string_spec.rb
 - spec/gc_spec.rb
 - spec/lib_spec.rb