jtor 0.1.0-java → 0.1.1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ca5126acd5831041982af13ccfaa6d53a8725c6a
-  data.tar.gz: 8e09af5305d4109c2708563b0be9c00d9ec130ab
+  metadata.gz: bb6efd191fb3dab0c19ebe356c3a24e5cc1f8534
+  data.tar.gz: c33f0bc1150ace2e5db228e055e6f04593439888
 SHA512:
-  metadata.gz: c8fe1028b34ca30c698ee1732b6d97865ebac35b5e591dd60bfe93c60e8497d7397526099bd10a39009195bf0105329087c1e18067a7ec0a9d1a44921b89e064
-  data.tar.gz: a44d00a8f8be8c383d3964c173256b094d4cd91f203131043b93fc96a106de9d8659cd934fa32525f6fe3dd093e448df5e34112e8583e6d1c7873fd92f7a2dbe
+  metadata.gz: 9629eefddac483afd218996e24ed53bf0b44d3198e4d37af1b802544dd579a9192ea15478dca39f477eb8e1019185796bc11d9cc57cebfa8e30090b11dff94e4
+  data.tar.gz: 295d55812f342355919eef6691d957164d868feabbed06e376de4011de1e61de3318c922488e4a2ee4e9a6496fe9d2e22def698d31c1ec08ab0f67824eba9c48

data/lib/jtor.rb

@@ -1,6 +1,11 @@
+warn 'Loading jtor in a non-JRuby interpreter' unless defined? JRUBY_VERSION
+
+require 'java'
+
 require 'ext/string'
 
-require 'jtor/load'
+require 'jtor_jars.rb'
 
+require 'jtor/version'
 require 'jtor/java_parser'
 require 'jtor/translator'

data/lib/jtor/expressions.rb

