ruby-lua 0.3.0

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.1"
+  gem "rcov", ">= 0"
+  gem "rdoc", ">=0"
+end

data/Gemfile.lock

@@ -0,0 +1,24 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    json (1.6.3)
+    rake (0.9.2.2)
+    rcov (0.9.11)
+    rdoc (3.11)
+      json (~> 1.4)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.1)
+  rcov
+  rdoc
+  shoulda

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Gregoire Lejeune
+
+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.

data/README.rdoc

@@ -0,0 +1,74 @@
+= ruby-lua
+
+Call Lua from Ruby (and Ruby from Lua in Ruby)
+
+Language::Lua - Lua interpretor for Ruby 
+
+== SYNOPSIS
+
+  require 'language/lua'
+  lua = Language::Lua.new()
+  lua.eval( "script.lua" )
+  # same as
+  lua.dofile( "script.lua" ) 
+  
+  out = lua.my_lua_function( ... )
+  print out;
+  # same as 
+  out = lua.call( "my_lua_function", ... )
+  print out;
+
+== Ruby API
+
+=== Language::Lua.new()
+
+Create a new Lua interpretor
+    
+=== Language::Lua.load( file ) or Language::Lua.dofile( file )
+
+Load a Lua Script
+
+=== Language::Lua.<lua_function>( ... )
+
+Call the Lua function named <lua_function>
+This is equivalent to 
+
+	Language::Lua.call( false, "<lua_function>", ... )
+
+=== Language::Lua.call( [true|false], "<lua_function>", ... )
+
+Call the Lua function named <lua_function>. 
+If first argument is true, the function result is not poped from the Lua Stack (default: false).
+
+=== Language::Lua.var( [true|false], "<lua_varname>", [<value>] )
+
+Return the <lua_varname> value or set the <lua_varname> if <value> is given.
+
+
+=== Language::Lua.eval( "lua_code" )
+
+Evaluate the lua_code
+
+== Lua 
+
+Ruby/Lua adds the following new method to Lua :
+
+=== ruby( "<ruby_function>", ... )
+
+In your Lua code, call <ruby_function>.
+
+== Contributing to ruby-lua
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2010 Gregoire Lejeune. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "ruby-lua"
+  gem.homepage = "http://github.com/glejeune/ruby-lua"
+  gem.license = "MIT"
+  gem.summary = %Q{Call Lua from Ruby (and Ruby from Lua in Ruby)}
+  gem.description = %Q{Call Lua from Ruby (and Ruby from Lua in Ruby)}
+  gem.email = "gregoire.lejeune@free.fr"
+  gem.authors = ["Gregoire Lejeune"]
+  gem.extensions = FileList["ext/**/extconf.rb"].to_a
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+RDoc::Task.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ruby-lua #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/examples/func.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/ruby
+
+require "../ext/lua"
+
+def my_function( str, num )
+  puts "In my_function !!!"
+  return "str = #{str} / num = #{num}"
+end
+
+lua = Language::Lua.new()
+
+lua.eval <<LUA
+  function one( )
+    return 1
+  end
+
+	function two( )
+	  return 2, 3 
+	end
+
+	function data( x )
+	  return x
+	end
+
+	function callRuby( )
+	  r = ruby( "my_function", "string", 3 )
+	  print( "r = " .. r ) 
+	end
+LUA
+
+p lua.call( true, "one" );
+  
+p lua.call( true, "two" );
+
+p lua.call( true, "data", "hello" ) 
+
+lua.callRuby

data/examples/rli.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/ruby
+
+require "../ext/lua"
+
+print "Ruby Lua Interpreter !\n"
+o = Language::Lua.new()
+
+o.load( ARGV[0] )

data/examples/test.lua

@@ -0,0 +1,21 @@
+-- defines a factorial function
+function fact (n)
+  if n == 0 then
+    return 1
+  else
+    return n * fact(n-1)
+  end
+end
+
+-- define a stupid function
+function hello( )
+  return "world"
+end
+
+-- define a string variable
+str = "blah blah blah"
+
+-- define a number variable
+num = 123
+
+fact( 3 )

