julializer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6b642dd1c03b8303e02dc986ef75b05e734310ed
+  data.tar.gz: c8e5c67d459b55cd43931fe89c668321196ca473
+SHA512:
+  metadata.gz: ba346042cb89c7ff9ff2e90b0a2100e897f59ce672f30ac41edcb4fc8a4b88e30353d4097bcb94236ba087645d46b06a01489c5dfbfbd933b1115474417dcd1e
+  data.tar.gz: d8d2be6a6149114f545c54b415dce47e717f3662e1658b464a8c8dd58096a0ffddbfce3a734761d4856c4caf28a618cbbedcecade620f35a890964fa90ae5c68

data/README.md

@@ -0,0 +1,7 @@
+A ruby2julia transpiler made with ❤️:
+
+## Limitation And Restrictions
+TBD
+
+## License
+MIT

data/Rakefile

@@ -0,0 +1,24 @@
+specs = [
+	"spec/core/random/rand_spec.rb",
+	"spec/core/array/slice_spec.rb",
+	"spec/core/math/atan2_spec.rb",
+	"spec/core/math/atan_spec.rb",
+	"spec/core/math/asinh_spec.rb",
+	"spec/core/math/asin_spec.rb",
+	"spec/core/math/acosh_spec.rb",
+	"spec/core/math/acos_spec.rb",
+	"spec/core/integer/",
+	"spec/core/float/",
+	"spec/core/fixnum/",
+	"spec/core/false/",
+]
+
+desc 'test behaviour using RSpec test files located in spec/*'
+task :spec do
+  specs.each {|e| system("rspec #{e}")}
+end
+
+desc 'test behaviour using RSpec test files located in spec/* with JULIALIZE_DEBUG set to true'
+task :spec_debug do
+  specs.each {|e| system("JULIALIZE_DEBUG=true rspec #{e}") }
+end

data/bin/julializer

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'julializer'
+
+Options = OptionParser.new do |opts|
+	opts.on("-v", "--version", "Print version") { |v| puts Julializer::VERSION; exit 0}
+end
+Options.parse!(ARGV)
+
+if ARGV.empty?
+	printf Julializer.ruby2julia($stdin.read)
+else
+	ARGV.each do |file|
+		if File.exist? file
+			printf Julializer.ruby2julia(File.read(file))
+		else
+			puts "File was not found: #{file}"
+			exit
+		end
+	end
+end

data/lib/julializer/version.rb

@@ -0,0 +1,3 @@
+module Julializer
+  VERSION = "0.1.0"
+end

data/lib/julializer.rb

