rufus-lua 1.1.0 → 1.1.1

data/lib/rufus/lua/utils.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2009, John Mettraux, Alain Hoang.
+# Copyright (c) 2009-2014, John Mettraux, Alain Hoang.
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -39,7 +39,7 @@ module Rufus::Lua
   #     #
   #     # => '{ "a": "A", "b": 2 }'
   #
-  def self.to_lua_s (o)
+  def self.to_lua_s(o)
 
     case o
 
@@ -62,7 +62,7 @@ module Rufus::Lua
   # Turns a Ruby Array or Hash instance into a Lua parseable string
   # representation.
   #
-  def self.to_lua_table_s (o)
+  def self.to_lua_table_s(o)
 
     s = if o.is_a?(Array)
       o.collect { |e| to_lua_s(e) }

data/lib/rufus/lua/version.rb

@@ -0,0 +1,32 @@
+#--
+# Copyright (c) 2009-2014, John Mettraux, Alain Hoang.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+module Rufus
+module Lua
+
+  VERSION = '1.1.1'
+end
+end
+

data/rufus-lua.gemspec

@@ -0,0 +1,36 @@
+
+Gem::Specification.new do |s|
+
+  s.name = 'rufus-lua'
+
+  s.version = File.read(
+    File.expand_path('../lib/rufus/lua/version.rb', __FILE__)
+  ).match(/ VERSION *= *['"]([^'"]+)/)[1]
+
+  s.platform = Gem::Platform::RUBY
+  s.authors = [ 'John Mettraux', 'Alain Hoang', 'Scott Persinger' ]
+  s.email = [ 'jmettraux@gmail.com' ]
+  s.homepage = 'https://github.com/jmettraux/rufus-lua'
+  s.rubyforge_project = 'rufus'
+  s.license = 'MIT'
+  s.summary = 'ruby-ffi based bridge from Ruby to Lua'
+
+  s.description = %{
+ruby-ffi based bridge from Ruby to Lua
+  }.strip
+
+  #s.files = `git ls-files`.split("\n")
+  s.files = Dir[
+    'Rakefile',
+    'lib/**/*.rb', 'spec/**/*.rb', 'test/**/*.rb',
+    '*.gemspec', '*.txt', '*.rdoc', '*.md'
+  ]
+
+  s.add_dependency 'ffi', '~> 1.9'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec', '>= 2.13.0'
+
+  s.require_path = 'lib'
+end
+

data/spec/coroutines_spec.rb

@@ -0,0 +1,90 @@
+
+#
+# Specifying rufus-lua
+#
+# Sat Mar 14 23:51:42 JST 2009
+#
+
+require 'spec_base'
+
+
+describe Rufus::Lua::State do
+
+  describe 'a Lua coroutine' do
+
+    before do
+      @s = Rufus::Lua::State.new
+    end
+    after do
+      @s.close
+    end
+
+    it 'can be returned to Ruby' do
+
+      expect(@s.eval(
+        'return coroutine.create(function (x) end)'
+      ).class).to eq(Rufus::Lua::Coroutine)
+    end
+
+    it 'has a status visible from Ruby' do
+
+      co = @s.eval(
+        'return coroutine.create(function (x) end)'
+      )
+      expect(co.status).to eq('suspended')
+    end
+
+    it 'can be resumed from Ruby' do
+
+      @s.eval(%{
+        co = coroutine.create(function (x)
+          while true do
+            coroutine.yield(x)
+          end
+        end)
+      })
+      expect(@s['co'].resume(7)).to eq [ true, 7.0 ]
+      expect(@s['co'].resume()).to eq [ true, 7.0 ]
+    end
+
+    it 'can be resumed from Ruby (and is not averse to \0 bytes)' do
+
+      @s.eval(%{
+        co = coroutine.create(function (x)
+          while true do
+            coroutine.yield(x)
+          end
+        end)
+      })
+      s = [ 0, 64, 0, 0, 65, 0 ].pack('c*')
+      expect(@s['co'].resume(s)).to eq [ true, s ]
+      expect(@s['co'].resume()).to eq [ true, s ]
+    end
+
+    # compressed version of the spec proposed by Nathanael Jones
+    # in https://github.com/nathanaeljones/rufus-lua/commit/179184aS
+    #
+    # for https://github.com/jmettraux/rufus-lua/issues/19
+    #
+    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)
+        return { a, b }
+      }).to_ruby
+
+      expect(r).to eq([ true, 'success' ])
+    end
+  end
+end
+

data/spec/eval_spec.rb

@@ -0,0 +1,125 @@
+
+#
+# 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 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 '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.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.filename).to eq(__FILE__)
+        expect(le.lineno).to eq(__LINE__ - 9)
+
+        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

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

data/spec/gc_spec.rb

@@ -0,0 +1,41 @@
+
+#
+# Specifying rufus-lua
+#
+# Mon Mar 16 23:07:49 JST 2009
+#
+
+require 'spec_base'
+
+
+describe Rufus::Lua::State do
+
+  before do
+    @s = Rufus::Lua::State.new
+  end
+  after do
+    @s.close
+  end
+
+  describe '#gc_collect!' do
+
+    it 'raises when called on a closed Rufus::Lua::State instance' do
+
+      s = Rufus::Lua::State.new
+      s.close
+      expect(lambda { s.gc_collect! }).to raise_error(RuntimeError)
+    end
+  end
+
+  describe '#gc_count' do
+
+    it 'returns an indication about the Lua interpreter memory usage' do
+
+      before_usage = @s.gc_count
+      @s.eval("return table.concat({ 'hello', 'from', 'Lua' }, ' ')")
+      after_usage = @s.gc_count
+
+      expect(after_usage).to be > before_usage
+    end
+  end
+end