How can I convert Ruby to Lua?

Question

Is there any way to automatically convert Ruby code to Lua? My question is:

1. What kinds of tools exist for this purpose?
2. What are their limitations?

One primary goal of this is to be able to bypass the Ruby interpreter when I execute the (converted to) Lua program. I don't mind if the Ruby interpreter needs to be invoked during the conversion process to Lua, but I don't want to have to rely on the Ruby interpreter when I run the newly generated Lua code.

---

UPDATE:

I've done quite a bit research into this topic and I personally am not finding a solution (which is why I'm asking the question here on StackOverflow).

In case anyone is curious, I've looked deeply into:

• Ruby-Lua, though all this does is allow you to call Lua from Ruby
• RLua, this allows you to run Ruby code from Lua and vise versa but it's not translating Ruby to Lua and it still invokes the Ruby interpreter on program run.

Answer 1

I'm sorry if this is not the answer you want to hear, but there is no practical way to do it, pal. I'm not going to say Ruby is richer than Lua, as I haven't studied the latter enough to say that, but from what I know and what I see,

1. There is no way anyone would have bothered writing Ruby compiler to Lua and similar languages.
2. There is no way writing such compiler would take you shorter time than rewriting your program manually.
3. The only language Ruby community cares about compiling Ruby into, is Ruby bytecode.

One could go on an on on what the possibilities are and are not of compiling high level languages into one another, but the bottom line for you is: Give up early. Stop searching and start rewriting your progs manually.

Answer 2

^{Note: I agree with everyone else here, that you really should just re-write your program from scratch. This answer is just an idea, that I hope someone will look into really.}

There are already a few Ruby-to-X converters that could you could bootstrap. The good ones already have a lexer & parsers, so you'd only need to work with the backend. If you choose a language similar to Lua then you could simplify things even more.

For example, there are a few Ruby-to-Javascript implementations, like RubyJS. Putting aside metamethods, self syntactic sugar, library differences, and a few semantic differences here and there, Lua could be seen as a subset of Javascript with a more verbose syntax.

With that in mind, you could modify most of the backend generator by changing a few { }s here and there:

// some random js
while(x < 56 && y == 40) {
  print('Hello World!');
}

 

-- What you could make it generate:
while x < 56 and y == 40 do
  print 'Hello World!'
end

Perhaps there may be a few times when it relies upon Javascript specific features, but even then, most of them could be emulated.

// Javascript has a === operator that enforces type equality
'5' === 5 // FALSE!

 

-- Lua lacks this, but it's easy to imitate
(type('5') == type(5)) and ('5' == 5)

No, honestly, this wouldn't be an easy project, but I think it's something definetly worth investing the time in. I hope this helps! :)

Answer 3

Universal-transpiler is a library for SWI-Prolog that can convert a small subset of Ruby into Lua and several other languages.

This is an example of its usage in Prolog, with Ruby source code as its input:

:- use_module(library(transpiler)).
:- set_prolog_flag(double_quotes,chars).
:- initialization(main).

main :- 
    translate("def add(a,b) return a + b end def squared(a) return a*a end def add_exclamation_point(parameter) return parameter + \"!\" end",'ruby','lua',X),
    atom_chars(Y,X),
    writeln(Y).

...and this is the Lua source code that it generates:

function add(a,b) 
        return a..b
end 
function squared(a) 
        return a*a
end 
function add_exclamation_point(parameter) 
        return parameter.."!"
end