@@ -0,0 +1,439 @@
+require 'ripper'
+
+module Julializer
+  class << self
+    require "julializer/version"
+
+    def ruby2julia(source)
+      @globals = []
+      #File.write("./__julialize_debug.log", Ripper.sexp(source).pretty_inspect)
+      transpile(Ripper.sexp(source))
+    end
+
+    private
+      def delim(s)
+        if s.kind_of?(Array) then
+          s.map{|line| "#{line};" }.join
+        else
+          "#{s};"
+        end
+      end
+
+      def transpile(s)
+        if s.instance_of?(String) then
+          s
+        elsif s.instance_of?(Array) && s[0].instance_of?(Symbol) then
+          #puts "s[0]=#{s[0]}"
+          #puts "s[1]=#{s[1]}"
+          case s[0]
+          when :program, :bodystmt  #, :else
+            s[1].map{|e| delim(transpile(e))}.join
+
+          #when :if, :elsif
+          #  s[2].map{|e| delim(transpile(e))}.join
+
+          when :assign
+            delim(transpile(s[1]) + "=" + transpile(s[2]))
+
+          when :var_field, :var_ref
+            if [:@gvar, :@ivar, :@cvar].include?(s[1][0])
+              @globals << s[1][1][1..-1]
+              s[1][1][1..-1]
+            elsif s[1][0]==:@const
+              (s[0]==:var_field ? "const " : "") + s[1][1].downcase
+            else
+              s[1][1]
+            end
+
+          when :next
+            delim("continue")
+
+          when :break
+            delim("break")
+
+          when :void_stmt
+            "" # this happens when rip "if true then # do nothing end" type of code
+
+          when :binary
+            if s[2] == :<< then
+              "push!(#{transpile(s[1])}, #{transpile(s[3])})"
+            elsif s[1][0] == :string_literal && s[2] == :% then
+              if s[3][0] == :array then
+                "@sprintf(#{transpile(s[1][1][1])},#{s[3][1].map{|e| transpile(e)}.join(',')})"
+              else
+                "@sprintf(#{transpile(s[1][1][1])},#{transpile(s[3])})"
+              end
+            else
+              case s[2]
+              when :or
+                operator = "||"
+              when :and
+                operator = "&&"
+              when :^
+                operator = "$"
+              when :**
+                operator = "^"
+              when :===
+                operator = "==" # Prevent using === since in Julia === checks much strictly than Ruby.
+              else
+                operator = s[2].to_s
+              end
+              transpile(s[1]) + operator + transpile(s[3])
+            end
+
+          when :opassign
+            delim(transpile(s[1]) + transpile(s[2]) + transpile(s[3]))
+
+          when :unary
+            case s[1]
+            when :not, :!
+              "!" + transpile(s[2])
+            when :-@
+              "(-" + transpile(s[2]) + ")"
+            when :~
+              "~" + transpile(s[2])
+            else
+              transpile(s[2])
+            end
+
+          when :paren
+            "(" + transpile(s[1][0]) + ")"
+
+          when :symbol
+            s[1][1]
+
+          when :field, :call
+            case s[1][1][1]
+            when "Math"
+              transpile(s[3][1])
+            when "Random"
+              case s[3][1]
+              when "rand"
+                "rand()"
+              else
+                transpile(s[3][1])
+              end
+            else
+              case s[3][1]
+              when "dup"
+                "copy(#{transpile(s[1])})"
+
+              when "shift"
+                "shift!(#{transpile(s[1])})"
+
+              when "to_f"
+                "float(#{transpile(s[1])})"
+
+              when "to_i", "to_int"
+                "trunc(Int64,parse(string(#{transpile(s[1])})))"
+
+              when "truncate"
+                "trunc(#{transpile(s[1])})"
+
+              when "chr"
+                "Char(#{transpile(s[1])})"
+
+              when "ord"
+                "Int(#{transpile(s[1])})"
+
+              when "class"
+                "typeof(#{transpile(s[1])})"
+
+              when "to_s"
+                "string(#{transpile(s[1])})"
+
+              when "even?"
+                "iseven(#{transpile(s[1])})"
+
+              when "odd?"
+                "isodd(#{transpile(s[1])})"
+
+              when "infinite?"
+                "isinf(#{transpile(s[1])})"
+
+              when "finite?"
+                "isfinite(#{transpile(s[1])})"
+
+              when "zero?"
+                "(#{transpile(s[1])}==0)"
+
+              when "integer?"
+                "(typeof(#{transpile(s[1])})==Int64)"
+
+              when "nan?"
+                "isnan(#{transpile(s[1])})"
+
+              when "abs", "magnitude"
+                "abs(#{transpile(s[1])})"
+
+              when "ceil", "floor"
+                "#{s[3][1]}(Int64,#{transpile(s[1])})"
+
+              when "size", "count"
+                "size(#{transpile(s[1])})[1]"
+
+              when "next", "succ"
+                "(#{transpile(s[1])}+1)"
+
+              when "pred"
+                "(#{transpile(s[1])}-1)"
+
+              when "next_float"
+                "(nextfloat(#{transpile(s[1])}))"
+
+              when "prev_float"
+                "(prevfloat(#{transpile(s[1])}))"
+
+              when "round"
+                "round(Int64,#{transpile(s[1])})"
+
+              else
+                "#{transpile(s[3])}(#{transpile(s[1])})"
+
+              end
+            end
+
+          when :array
+            s[1].nil? ? "[]" : "["+s[1].map{|e| transpile(e[1])}.join(",")+"]"
+
+          when :@CHAR
+            "'" + s[1][1] + "'"
+
+          when :@ident, :@int, :@kw, :@op
+            if s[0]==:@int && s[1][0..1]=="0x" then
+              "(#{s[1]}+0)" # Promote to Int64 from smaller numbers for cases like spec/core/float/divide_spec.rb (otherwise 91.1/-0xffffffff fails)
+            else
+              s[1]
+            end
+
+          when :string_content
+            s[1].nil? ? "" : 'string(' + s[1..-1].map{|e| transpile(e)}.join(",") + ')'
+
+          when :@tstring_content
+            '"' + s[1] + '"'
+
+          # commented out for simplification
+          #when :vcall
+
+          when :command
+            case s[1][1]
+            when "p", "puts", "printf", "print"
+              c = "print"
+            else
+              c = transpile(s[1])
+            end
+            delim(c + "(" + transpile(s[2]) + ")")
+
+          when :method_add_block
+            t = s[1][0]==:call ? s : s[1]
+            if t[1][3][1]=="each"
+              delim([
+                "___state = start(#{t[1][1][1][1]})",
+                "while !done(#{t[1][1][1][1]}, ___state)",
+                "___i, ___state = next(#{t[1][1][1][1]}, ___state)",
+                (s[2][1].nil? ? "" : "#{s[2][1][1][1][0][1]} = ___i"),
+                s[2][2].map{|e| delim(transpile(e))}.join,
+                "end"
+              ])
+            elsif t[1][3][1]=="downto"
+              delim([
+                "for #{transpile(s[2][1])} in countfrom(#{transpile(t[1][1])}, -1)",
+                "if #{transpile(s[2][1])}<#{transpile(t[2][1][1])} break end",
+                s[2][2].map{|e| delim(transpile(e))}.join,
+                "end"
+              ])
+            elsif t[1][3][1]=="times"
+              delim([
+                "for #{transpile(s[2][1]).nil? ? "___xyz___" : transpile(s[2][1]) } in 0:#{transpile(t[1][1])}-1",
+                s[2][2].map{|e| delim(transpile(e))}.join,
+                "end"
+              ])
+            else
+              transpile(s[1])
+            end
+
+          when :method_add_arg
+            if transpile(s[1][1])=="array" && transpile(s[1][3])=="new"
+              "fill(#{s[2][1][1][1][1]}, #{s[2][1][1][0][1][1]})"
+            elsif transpile(s[1][1])=="random" && transpile(s[1][3])=="rand"
+              "rand(#{transpile(s[2][1])})"
+            else
+              case transpile(s[1][3])
+              when "slice", "slice!"
+                method = transpile(s[1][3]) == "slice!" ? "splice!" : transpile(s[1][3])
+                start_index=0
+                if s[2][1][1][0][0] == :dot2 || s[2][1][1][0][0] == :dot3
+                  range = "#{transpile(s[2])}"
+                elsif s[2][1][1].count == 1
+                  range = "#{transpile(s[2])}+1"
+                else
+                  range = "#{transpile(s[2][1][1][0])}+1:#{start_index}+#{transpile(s[2][1][1][0])}+#{transpile(s[2][1][1][1])}+1"
+                end
+                "#{method}(#{transpile(s[1][1])}, #{range})"
+
+              when "send"
+                case transpile(s[2][1][1][0])
+                when "==", "==="
+                  # Prevent using === since in Julia === checks much strictly than Ruby.
+                  "==(#{transpile(s[2][1][1][1])}, #{transpile(s[1][1])})"
+                when "magnitude"
+                  "abs(#{transpile(s[1][1])})"
+                when "to_i", "to_int"
+                  "trunc(Int64,parse(string(#{transpile(s[1][1])})))"
+                when "truncate"
+                  "trunc(#{transpile(s[1][1])})"
+                when "-@"
+                  "-(#{transpile(s[1][1])})"
+                when "+@"
+                  transpile(s[1][1])
+                when "%", "modulo"
+                  "#{transpile(s[1][1])}%#{transpile(s[2][1][1][1])}"
+                when "fdiv"
+                  "#{transpile(s[1][1])}/#{transpile(s[2][1][1][1])}"
+                when "next", "succ"
+                  "(#{transpile(s[1][1])}+1)"
+                else
+                  "#{transpile(s[2])}(#{transpile(s[1][1])})"
+                end
+              when "index"
+                "findfirst(#{transpile(s[1][1])}, #{transpile(s[2])})"
+              when "rindex"
+                "findlast(#{transpile(s[1][1])}, #{transpile(s[2])})"
+              when "div"
+                "floor(#{transpile(s[1][1])}/#{transpile(s[2])})"
+              when "modulo"
+                "#{transpile(s[1][1])}%#{transpile(s[2])}"
+              when "divmod"
+                "divrem(#{transpile(s[1][1])},#{transpile(s[2])})"
+              when "fdiv"
+                "#{transpile(s[1][1])}/#{transpile(s[2])}"
+              when "eql?"
+                "===(#{transpile(s[1][1])}, #{transpile(s[2])})"
+              when "round"
+                "round(#{transpile(s[1][1])}, #{transpile(s[2])})"
+              when "atan2"
+                "atan2(#{transpile(s[2])})"
+              when "gcd"
+                "gcd(#{transpile(s[1][1])}, #{transpile(s[2])})"
+              when "lcm"
+                "lcm(#{transpile(s[1][1])}, #{transpile(s[2])})"
+              when "gcdlcm"
+                "[gcd(#{transpile(s[1][1])}, #{transpile(s[2])}), lcm(#{transpile(s[1][1])}, #{transpile(s[2])})]"
+              when "key?", "has_key?"
+                "haskey(#{transpile(s[1][1])}, #{transpile(s[2])})"
+              when "rand"
+                "int(rand() * #{transpile(s[2])})"
+
+              else
+                transpile(s[1]) + "(" + (transpile(s[2]) || "") + ")"
+              end
+            end
+
+          when :args_add_block
+            s[1].map{|e| transpile(e)}.join(",")
+
+          when :while
+            delim([
+              "while " + transpile(s[1]),
+               transpile(s[2]),
+               "end"
+            ])
+
+          when :for
+            delim([
+              "for #{transpile(s[1])}::Int64 = #{transpile(s[2])}",
+              transpile(s[3]),
+              "end"
+            ])
+
+          when :if, :elsif
+            if s[0]==:elsif then
+              keyword = "elseif"
+            else
+              keyword = "if"
+            end
+            additional_condition = !s[3].nil? ? transpile(s[3]) : "end"
+            delim([
+              "#{keyword} " + transpile(s[1]),
+              s[2].map{|e| delim(transpile(e))}.join,
+              "#{additional_condition}"
+            ])
+
+          when :if_mod
+            delim([
+              "if " + transpile(s[1]),
+              transpile(s[2]),
+              "end"
+            ])
+
+          when :else
+            delim([
+              "else",
+              s[1].map{|e| delim(transpile(e))}.join,
+              "end"
+            ])
+
+          when :def
+            code=transpile(s[3])
+            globals_code=@globals.uniq.join(",")
+            @globals=[]
+            delim([
+              "function #{s[1][1]}(#{transpile(s[2][1])})",
+              (globals_code.length>0 ? delim("global #{globals_code}") : "") + code,
+              "end"
+            ])
+
+          when :params
+            s[1].nil? ? "" : s[1].map{|e| e[1]}.join(", ")
+
+          when :dot2, :dot3
+            "#{transpile(s[1])}:#{transpile(s[2])}"
+
+          when :aref, :aref_field
+            if !s[2].flatten.include?(:dot2) && !s[2].flatten.include?(:dot3) && s[2][1][0][0]!=:string_literal then
+              transpile(s[1]) + "[" + transpile(s[2]) + "+1]"
+            else
+              if s[2].flatten.include?(:dot2)
+                range = "#{transpile(s[2][1][0][1])}+1:#{transpile(s[2][1][0][2])}+1"
+              elsif s[2].flatten.include?(:dot3)
+                range = "#{transpile(s[2][1][0][1])}+1:#{transpile(s[2][1][0][2])}"
+              else
+                range = transpile(s[2])
+              end
+              transpile(s[1]) + "[" + range + "]"
+            end
+
+          when :const_path_ref
+            if s[1][1][1]=="Float"
+              case transpile(s[2])
+              when "NAN"
+                "NaN"
+              when "INFINITY"
+                "Inf"
+              when "EPSILON"
+                "eps()"
+              when "MAX"
+                "typemax(Float64)"
+              when "MIN"
+                "typemin(Float64)"
+              else
+                transpile(s[1])
+              end
+            else
+              transpile(s[1])
+            end
+
+          when :return
+            delim("return #{transpile(s[1])}")
+
+          else
+            transpile(s[1])
+
+          end
+
+        elsif s.instance_of?(Array) && s[0].instance_of?(Array) then
+          s.map{|e| transpile(e)}.join
+        end
+      end
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: julializer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kei Sawada(@remore)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A ruby2julia transpiler with only limited types of syntax conversion
+  supported
+email:
+- k@swd.cc
+executables:
+- julializer
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- bin/julializer
+- lib/julializer.rb
+- lib/julializer/version.rb
+homepage: https://github.com/remore/julializer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A ruby2julia transpiler with only limited types of syntax conversion supported
+test_files: []