data/examples/test.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/ruby
+
+require 'pp'
+require "../ext/lua"
+
+lua = Language::Lua.new()
+lua.load( "test.lua" )
+
+i = 0;
+print "BEGIN[#{i}]: -------------------------------------------------\n"
+print "Lua Stack Size = #{lua.stack_size}\n"
+lua.stack_dump
+print "END[#{i}]:   -------------------------------------------------\n"
+
+r = lua.call( "fact", 10 )
+print "call( \"fact\", 10 ) -> #{r}\n"
+
+r = lua.call( false, "fact", 8 )
+print "call( false, \"fact\", 8 ) -> #{r}\n"
+
+r = lua.call( true, "fact", 6 )
+print "call( true, \"fact\", 6 ) -> #{r}\n"
+
+r = lua.hello( )
+print "hello( ) -> #{r}\n"
+
+r = lua.var( "str" )
+print "var( \"str\" ) -> #{r}\n"
+
+r = lua.var( false, "num" )
+print "var( false, \"num\" ) -> #{r}\n"
+
+lua.var( "rdef", "Definied" )
+r = lua.var( true, "rdef" )
+print "var( true, \"rdef\" ) -> #{r}\n"
+
+lua.eval( 'print "Hello from Lua !"' )
+
+lua.eval <<LUA
+    function norm (x, y)
+      local n2 = x^2 + y^2
+      return math.sqrt(n2)
+    end
+LUA
+
+r = lua.norm( 2, 3 )
+print "norm( 2, 3 ) -> #{r}\n"
+
+
+print "BEGIN: -------------------------------------------------\n"
+print "Lua Stack Size = #{lua.stack_size}\n"
+lua.stack_dump
+print "END:   -------------------------------------------------\n"
+
+a = Array::new( )
+a[0] = 30;
+a[1] = "greg"
+lua.var( "tbl", a )
+r = lua.var( "tbl" )
+print "BEGIN: -------------------------------------------------\n"
+print "Lua Stack Size = #{lua.stack_size}\n"
+lua.stack_dump
+print "END:   -------------------------------------------------\n"
+
+print "var( \"tbl\" ) -> "; pp r
+print "BEGIN: -------------------------------------------------\n"
+print "Lua Stack Size = #{lua.stack_size}\n"
+lua.stack_dump
+print "END:   -------------------------------------------------\n"
+
+r.each { |k, v|
+  puts "#{k} => #{v}"
+}
+
+h = Hash::new( )
+h['greg'] = 30
+h['arthur'] = 6
+lua.var( "fml", h )
+r = lua.var( "fml" )
+r.each { |k, v|
+  puts "#{k} => #{v}"
+}

data/examples/tt.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/ruby
+
+require "../ext/lua"
+
+def rb_function( str, num )
+  puts "I'm a Ruby function. I was called by Lua!"
+  puts "Lua gave me the String : #{str}"
+  puts "and the Mumber : #{num}"
+  puts "So I return the string : 'Thank you Lua!'"
+  return 'Thank you Lua!'
+end
+
+puts "Hello... You are in Ruby..."
+
+Language::Lua.new() { |lua| 
+  lua.eval '
+  	function lua_function( )
+  	  print( "Yes! I\'m Lua.")
+  	  
+  	  print( "I give you a String and a Number")
+  	  r = ruby( "rb_function", "string", 3 )
+  	  
+  	  tagada="glop"
+  	  
+  	  print( "Ruby said : " .. r )
+  	  print( "- You welcome!" ) 
+  	end
+  '
+  
+  puts "Knok! Knok! Lua ?"
+  lua.lua_function()
+  puts lua.var('tagada')
+}
+
+puts "- Bye!"

data/examples/verif.lua

@@ -0,0 +1,12 @@
+-- defines a factorial function
+function fact (n)
+  if n == 0 then
+    return 1
+  else
+    return n * fact(n-1)
+  end
+end
+
+print("enter a number:")
+a = io.read("*number")        -- read a number
+print(fact(a))