@@ -0,0 +1,182 @@
+module Jtor
+  module Expressions
+    include_package 'com.github.javaparser.ast.expr'
+    include_package 'com.github.javaparser.ast.type'
+
+    ASSINGMENT_OPERATORS = {
+      assign: '=',
+      plus: '+=',
+      minus: '-=',
+      star: '*=',
+      slash: '/=',
+      and: '&=',
+      or: '|=',
+      xor: '^=',
+      rem: '%=',
+      lShift: '<<=',
+      rSignedShift: '>>=',
+      rUnsignedShift: '>>>='
+    }
+
+    UNARY_OPERATORS = {
+      positive: '+',
+      negative: '-',
+      preIncrement: '++',
+      preDecrement: '--',
+      not: '!',
+      inverse: '~',
+      posIncrement: '++',
+      posDecrement: '--'
+    }
+
+    BINARY_OPERATORS = {
+      or: '||',
+      and: '&&',
+      binOr: '|',
+      binAnd: '&',
+      xor: '^',
+      equals: '==',
+      notEquals: '!=',
+      less: '<',
+      greater: '>',
+      lessEquals: '<=',
+      greaterEquals: '>=',
+      lShift: '<<',
+      rSignedShift: '>>',
+      rUnsignedShift: '>>>',
+      plus: '+',
+      minus: '-',
+      times: '*',
+      divide: '/',
+      remainder: '%'
+    }
+
+    def translate_expression(expr)
+      case expr
+      when MethodCallExpr
+        scoped_expression(expr) do
+          "#{expr.name}#{translate_arguments(expr.args)}"
+        end
+      when AssignExpr
+        target = translate_expression(expr.target)
+        operator = ASSINGMENT_OPERATORS[expr.operator.to_s.to_sym]
+        value = translate_expression(expr.value)
+        "#{target} #{operator} #{value}"
+      when FieldAccessExpr
+        scoped_expression(expr) { expr.field }
+      when VariableDeclarationExpr
+        # I think we don't need to do anything, but I might be missing some scoping
+        # particularity. We'll see
+      when QualifiedNameExpr
+        "#{translate_expression(expr.qualifier)}.#{expr.name}"
+      when NameExpr
+        expr.name
+      when ArrayAccessExpr
+        "#{translate_expression(expr.name)}[#{translate_expression(expr.index)}]"
+      when ArrayCreationExpr
+        if expr.initializer
+          values = expr.initializer.values.map { |value| translate_expression(value) }
+          "[#{values.join(', ')}]"
+        else
+          "Array.new(#{expr.array_count})"
+        end
+      when UnaryExpr
+        op = expr.operator.to_s.to_sym
+        operator = UNARY_OPERATORS[op]
+        value = translate_expression(expr.expr)
+        if [:posIncrement, :posDecrement].include?(op)
+          "#{value}#{operator}"
+        else
+          "#{operator}#{value}"
+        end
+      when BinaryExpr
+        left = translate_expression(expr.left)
+        operator = BINARY_OPERATORS[expr.operator.to_s.to_sym]
+        right = translate_expression(expr.right)
+        "#{left} #{operator} #{right}"
+      when IntegerLiteralExpr
+        # NOTE: `IntegerLiteralExpr` is a subclass of `StringLiteralExpr`, so
+        # this case must be before the latter
+        expr.value
+      when StringLiteralExpr
+        expr.value.inspect
+      when BooleanLiteralExpr
+        expr.value
+      when ObjectCreationExpr
+        # TODO: Handle object creations with anonymous classes
+        scoped_expression(expr) do
+          type = translate_type(expr.type)
+          "#{type}.new#{translate_arguments(expr.args)}"
+        end
+      when InstanceOfExpr
+        # No `instanceof` operator in ruby, but every expression is an object
+        # with the `is_a?` method, which serves the same purpose. We wrap the
+        # expression in parenthesis just in case it's not atomic.
+        "(#{translate_expression(expr.expr)}).is_a?(#{translate_type(expr.type)})"
+      when NullLiteralExpr
+        'nil'
+      when CastExpr
+        # No need to cast anything :P
+        translate_expression(expr.expr)
+      when ThisExpr
+        # TODO: Handle class expressions on `this`
+        'self'
+      when ClassExpr
+        "#{translate_type(expr.type)}.class"
+      when EnclosedExpr
+        "(#{translate_expression(expr.inner)})"
+      when ConditionalExpr
+        condition = translate_expression(expr.condition)
+        then_expr = translate_expression(expr.then_expr)
+        else_expr = translate_expression(expr.else_expr)
+        "#{condition} ? #{then_expr} : #{else_expr}"
+      end
+    end
+
+    def translate_expressions(expressions)
+      expressions.map { |expr| translate_expression(expr) }.join('; ')
+    end
+
+    private
+
+    def translate_arguments(args)
+      return '' unless args
+      "(#{args.map { |arg| translate_expression(arg) }.join(', ')})"
+    end
+
+    def translate_type(type)
+      case type
+      when ClassOrInterfaceType
+        if type.scope
+          scope = type
+          while (scope = scope.scope)
+            module_string = "#{scope.name.to_constant_name}#{module_string}"
+          end
+          module_string = "Java::#{module_string}::"
+        end
+        "#{module_string}#{type.name}"
+      when PrimitiveType
+        # Mapping from
+        # https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby#java-to-ruby
+        case type.type
+        when PrimitiveType::Primitive::Boolean
+          'Java::JavaLang::Boolean'
+        when PrimitiveType::Primitive::Byte, PrimitiveType::Primitive::Short,
+              PrimitiveType::Primitive::Char, PrimitiveType::Primitive::Int,
+              PrimitiveType::Primitive::Long
+          'Fixnum'
+        when PrimitiveType::Primitive::Float, PrimitiveType::Primitive::Double
+          'Float'
+        end
+      when ReferenceType
+        # Integer[], String[], Float[][] all translates to Array in ruby
+        type.array_count == 0 ? translate_type(type.type) : 'Array'
+      end
+    end
+
+    def scoped_expression(expr)
+      scope = "#{translate_expression(expr.scope)}." if expr.scope
+      "#{scope}#{yield}"
+    end
+  end
+end

data/lib/jtor/java_parser.rb

@@ -1,53 +1,107 @@
-require 'java'
-require 'jbundler'
+require_relative 'expressions'
 
 java_import java.io.FileInputStream
 java_import com.github.javaparser.JavaParser
 
 module Jtor
   class JavaParser
+    include Jtor::Expressions
+
     attr_accessor :indentator
 
     def initialize(f)
       @indentator = '  '
+      @level = 0
       @f = f
     end
 
     def translate(file)
       parser = ::JavaParser.parse(FileInputStream.new(file))
-      parser.types.each { |type| translate_type(0, type) }
+      parser.imports.each do |import|
+        fputs("jtor_import '#{translate_expression(import.name)}'")
+      end
+      fputs('module Java')
+      indented do
+        fputs("module #{module_name(parser.package.name)}")
+        indented do
+          parser.types.each { |type| translate_class_or_interface(type) }
+        end
+        fputs('end')
+      end
+      fputs('end')
     end
 
     private
 
-    def write(i_level, s)
-      @f.puts "#{@indentator * i_level}#{s}"
+    def indent
+      @level += 1
     end
 
-    def translate_type(i_level, type)
-      write(i_level, "class #{type.name.to_constant_name}")
-      type.members.each { |member| translate_member(i_level + 1, member) }
-      write(i_level, 'end')
+    def outdent
+      @level -= 1
     end
 
