rufus-lua 1.1.0 → 1.1.1

data/spec/lib_spec.rb

@@ -0,0 +1,32 @@
+
+#
+# Specifying rufus-lua
+#
+# Thu Jun 19 20:29:06 JST 2014
+#
+
+require 'spec_base'
+
+
+describe Rufus::Lua::Lib do
+
+  describe '.path' do
+
+    it 'returns the Lua lib being used' do
+
+      path =
+        Array(
+          Dir.glob('/usr/lib/liblua*.so') +
+          Dir.glob('/usr/lib/*/liblua*.so') +
+          Dir.glob('/usr/local/lib/liblua*.so') +
+          Dir.glob('/opt/local/lib/liblua*.so') +
+          Dir.glob('/usr/lib/liblua*.dylib') +
+          Dir.glob('/usr/local/lib/liblua*.dylib') +
+          Dir.glob('/opt/local/lib/liblua*.dylib')
+        ).first
+
+      expect(Rufus::Lua::Lib.path).to eq path
+    end
+  end
+end
+

data/spec/rfunctions_spec.rb

@@ -0,0 +1,282 @@
+
+#
+# Specifying rufus-lua
+#
+# Wed Mar 18 17:53:06 JST 2009
+#
+
+require 'spec_base'
+
+
+describe Rufus::Lua::State do
+
+  before do
+    @s = Rufus::Lua::State.new
+  end
+  after do
+    @s.close
+  end
+
+  describe '#function' do
+
+    it 'raises when no block is given' do
+
+      expect(lambda {
+        @s.function 'no_block'
+      }).to raise_error(RuntimeError)
+    end
+
+    it 'works without arguments' do
+
+      blinked = false
+
+      @s.function 'blink' do
+        blinked = true
+      end
+
+      @s.eval('blink()')
+
+      expect(blinked).to eq true
+    end
+
+    it 'works with arguments' do
+
+      message = nil
+
+      @s.function :greet do |msg|
+        message = msg
+      end
+
+      @s.eval("greet('obandegozaimasu')")
+
+      expect(message).to eq 'obandegozaimasu'
+    end
+
+    it 'binds functions inside of Lua tables' do
+
+      @s.eval('lib = {}')
+      @s.function 'lib.myfunc' do |x|
+        x + 2
+      end
+
+      expect(@s.eval("return lib.myfunc(3)")).to eq 5.0
+    end
+
+    it 'creates the top Lua table if not present' do
+
+      @s.function 'lib.myfunc' do |x|
+        x + 2
+      end
+
+      expect(@s.eval("return lib.myfunc(3)")).to eq 5.0
+    end
+
+    it 'only creates the top table (not intermediary tables)' do
+
+      expect(lambda {
+        @s.function('lib.toto.myfunc') { |x| x + 2 }
+      }).to raise_error(ArgumentError)
+    end
+  end
+
+  describe 'calling a Ruby function from Lua' do
+
+    it 'may return a single value' do
+
+      @s.function :greet do
+        'hello !'
+      end
+
+      expect(@s.eval('return greet()')).to eq 'hello !'
+    end
+
+    it 'may return multiple values' do
+
+      @s.function :compute do
+        [ 'a', true, 1 ]
+      end
+
+      expect(@s.eval('return compute()').to_a).to eq [ 'a', true, 1.0 ]
+    end
+
+    it 'may return tables' do
+
+      @s.function :compute do
+        { 'a' => 'alpha', 'z' => 'zebra' }
+      end
+
+      expect(@s.eval('return compute()').to_h).to eq(
+        { 'a' => 'alpha', 'z' => 'zebra' })
+    end
+
+    it 'may return tables (with nested arrays)' do
+
+      @s.function :compute do
+        { 'a' => 'alpha', 'z' => [ 1, 2, 3 ] }
+      end
+
+      expect(@s.eval('return compute()').to_h['z'].to_a).to eq [ 1.0, 2.0, 3.0 ]
+    end
+
+    it 'accepts hashes as arguments' do
+
+      @s.function :to_json do |h|
+        "{" + h.collect { |k, v| "#{k}:\"#{v}\"" }.join(",") + "}"
+      end
+
+      expect(@s.eval(
+        "return to_json({ a = 'ALPHA', b = 'BRAVO' })"
+      )).to eq(
+        '{a:"ALPHA",b:"BRAVO"}'
+      )
+    end
+
+    it 'accepts arrays as arguments' do
+
+      @s.function :do_join do |a|
+        a.to_a.join(', ')
+      end
+
+      expect(@s.eval(
+        "return do_join({ 'alice', 'bob', 'charly' })"
+      )).to eq(
+        'alice, bob, charly'
+      )
+    end
+
+    it 'raise exceptions (Ruby -> Lua -> Ruby and back)' do
+
+      @s.function :do_fail do
+        raise "fail!"
+      end
+
+      expect(lambda {
+        @s.eval("return do_fail()")
+      }).to raise_error(RuntimeError)
+    end
+
+    it 'counts the animals correctly' do
+
+      @s.function 'key_up' do |table|
+        table.inject({}) do |h, (k, v)|
+          h[k.to_s.upcase] = v; h
+        end
+      end
+
+      expect(@s.eval(%{
+        local table = {}
+        table['CoW'] = 2
+        table['pigs'] = 3
+        table['DUCKS'] = 'none'
+        return key_up(table)
+      }).to_h).to eq(
+        { 'COW' => 2.0, 'DUCKS' => 'none', 'PIGS' => 3.0 }
+      )
+    end
+
+    it 'returns Ruby arrays as Lua tables' do
+
+      @s.function :get_data do |msg|
+        %w[ one two three ]
+      end
+
+      @s.eval('data = get_data()')
+
+      expect(@s['data'].to_a).to eq %w[ one two three ]
+      expect(@s.eval('return type(data)')).to eq('table')
+    end
+
+    it 'return properly indexed Lua tables' do
+
+      @s.function :get_data do |msg|
+        %w[ one two three ]
+      end
+
+      @s.eval('data = get_data()')
+
+      expect(@s.eval('return data[0]')).to eq nil
+      expect(@s.eval('return data[1]')).to eq 'one'
+    end
+
+    it 'accepts more than 1 arg and order the args correctly' do
+
+      @s.function 'myfunc' do |a, b, c|
+        "#{a}_#{b}_#{c}"
+      end
+
+      expect(@s.eval("return myfunc(1, 2, 3)")).to eq '1.0_2.0_3.0'
+    end
+
+    it 'accepts optional arguments' do
+
+      @s.function 'myfunc' do |a, b, c|
+        "#{a}_#{b}_#{c}"
+      end
+
+      expect(@s.eval("return myfunc(1)")).to eq '1.0__'
+    end
+
+    it 'is ok when there are too many args' do
+
+      @s.function 'myfunc' do |a, b|
+        "#{a}_#{b}"
+      end
+
+      expect(@s.eval("return myfunc(1, 2, 3)")).to eq '1.0_2.0'
+    end
+
+    it 'passes Float arguments correctly' do
+
+      @s.function 'myfunc' do |a|
+        "#{a.class} #{a}"
+      end
+
+      expect(@s.eval("return myfunc(3.14)")).to eq 'Float 3.14'
+    end
+
+    it 'preserves arguments' do
+
+      @s.function 'check_types' do |t, s, f, h, a|
+
+        #p [ t, s, f, h, a ]
+
+        (t.is_a?(TrueClass) &&
+         s.is_a?(String) &&
+         f.is_a?(Float) &&
+         h.is_a?(Rufus::Lua::Table) &&
+         a.is_a?(Rufus::Lua::Table))
+      end
+
+      expect(@s.eval(
+        "return check_types(true, 'foobar', 3.13, {a='ay',b='bee'}, {'one','two','three'})"
+      )).to eq true
+    end
+
+    it 'honours to_ruby=true' do
+
+      @s.function 'check_types', :to_ruby => true do |t, s, f, h, a|
+
+        #p [ t, s, f, h, a ]
+
+        (t.is_a?(TrueClass) &&
+         s.is_a?(String) &&
+         f.is_a?(Float) &&
+         h.is_a?(Hash) &&
+         a.is_a?(Array))
+      end
+
+      expect(@s.eval(
+        "return check_types(true, 'foobar', 3.13, {a='ay',b='bee'}, {'one','two','three'})"
+      )).to eq true
+    end
+
+    it 'protects callbacks from GC' do
+
+      @s.function 'myfunc' do |a|
+      end
+
+      expect(@s.instance_variable_get(:@callbacks).size).to eq 1
+    end
+  end
+end
+