data/ext/extconf.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/ruby -w
+# See the LICENSE file for copyright and distribution information
+
+require "mkmf"
+
+$LIBPATH.push(Config::CONFIG['libdir'])
+
+def crash(str)
+  printf(" extconf failure: %s\n", str)
+  exit 1
+end
+
+lib = ""
+
+#unless have_library( 'm', 'atan' )
+#  crash( 'need libm' )
+#end
+if /^1.8/.match RUBY_VERSION
+    $CFLAGS << " -DRUBY_1_8"
+end
+
+if dir_config( "lua50" ) != [nil, nil]
+   inc, lib = dir_config( 'lua50' ) 
+   $LDFLAGS << " -L#{lib} -llualib50 -llua50"
+   $CFLAGS << " -I#{inc}"
+elsif dir_config( "lua" ) != [nil, nil]
+   inc, lib = dir_config( 'lua' ) 
+   $LDFLAGS << " -L#{lib} -llualib -llua"
+   $CFLAGS << " -I#{inc}"
+elsif ex = find_executable( "lua-config" )
+   $LDFLAGS << ' ' + `#{ex} --libs`.chomp
+   $CFLAGS << ' ' + `#{ex} --include`.chomp
+elsif ex = find_executable( "pkg-config" )
+   $LDFLAGS << ' ' + `#{ex} --libs lua`.chomp
+   $CFLAGS << ' ' + `#{ex} --cflags lua`.chomp
+else
+  crash(<<EOL)
+need liblua50.
+
+        Install the library or try one of the following options to extconf.rb:
+
+        --with-lua-lib=/path/to/liblua/lib
+        --with-lua-include=/path/to/liblua/include
+		or
+        --with-lua50-lib=/path/to/liblua/lib
+        --with-lua50-include=/path/to/liblua/include
+EOL
+end
+
+if have_header( "lua.h" ) == false or have_header( "lauxlib.h" ) == false or have_header( "lualib.h" ) == false
+  crash(<<EOL)
+need liblua50 (headers not found)
+
+        Install the library or try one of the following options to extconf.rb:
+
+        --with-lua-lib=/path/to/liblua/lib
+        --with-lua-include=/path/to/liblua/include
+		or
+        --with-lua50-lib=/path/to/liblua/lib
+        --with-lua50-include=/path/to/liblua/include
+EOL
+end
+
+puts "compile with : "
+puts "  CFLAGS = #{$CFLAGS}"
+puts "  LDFLAGS = #{$LDFLAGS}"
+puts
+
+$CFLAGS = '-g -Wall ' + $CFLAGS
+
+create_header()
+create_makefile("language/lua")

data/ext/rlua.c

