RubyGems - rufus-lua - Versions diffs - 1.1.2 → 1.1.3 - Mend

rufus-lua 1.1.2 → 1.1.3

Files changed (32) hide show

@@ -1,222 +0,0 @@
-#
-# 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 DELETED

@@ -1,165 +0,0 @@
-#
-# Specifying rufus-lua
-#
-# Wed Mar 11 17:09:17 JST 2009
-#
-require 'spec_base'
-describe Rufus::Lua::State do
-  before do
-    @s = Rufus::Lua::State.new
-  end
-  after do
-    @s.close
-  end
-  describe '#[]' do
-    it 'returns nil for an unknown value/binding' do
-      expect(@s['unknown']).to eq nil
-    end
-  end
-  describe '#eval' do
-    it 'evals true' do
-      @s.eval('a = true')
-      expect(@s['a']).to eq true
-    end
-    it 'evals false' do
-      @s.eval('a = false')
-      expect(@s['a']).to eq false
-    end
-    it 'evals strings' do
-      @s.eval('a = "black adder"')
-      expect(@s['a']).to eq 'black adder'
-    end
-    it 'evals additions' do
-      @s.eval('a = 1 + 1')
-      expect(@s['a']).to eq 2.0
-    end
-    it 'evals nested lookups' do
-      @s.eval('a = { b = { c = 0 } }')
-      @s.eval('_ = a.b.c')
-      expect(@s['_']).to eq 0
-    end
-    #it 'returns the global environment' do
-    #  @s['_G']).to eq {}
-    #end
-    it 'returns numbers' do
-      expect(@s.eval('return 7')).to eq 7.0
-    end
-    it 'returns multiple values' 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
-    end
-    it 'returns true' 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
-      le = nil
-      begin
-        @s.eval('error(77)', nil, '/nada/virtual.lua', 63)
-      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)
-      expect(le.original_backtrace.first).to match(/\/lua\/state\.rb:/)
-      expect(le.backtrace.first).to eq('/nada/virtual.lua:63:')
-    end
-    context 'and errors' do
-      it 'makes the file and line available' do
-        le = nil
-        begin
-          @s.eval('error(77)')
-        rescue Rufus::Lua::LuaError => le
-        end
-        expect(le.kind).to eq('eval:pcall')
-        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__ - 12)
-        expect(le.original_backtrace.first).to match(/\/lua\/state\.rb:/)
-        expect(le.backtrace.first).to match(/\/eval_spec\.rb:/)
-      end
-    end
-  end
-end

data/spec/functions_spec.rb DELETED

@@ -1,119 +0,0 @@
-#
-# Specifying rufus-lua
-#
-# Wed Mar 11 17:09:17 JST 2009
-#
-require 'spec_base'
-describe Rufus::Lua::State do
-  describe 'Lua functions' do
-    before do
-      @s = Rufus::Lua::State.new
-    end
-    after do
-      @s.close
-    end
-    it 'are returned as Rufus::Lua::Function instances' do
-      expect(@s.eval('return function () end').class).to eq Rufus::Lua::Function
-    end
-    it 'are callable from Ruby' do
-      f = @s.eval(%{
-        f = function ()
-          return 77
-        end
-        return f
-      })
-      expect(f.call()).to eq 77.0
-    end
-    it 'are callable even when they return multiple values' do
-      f = @s.eval(%{
-        f = function ()
-          return 77, 44
-        end
-        return f
-      })
-      expect(f.call()).to eq [ 77.0, 44.0 ]
-    end
-    it 'are callable with arguments' do
-      f = @s.eval(%{
-        f = function (x)
-          return x * x
-        end
-        return f
-      })
-      expect(f.call(2)).to eq 4.0
-    end
-    it 'are callable with boolean arguments' do
-      f = @s.eval(%{
-        f = function (x)
-          return x
-        end
-        return f
-      })
-      expect(f.call(true)).to eq true
-      expect(f.call(false)).to eq false
-    end
-    it 'are callable with array arguments' do
-      f = @s.eval(%{
-        f = function (x)
-          return x
-        end
-        return f
-      })
-      expect(f.call(%w[ one two three ]).to_a).to eq %w[ one two three ]
-    end
-    it 'are callable with multiple arguments' do
-      f = @s.eval(%{
-        f = function (x, y)
-          return x + y
-        end
-        return f
-      })
-      expect(f.call(1, 2)).to eq 3.0
-    end
-    it 'are called with #to_lua\'ed Ruby arguments' do
-      f = @s.eval(%{
-        f = function (x)
-          return x
-        end
-        return f
-      })
-      t = Time.now
-      def t.to_lua
-        "lua:#{to_s}"
-      end
-      expect(f.call(t)).to eq t.to_lua
-    end
-  end
-end