data/spec/spec_base.rb

@@ -0,0 +1,10 @@
+
+#
+# Specifying rufus-lua
+#
+# Wed Mar 11 16:09:31 JST 2009
+#
+
+require 'fileutils'
+require 'rufus-lua'
+

data/spec/state_spec.rb

@@ -0,0 +1,106 @@
+
+#
+# Specifying rufus-lua
+#
+# Mon Mar 16 23:38:00 JST 2009
+#
+
+require 'spec_base'
+
+
+describe Rufus::Lua::State do
+
+  describe '#new' do
+
+    it 'loads all libs by default' do
+
+      @s = Rufus::Lua::State.new
+      expect(@s.eval('return os;')).not_to be nil
+      @s.close
+    end
+
+    it 'loads no libs when told so' do
+
+      @s = Rufus::Lua::State.new(false)
+      expect(@s.eval('return os;')).to be nil
+      @s.close
+    end
+
+    it 'loads only specific libs when told so' do
+
+      @s = Rufus::Lua::State.new([ :os, :math ])
+      expect(@s.eval('return io;')).to be nil
+      expect(@s.eval('return os;')).not_to be nil
+      @s.close
+    end
+  end
+
+  describe '#close' do
+
+    it 'does not crash when closing an already closed State' do
+
+      @s = Rufus::Lua::State.new
+      @s.close
+
+      expect(lambda { @s.close }).to raise_error(RuntimeError)
+    end
+  end
+
+  describe '#[]' do
+
+    before do
+      @s = Rufus::Lua::State.new
+    end
+    after do
+      @s.close
+    end
+
+    it 'return nils for unbound variables' do
+
+      expect(@s['a']).to be nil
+    end
+
+    it 'accepts setting values directly' do
+
+      @s['a'] = 1
+      @s['a'] == 1
+    end
+
+    it 'accepts setting array values directly' do
+
+      @s['a'] = [ true, false, %w[ alpha bravo charly ] ]
+
+      expect(@s['a'].to_a[0]).to be true
+      expect(@s['a'].to_a[2].to_a).to eq %w[ alpha bravo charly ]
+    end
+
+    it 'accepts setting hash values directly' do
+
+      @s['a'] = { 'a' => 'alpha', 'b' => 'bravo' }
+
+      expect(@s['a'].to_h).to eq({ 'a' => 'alpha', 'b' => 'bravo' })
+    end
+  end
+
+  context 'gh-6 panic: unprotected error' do
+
+    it 'does not happen when loading io alone' do
+
+      state = Rufus::Lua::State.new(%w[ io ])
+
+      expect(state.eval('return io;')).not_to be nil
+      expect(state.eval('return math;')).to be nil
+      state.close
+    end
+
+    it 'does not happen' do
+
+      state = Rufus::Lua::State.new(%w[ base table string math package ])
+
+      expect(state.eval('return table;')).not_to be nil
+      expect(state.eval('return math;')).not_to be nil
+      state.close
+    end
+  end
+end
+

data/spec/string_spec.rb

@@ -0,0 +1,46 @@
+
+#
+# Specifying rufus-lua
+#
+# Sat Jun 21 11:04:02 JST 2014
+#
+
+require 'spec_base'
+
+# adapted from https://github.com/jmettraux/rufus-lua/issues/14
+
+
+describe 'lua strings' do
+
+  context 'and \0 bytes' do
+
+    before :each do
+      @s = Rufus::Lua::State.new
+    end
+    after :each do
+      @s.close
+    end
+
+    it 'are not truncated when returned to Ruby' do
+
+      s = @s.eval('return string.char(1, 0, 0, 2, 0, 0)')
+
+      expect(s.bytes.to_a).to eq([ 1, 0, 0, 2, 0, 0 ])
+    end
+
+    it 'are not truncated when passed from Ruby to Lua and back' do
+
+      s = [ 65, 66, 0, 67, 0, 0, 68, 0 ].pack('c*')
+
+      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, 'l' => 8.0 })
+    end
+  end
+end
+