@@ -0,0 +1,522 @@
+/**
+ * Copyright (C) 2004 Gregoire Lejeune <gregoire.lejeune@free.fr>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ */
+
+#include "rlua.h"
+
+#define _W_STACK(L) {\
+    int i;\
+    int iStackSize = lua_gettop( L );\
+    rb_warn( "Lua stack size = %d", iStackSize );\
+    \
+    for (i = 1; i <= iStackSize; i++) {\
+      int t = lua_type(L, i);\
+      switch (t) {\
+        case LUA_TSTRING:  /* strings */\
+          printf("`%s'", lua_tostring(L, i));\
+          break;\
+      \
+        case LUA_TBOOLEAN:  /* booleans */\
+          printf(lua_toboolean(L, i) ? "true" : "false");\
+          break;\
+      \
+        case LUA_TNUMBER:  /* numbers */\
+          printf("%g", lua_tonumber(L, i));\
+          break;\
+      \
+        default:  /* other values */\
+          printf("%s", lua_typename(L, t));\
+          break;\
+      }\
+      printf("  ");  /* put a separator */\
+    }\
+    printf("\n");  /* end the listing */                \
+\
+}
+
+static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
+  (void)ud;  (void)osize;  /* not used */
+  if (nsize == 0) {
+    free(ptr);
+    return NULL;
+  } else {
+		return realloc(ptr, nsize);
+	}
+}
+
+static const char *_xSelf = "_xSelf";
+
+/**
+ * lua_SetVarToStack( lua_State *L, VALUE vVarValue )
+ *
+ * Desc: Positionne une valeur Ruby dans la pile Lua
+ */
+static void lua_SetVarToStack( lua_State *L, VALUE vVarValue ) {
+  int iStackSize;
+  long iRbArrayLength;
+  int iCpt;
+  VALUE keys;
+  
+  switch( TYPE(vVarValue) ) {
+    case T_NIL:
+      lua_pushnil( L );
+      break;
+    case T_TRUE:
+      lua_pushboolean( L, 1 );
+      break;
+    case T_FALSE:
+      lua_pushboolean( L, 0 );
+      break;
+    case T_STRING:
+      lua_pushlstring( L, RSTRING_PTR(vVarValue), RSTRING_LEN(vVarValue) );
+      break;
+    case T_FIXNUM:
+      lua_pushnumber( L, FIX2INT(vVarValue) );
+      break;
+    case T_BIGNUM:
+      lua_pushnumber( L, NUM2DBL(vVarValue) );
+      break;
+    case T_FLOAT:
+      lua_pushnumber( L, (lua_Number)RFLOAT_VALUE(vVarValue) );
+      break;
+    case T_ARRAY:
+      lua_newtable( L );
+      iStackSize = lua_gettop( L );
+      iRbArrayLength = RARRAY_LEN( vVarValue );
+      lua_pushstring( L, "n" );
+      lua_pushnumber( L, iRbArrayLength );
+      lua_settable( L, -3 );
+      for( iCpt = 0; iCpt < iRbArrayLength; iCpt++ ) {
+        lua_SetVarToStack( L, RARRAY_PTR(vVarValue)[iCpt] );
+        lua_rawseti( L, iStackSize, iCpt + 1 );
+      }
+      break;
+    case T_HASH:
+      lua_newtable( L );
+      keys = rb_funcall( vVarValue, rb_intern("keys"), 0 );
+      for( iCpt = 0; iCpt <= RARRAY_LEN(keys)-1; iCpt++ ){
+        VALUE vHashKey;
+        vHashKey = *(RARRAY_PTR(keys)+iCpt);
+        lua_pushlstring( L, RSTRING_PTR(vHashKey), RSTRING_LEN(vHashKey) );
+        lua_SetVarToStack( L, rb_hash_aref(vVarValue, vHashKey) );
+        lua_settable( L, -3 );
+      }
+      break;
+  
+    default:
+      lua_pushlightuserdata( L,(void*)vVarValue ); /* saves ruby object */
+      break;
+  }
+}
+
+/**
+ * lua_SetNamedVarFromRuby( lua_State *L, VALUE vVarName, VALUE vVarValue );
+ *
+ * Desc: Positionne une valeur nomm�e Ruby dans l'index global Lua
+ */
+static void lua_SetNamedVarFromRuby( lua_State *L, VALUE vVarName, VALUE vVarValue ) {
+  lua_pushlstring( L, RSTRING_PTR(vVarName), RSTRING_LEN(vVarName) );
+  lua_SetVarToStack( L, vVarValue );
+  lua_settable( L, LUA_GLOBALSINDEX );
+  return;
+}
+
+/**
+ * VALUE v = lua_GetVarFromStack( lua_State *L );
+ *
+ * Desc: R�cup�re la valeur au sommet de la pile Lua
+ */
+static VALUE lua_GetVarFromStack( lua_State *L ) {
+  int iStackSize = 0;
+  VALUE vTableKey = Qnil;
+  VALUE vTableValue = Qnil;
+  VALUE RCod = Qnil;
+
+  switch(lua_type(L,-1)){
+    case LUA_TNONE:
+      break;
+    case LUA_TBOOLEAN:
+      RCod = lua_toboolean(L,-1) ? Qtrue : Qfalse;
+      break;
+    case LUA_TUSERDATA:
+      RCod = (VALUE) lua_touserdata(L,-1);
+      break;
+    case LUA_TNIL:
+      break;
+    case LUA_TNUMBER:
+      RCod = rb_float_new(lua_tonumber(L,-1));
+      break;
+    case LUA_TSTRING:
+      RCod = rb_str_new2(lua_tostring(L,-1));
+      break;
+    case LUA_TTABLE:
+      RCod = rb_hash_new();
+      iStackSize = lua_gettop(L);
+      lua_pushnil(L);
+      while(lua_next(L,iStackSize) != 0){
+        vTableValue = lua_GetVarFromStack(L);
+        lua_pop(L,1);
+        vTableKey = lua_GetVarFromStack(L);
+        rb_hash_aset(RCod,vTableKey,vTableValue);
+      }
+      lua_settop(L,iStackSize);
+      break;
+    case LUA_TFUNCTION:
+      break;
+  }
+  return(RCod);
+}
+
+static int lua_CallRubyFunction( lua_State *L ) {
+  int iNbArgs = lua_gettop(L);
+  VALUE self;
+  char *xRubyFuncName;
+  ID idRubyFunc;
+  int iNbFuncArgs = 0;
+  VALUE	*vFuncArgs;
+  VALUE vFuncRCod = Qnil;
+  int iCpt;
+
+  if( iNbArgs < 1 || !lua_isstring(L, 1) ) {
+    lua_pushstring( L, "incorrect argument to function `ruby'" );
+    lua_error(L);
+  }
+
+  xRubyFuncName = (char *)lua_tostring(L, 1);
+  idRubyFunc = rb_intern( xRubyFuncName );
+  iNbFuncArgs = iNbArgs - 1;
+  lua_remove( L, 1 );
+
+  /** Act: Recuperation de self depuis la registry Lua */
+  lua_pushlightuserdata(L, (void *)&_xSelf);
+  lua_gettable(L, LUA_REGISTRYINDEX);
+  self = (VALUE)lua_touserdata(L,-1);
+  lua_pop( L, 1 );
+
+  vFuncArgs = malloc(sizeof(VALUE) * iNbFuncArgs );
+  for( iCpt = 0; iCpt < iNbFuncArgs; iCpt++ ) {
+	  vFuncArgs[iNbFuncArgs - iCpt - 1] = lua_GetVarFromStack( L );
+	  lua_remove( L, -1 );
+  }
+
+  vFuncRCod = rb_funcall2( self, idRubyFunc, iNbFuncArgs, vFuncArgs );
+  lua_SetVarToStack( L, vFuncRCod );
+  
+  return 1;
+}
+
+/** ------------------------------------------------------------------------ */
+
+/**
+ * VALUE v = ruby_CallLuaFunction( char *xFunctionName, int iNbArgs, VALUE *vArgs, VALUE self )
+ *
+ * Desc: Appel la fonction Lua xFunctionName avec les param�tres contenu dans vArgs
+ *       et retourne le r�sultat
+ */
+static VALUE ruby_CallLuaFunction( char *xFunctionName, int iNbArgs, VALUE *vArgs, VALUE self ) {
+  RbTlua *pRbTlua;
+  int iCpt;
+  VALUE RCod = Qnil;
+
+  Data_Get_Struct( self, RbTlua, pRbTlua );
+
+  lua_getglobal( pRbTlua->L, xFunctionName );  /* get function */
+
+  for( iCpt = 0; iCpt < iNbArgs; iCpt++ ) {
+    lua_SetVarToStack( pRbTlua->L, vArgs[iCpt] );
+  }
+
+  if( lua_pcall( pRbTlua->L, iNbArgs, 1, 0 ) != 0 )  /* do the call */
+    rb_raise( rb_eSystemCallError, "error running lua function `%s': %s", xFunctionName, lua_tostring(pRbTlua->L, -1) );
+
+  RCod = lua_GetVarFromStack( pRbTlua->L );
+  
+  return( RCod );
+}
+
+/** ------------------------------------------------------------------------ */
+
+/**
+ * Desc: Destructeur de class
+ */
+void ruby_lua_free( RbTlua *pRbTlua ) {
+  if (pRbTlua != NULL) {
+    lua_close(pRbTlua->L);
+    free(pRbTlua);
+  }
+}
+
+/**
+ * Desc: mark
+ */
+void ruby_lua_mark( RbTlua *pRbTlua ) {
+  if( pRbTlua == NULL ) return;
+//  if( !NIL_P(pRbTlua->xXmlData) ) rb_gc_mark( pRbTlua->xXmlData );
+
+  return;
+}
+
+/** 
+ * o = Language::Lua.new() 
+ *
+ * Desc: Constructeur de class
+ */
+VALUE ruby_lua_new( VALUE class ) {
+  VALUE self; 
+  RbTlua *pRbTlua;
+
+  pRbTlua = (RbTlua *)malloc(sizeof(RbTlua));
+  if( pRbTlua == NULL )
+    rb_raise( rb_eNoMemError, "No memory left for Lua struct" );
+      
+  pRbTlua->L = lua_newstate(l_alloc, pRbTlua->ud);
+	luaL_openlibs(pRbTlua->L);
+
+  lua_register( pRbTlua->L, "ruby", lua_CallRubyFunction );
+  
+  self = Data_Wrap_Struct( class, ruby_lua_mark, ruby_lua_free, pRbTlua );
+  
+  /** Act: On place self dans la Registry Lua */
+  lua_pushlightuserdata( pRbTlua->L, (void *)&_xSelf );
+  lua_pushlightuserdata( pRbTlua->L, (void *)self );
+  lua_settable( pRbTlua->L, LUA_REGISTRYINDEX );
+
+	if(rb_block_given_p()) {
+		rb_yield(self);
+	}
+
+  return( self );
+}  
+
+/** 
+ * lua.load( "script.lua" ) 
+ * lua.dofile( "script.lua" ) 
+ *
+ * Desc: Charge un script Lua
+ */
+VALUE ruby_lua_load( VALUE self, VALUE xOutFilename ) {
+  RbTlua *pRbTlua;
+  Data_Get_Struct( self, RbTlua, pRbTlua );
+
+  if( luaL_loadfile( pRbTlua->L, StringValuePtr( xOutFilename ) ) || lua_pcall( pRbTlua->L, 0, 0, 0 ) ) {
+    rb_raise( rb_eSystemCallError, "cannot run file %s !", lua_tostring( pRbTlua->L, -1 ) );
+  }
+
+  return( Qnil );
+}
+
+/** 
+ * v = lua.<lua_method>( ... ) 
+ *
+ * Desc: Appel la fonction Lua <lua_method> et renvoi le r�sultat 
+ *       en le supprimant de la stack
+ */
+VALUE ruby_lua_method_missing(int iNbArgs, VALUE *vArgs, VALUE self) {
+  VALUE RCod = Qnil;
+  RbTlua *pRbTlua;
+  Data_Get_Struct( self, RbTlua, pRbTlua );
+
+  RCod = ruby_CallLuaFunction( (char*)rb_id2name(SYM2ID(vArgs[0])), iNbArgs - 1, vArgs + 1, self );
+  lua_pop( pRbTlua->L, 1 );
+
+  return( RCod );
+}
+
+/**
+ * v = lua.call( [true|false], "<lua_method>", ... )
+ *
+ * Desc: Appel la fonction Lua <lua_method> et renvoi le r�sultat 
+ *       en le conservant dant la stack si le premier argument est true 
+ */
+VALUE ruby_lua_call(int iNbArgs, VALUE *vArgs, VALUE self) {
+  VALUE RCod = Qnil;
+  RbTlua *pRbTlua;
+  Data_Get_Struct( self, RbTlua, pRbTlua );
+
+  switch( TYPE( vArgs[0] ) ) {
+    case T_TRUE:
+      RCod = ruby_CallLuaFunction( StringValuePtr(vArgs[1]), iNbArgs - 2, vArgs + 2, self );
+      break;
+      
+    case T_FALSE:
+      RCod = ruby_CallLuaFunction( StringValuePtr(vArgs[1]), iNbArgs - 2, vArgs + 2, self );
+      lua_pop( pRbTlua->L, 1 );
+      break;
+      
+    case T_STRING:
+      RCod = ruby_CallLuaFunction( StringValuePtr(vArgs[0]), iNbArgs - 1, vArgs + 1, self );
+      lua_pop( pRbTlua->L, 1 );
+      break;
+    
+    default:
+      rb_raise( rb_eArgError, "Language::Lua.call argument error !" );
+  }
+
+  return( RCod );
+}
+
+/**
+ * v = lua.var( [true|false], "<lua_varname>", [<value>] )
+ *
+ * Desc: Retourne la valeur de la valiable Lua <lua_varname>
+ *       en le conservant dans la stack si le premier argument est true .
+ *       Ou positionne la valeur de 
+ */
+VALUE ruby_lua_var( int iNbArgs, VALUE *vArgs, VALUE self ) {
+  VALUE RCod = Qnil;
+  RbTlua *pRbTlua;
+  Data_Get_Struct( self, RbTlua, pRbTlua );
+
+  switch( TYPE( vArgs[0] ) ) {
+    case T_TRUE:
+      if( iNbArgs == 2 ) {
+        /** Act: Recup�re la valeur */
+        lua_getglobal( pRbTlua->L, StringValuePtr(vArgs[1]) );
+        RCod = lua_GetVarFromStack( pRbTlua->L );
+      } else if( iNbArgs == 3 ) {
+        /** Positionne la valeur */
+        lua_SetNamedVarFromRuby( pRbTlua->L, vArgs[1], vArgs[2] );
+      } else {
+        rb_raise( rb_eArgError, "Language::Lua.var argument error !" );
+      }
+      break;
+      
+    case T_FALSE:
+      if( iNbArgs == 2 ) {
+        /** Act: Recup�re la valeur */
+        lua_getglobal( pRbTlua->L, StringValuePtr(vArgs[1]) );
+        RCod = lua_GetVarFromStack( pRbTlua->L );
+        lua_pop( pRbTlua->L, 1 );
+      } else if( iNbArgs == 3 ) {
+        /** Positionne la valeur */
+        lua_SetNamedVarFromRuby( pRbTlua->L, vArgs[1], vArgs[2] );
+      } else {
+        rb_raise( rb_eArgError, "Language::Lua.var argument error !" );
+      }
+      break;
+      
+    case T_STRING:
+      if( iNbArgs == 1 ) {
+        /** Act: Recup�re la valeur */
+        lua_getglobal( pRbTlua->L, StringValuePtr(vArgs[0]) );
+        RCod = lua_GetVarFromStack( pRbTlua->L );
+        lua_pop( pRbTlua->L, 1 );
+      } else if( iNbArgs == 2 ) {
+        /** Positionne la valeur */
+        lua_SetNamedVarFromRuby( pRbTlua->L, vArgs[0], vArgs[1] );
+      } else {
+        rb_raise( rb_eArgError, "Language::Lua.var argument error !" );
+      }
+      break;
+    
+    default:
+      rb_raise( rb_eArgError, "Language::Lua.var argument error !" );
+  }
+
+  return( RCod );
+}
+
+/** 
+ * lua.eval( "<lua_code>" ) 
+ *
+ * Desc: Evalue le code Lua <lua_code>
+ */
+VALUE ruby_lua_eval( VALUE self, VALUE xLuaCode ) {
+  char *pszLuaCode; 
+  RbTlua *pRbTlua;
+  Data_Get_Struct( self, RbTlua, pRbTlua );
+  
+  pszLuaCode = StringValuePtr( xLuaCode );
+  if( luaL_loadbuffer( pRbTlua->L, pszLuaCode, strlen(pszLuaCode), "line" ) || lua_pcall(pRbTlua->L, 0, 0, 0) ) {
+    rb_raise( rb_eSystemCallError, "Lua error: %s", lua_tostring( pRbTlua->L, -1 ) );
+  }
+
+  return( Qnil );
+}
+
+/**
+ * v = lua.stackSize( )
+ *
+ * Desc: Retourne la taille de la stack Lua
+ */
+VALUE ruby_lua_stack_size( VALUE self ) {
+  RbTlua *pRbTlua;
+  Data_Get_Struct( self, RbTlua, pRbTlua );
+  
+  return( INT2NUM( lua_gettop( pRbTlua->L ) ) );
+}
+
+/**
+ * lua.stackDump( )
+ *
+ * Desc: Dump le contenu de la stack sur la sortie standard
+ */
+VALUE ruby_lua_stack_dump( VALUE self ) {
+  RbTlua *pRbTlua;
+  int i;
+  int iStackSize;
+  
+  Data_Get_Struct( self, RbTlua, pRbTlua );
+  
+  iStackSize = lua_gettop(pRbTlua->L);
+  for (i = 1; i <= iStackSize; i++) {  /* repeat for each level */
+    int t = lua_type(pRbTlua->L, i);
+    switch (t) {
+      case LUA_TSTRING:  /* strings */
+        printf("%04d: `%s'\n", i, lua_tostring(pRbTlua->L, i));
+        break;
+    
+      case LUA_TBOOLEAN:  /* booleans */
+        printf("%04d: %s\n", i, (lua_toboolean(pRbTlua->L, i) ? "true" : "false"));
+        break;
+    
+      case LUA_TNUMBER:  /* numbers */
+        printf("%04d: %g\n", i, lua_tonumber(pRbTlua->L, i));
+        break;
+    
+      default:  /* other values */
+        printf("%04d: #%s\n", i, lua_typename(pRbTlua->L, t));
+        break;
+    }
+  }
+
+  return( Qnil );
+}
+
+/** ------------------------------------------------------------------------ */
+
+VALUE mLanguage;
+VALUE cLua;
+
+void Init_lua( void ) {
+  mLanguage  = rb_define_module( "Language" );
+  cLua = rb_define_class_under( mLanguage, "Lua", rb_cObject );
+
+  rb_define_const( cLua, "RUBY_LUA_VERSION", rb_str_new2( RUBY_LUA_VERSION ) );
+
+  rb_define_singleton_method( cLua, "new", ruby_lua_new, 0 );
+
+  rb_define_method( cLua, "load",           ruby_lua_load,            1 );
+  rb_define_method( cLua, "dofile",         ruby_lua_load,            1 );
+  rb_define_method( cLua, "method_missing", ruby_lua_method_missing, -1 );
+  rb_define_method( cLua, "call",           ruby_lua_call,           -1 );
+  rb_define_method( cLua, "var",            ruby_lua_var,            -1 );
+  rb_define_method( cLua, "eval",           ruby_lua_eval,            1 );
+  
+  rb_define_method( cLua, "stack_size",      ruby_lua_stack_size,      0 );
+  rb_define_method( cLua, "stack_dump",      ruby_lua_stack_dump,      0 );
+}