-    def translate_method(i_level, name, parameters)
-      params = if parameters.any?
-        "(#{parameters.map { |p| p.id.name }.join(', ')})"
-      else
-        ''
-      end
-      write(i_level, "def #{name}#{params}")
-      # TODO: Translate method body
-      write(i_level, 'end')
+    def indented
+      indent
+      yield
+      outdent
+    end
+
+    def fwrite(s)
+      @f.write "#{@indentator * @level}#{s}"
+    end
+
+    def fputs(s)
+      @f.puts "#{@indentator * @level}#{s}"
+    end
+
+    def translate_statement(stmt)
+      # TODO: Translate statement
+    end
+
+    def translate_block_statement(block_stmt)
+      block_stmt.stmts.each { |stmt| translate_statement(stmt) }
     end
 
-    def translate_member(i_level, member)
+    def translate_param_types(params)
+      "[#{params.map { |p| translate_type(p.type) }.join(', ')}]"
+    end
+
+    def translate_param_list(params)
+      params.any? ? " |#{params.map { |p| p.id.name }.join(', ')}|" : ''
+    end
+
+    def write_method(name, params, body)
+      types = translate_param_types(params)
+      param_list = translate_param_list(params)
+      fputs("add_java_method(:#{name}, #{types}) do#{param_list}")
+      indented { translate_block_statement(body) } if body
+      fputs('end')
+    end
+
+    def translate_member(member)
       case member
       when Java::ComGithubJavaparserAstBody::MethodDeclaration
-        translate_method(i_level, member.name, member.parameters)
+        write_method(member.name, member.parameters, member.body)
       when Java::ComGithubJavaparserAstBody::ConstructorDeclaration
-        translate_method(i_level, 'initialize', member.parameters)
+        write_method(:initialize, member.parameters, member.block)
       end
     end
+
+    def translate_class_or_interface(type)
+      if type.extends.any?
+        extends = " < #{type.extends.map { |e| translate_type(e) }.join(', ')}"
+      end
+      fputs("class #{type.name.to_constant_name}#{extends}")
+      indented do
+        fputs('extend Jtor::StdLib::Base')
+        type.members.each { |member| translate_member(member) }
+      end
+      fputs('end')
+    end
+
+    def module_name(name_expr)
+      name_expr.name.split('.').map(&:to_constant_name).join
+    end
   end
 end

data/lib/jtor/translator.rb

@@ -1,13 +1,22 @@
 require 'fileutils'
+require 'erb'
 
 module Jtor
   class Translator
     def self.run(src, dest)
+      gemfile_template = ERB.new(File.read('templates/Gemfile.erb'))
       Dir.chdir(src)
+      # Write Gemfile
+      File.open(File.join(dest, 'Gemfile'), 'w') do |f|
+        f.puts(gemfile_template.result(binding))
+      end
+
+      # Translate files
       Dir.glob('**/*.java').each do |file|
         dest_file = File.join(dest, file.gsub(/java$/, 'rb'))
         FileUtils.mkdir_p(File.dirname(dest_file))
         File.open(dest_file, 'w') do |f|
+          f.puts("require 'jtor-stdlib'")
           JavaParser.new(f).translate(File.join(src, file))
         end
       end

data/lib/jtor/version.rb

@@ -0,0 +1,4 @@
+module Jtor
+  VERSION = '0.1.1'
+  JTOR_STDLIB_VERSION = '0.1.1'
+end

data/lib/jtor_jars.rb

@@ -0,0 +1,4 @@
+# this is a generated file, to avoid over-writing it just delete this comment
+require 'jar_dependencies'
+
+require_jar( 'com.github.javaparser', 'javaparser-core', '2.3.0' )

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jtor
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: java
 authors:
 - Alejandro Rodríguez
@@ -34,9 +34,11 @@ files:
 - bin/jtor
 - lib/ext/string.rb
 - lib/jtor.rb
+- lib/jtor/expressions.rb
 - lib/jtor/java_parser.rb
-- lib/jtor/load.rb
 - lib/jtor/translator.rb
+- lib/jtor/version.rb
+- lib/jtor_jars.rb
 homepage: https://gitlab.com/eReGeBe/jtor
 licenses:
 - MIT
@@ -56,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- jar com.github.javaparser:javaparser-core, 2.1.0
+- jar com.github.javaparser:javaparser-core, 2.3.0
 rubyforge_project: 
 rubygems_version: 2.5.0
 signing_key: 

data/lib/jtor/load.rb

@@ -1,4 +0,0 @@
-warn 'Loading jtor in a non-JRuby interpreter' unless defined? JRUBY_VERSION
-
-require 'jar-dependencies'
-require_jar('com.github.javaparser', 'javaparser-core', '2.1.0')