data/ext/rlua.h

@@ -0,0 +1,48 @@
+/**
+ * Copyright (C) 2004 Gregoire Lejeune <gregoire.lejeune@free.fr>
+ * 
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
+ */
+
+/* Please see the LICENSE file for copyright and distribution information */
+
+#ifndef __RUBY_LUA_H__
+#define __RUBY_LUA_H__
+
+#include <ruby.h>
+#ifdef RUBY_1_8
+#include <rubyio.h>
+#else
+#include <ruby/io.h>
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+
+#define RUBY_LUA_VERSION  "0.2.0"
+#define RUBY_LUA_VERNUM   020
+
+typedef struct RbTlua {
+  lua_State *L;
+	void *ud;
+} RbTlua;
+
+#endif

data/test/helper.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'ruby-lua'
+
+class Test::Unit::TestCase
+end

data/test/test_ruby-lua.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestRubyLua < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-lua
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: 
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
+platform: ruby
+authors: 
+- Gregoire Lejeune
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-14 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: shoulda
+  prerelease: false
+  type: :development
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  name: bundler
+  prerelease: false
+  type: :development
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 1
+        - 5
+        - 1
+        version: 1.5.1
+  name: jeweler
+  prerelease: false
+  type: :development
+  requirement: *id003
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rcov
+  prerelease: false
+  type: :development
+  requirement: *id004
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rdoc
+  prerelease: false
+  type: :development
+  requirement: *id005
+description: Call Lua from Ruby (and Ruby from Lua in Ruby)
+email: gregoire.lejeune@free.fr
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- examples/func.rb
+- examples/luac.out
+- examples/rli.rb
+- examples/test.lua
+- examples/test.rb
+- examples/tt.rb
+- examples/verif.lua
+- ext/extconf.rb
+- ext/rlua.c
+- ext/rlua.h
+- test/helper.rb
+- test/test_ruby-lua.rb
+homepage: http://github.com/glejeune/ruby-lua
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Call Lua from Ruby (and Ruby from Lua in Ruby)
+test_files: 
+- examples/func.rb
+- examples/rli.rb
+- examples/test.rb
+- examples/tt.rb
+- test/helper.rb
+- test/test_ruby-lua.rb