jtor 0.1.1-java → 0.1.2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb6efd191fb3dab0c19ebe356c3a24e5cc1f8534
-  data.tar.gz: c33f0bc1150ace2e5db228e055e6f04593439888
+  metadata.gz: eb0a35641aa58e399585b02e4bd5f0107ade213b
+  data.tar.gz: a513aa40d6a8f46a72d6131a2f19c6398feb52e6
 SHA512:
-  metadata.gz: 9629eefddac483afd218996e24ed53bf0b44d3198e4d37af1b802544dd579a9192ea15478dca39f477eb8e1019185796bc11d9cc57cebfa8e30090b11dff94e4
-  data.tar.gz: 295d55812f342355919eef6691d957164d868feabbed06e376de4011de1e61de3318c922488e4a2ee4e9a6496fe9d2e22def698d31c1ec08ab0f67824eba9c48
+  metadata.gz: 83bbc5dd9b936d8e3d0635c650179b57e82ad54e70ea49230fe51bf3ab64c2e42e67d3b590df51c8dabd2486e549cfc441984217f6db72678eee93ff2b4f0436
+  data.tar.gz: 8e3eddf4b2b7f05974b3741cc8c301dc62c23cbcaef62b373163f75c19369d4d1669579dbd5321e836b4637455e7350194c85a9d9c6c02efc08750f81a7e91be

data/lib/jtor/expressions.rb

@@ -65,8 +65,12 @@ module Jtor
       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
+        expr.vars.map do |var|
+          # If only declaring and not assigning, we don't need to translate it
+          # (I think)
+          next unless var.init
+          "#{var.id} = #{translate_expression(var.init)}"
+        end.compact.join('; ')
       when QualifiedNameExpr
         "#{translate_expression(expr.qualifier)}.#{expr.name}"
       when NameExpr
@@ -84,8 +88,18 @@ module Jtor
         op = expr.operator.to_s.to_sym
         operator = UNARY_OPERATORS[op]
         value = translate_expression(expr.expr)
-        if [:posIncrement, :posDecrement].include?(op)
-          "#{value}#{operator}"
+        case op
+        when :posIncrement
+          # For preIncrement and preDecrement we record the old value first,
+          # then execute the operation and then return the old value
+          "(__old = #{value}; #{value} += 1; __old)"
+        when :posDecrement
+          "(__old = #{value}; #{value} -= 1; __old)"
+        when :preIncrement
+          # No ++/-- in ruby
+          "(#{value} += 1)"
+        when :preDecrement
+          "(#{value} -= 1)"
         else
           "#{operator}#{value}"
         end
@@ -121,6 +135,10 @@ module Jtor
       when ThisExpr
         # TODO: Handle class expressions on `this`
         'self'
+      when SuperExpr
+        # Return our trusty `sup` helper object which encapsulates super methods
+        # TODO: Handle class expressions on `super`
+        'sup'
       when ClassExpr
         "#{translate_type(expr.type)}.class"
       when EnclosedExpr
@@ -137,13 +155,27 @@ module Jtor
       expressions.map { |expr| translate_expression(expr) }.join('; ')
     end
 
-    private
-
     def translate_arguments(args)
-      return '' unless args
+      return '' unless args && args.any?
       "(#{args.map { |arg| translate_expression(arg) }.join(', ')})"
     end
 
+    def translate_constructor_call_args(params, args)
+      # These arguments will be `eval`ed in Jtor::StdLib::Base. There the
+      # arguments are in an array called `args`. We'll translate any reference
+      # to a name defined in `params` to `args[i]`, where `i` is the index of
+      # that parameter in `params`
+      arguments = translate_arguments(args)
+      params.each_with_index do |param, index|
+        replacement = "\\1args[#{index}]\\2"
+        # Only replace unscoped names matching the param name
+        arguments.gsub!(/([ \(])#{param.id.name}([., \)])/, replacement)
+      end
+      arguments
+    end
+
+    private
+
     def translate_type(type)
       case type
       when ClassOrInterfaceType
@@ -152,7 +184,9 @@ module Jtor
           while (scope = scope.scope)
             module_string = "#{scope.name.to_constant_name}#{module_string}"
           end
-          module_string = "Java::#{module_string}::"
+          module_string += '::'
+        elsif %w(Exception String Math Class Object).include?(type.name)
+          module_string = 'JavaLang::'
         end
         "#{module_string}#{type.name}"
       when PrimitiveType
@@ -160,7 +194,7 @@ module Jtor
         # https://github.com/jruby/jruby/wiki/CallingJavaFromJRuby#java-to-ruby
         case type.type
         when PrimitiveType::Primitive::Boolean
-          'Java::JavaLang::Boolean'
+          'JavaLang::Boolean'
         when PrimitiveType::Primitive::Byte, PrimitiveType::Primitive::Short,
               PrimitiveType::Primitive::Char, PrimitiveType::Primitive::Int,
               PrimitiveType::Primitive::Long

data/lib/jtor/java_parser.rb

@@ -5,6 +5,9 @@ java_import com.github.javaparser.JavaParser
 
 module Jtor
   class JavaParser
+    include_package 'com.github.javaparser.ast.stmt'
+    include_package 'com.github.javaparser.ast.body'
+
     include Jtor::Expressions
 
     attr_accessor :indentator
@@ -17,13 +20,16 @@ module Jtor
 
     def translate(file)
       parser = ::JavaParser.parse(FileInputStream.new(file))
-      parser.imports.each do |import|
-        fputs("jtor_import '#{translate_expression(import.name)}'")
-      end
+      # In Java, other classes on the same package are automatically accessible,
+      # we do that manually here.
+      fputs("jtor_import '#{parser.package.name}.*'")
       fputs('module Java')
       indented do
         fputs("module #{module_name(parser.package.name)}")
         indented do
+          parser.imports.each do |import|
+            fputs("jtor_import '#{translate_expression(import.name)}'")
+          end
           parser.types.each { |type| translate_class_or_interface(type) }
         end
         fputs('end')
@@ -47,16 +53,99 @@ module Jtor
       outdent
     end
 
+    def indented_string(s)
+      # If we last used a `write` or if the string passed is empty, we don't
+      # want indentation
+      if @prev_write || !s
+        s
+      else
+        "#{@indentator * @level}#{s}"
+      end
+    end
+
     def fwrite(s)
-      @f.write "#{@indentator * @level}#{s}"
+      @f.write(indented_string(s))
+      @prev_write = true
     end
 
-    def fputs(s)
-      @f.puts "#{@indentator * @level}#{s}"
+    def fputs(s = nil)
+      @f.puts(indented_string(s))
+      @prev_write = false
     end
 
     def translate_statement(stmt)
-      # TODO: Translate statement
+      case stmt
+      when BlockStmt
+        translate_block_statement(stmt)
+      when ExpressionStmt
+        translated_expression = translate_expression(stmt.expression)
+        fputs(translated_expression) if translated_expression
+      when IfStmt
+        fputs("if #{translate_expression(stmt.condition)}")
+        indented { translate_statement(stmt.then_stmt) }
+        if stmt.else_stmt
+          if stmt.else_stmt.is_a?(IfStmt)
+            fwrite('els')
+            translate_statement(stmt.else_stmt)
+          else
+            fputs('else')
+            indented { translate_statement(stmt.then_stmt) }
+            fputs('end')
+          end
+        else
+          fputs('end')
+        end
+      when TryStmt
+        fputs('begin')
+        indented { translate_block_statement(stmt.try_block) }
+        stmt.catchs.each do |catch_clause|
+          except = catch_clause.except
+          fputs("rescue #{except.types[0].type.name} => #{except.id.name}")
+          indented { translate_block_statement(catch_clause.catch_block) }
+        end
+        if stmt.finally_block
+          fputs('ensure')
+          indented { translate_block_statement(stmt.finally_block) }
+        end
+        fputs('end')
+      when ForStmt
+        fputs(translate_expressions(stmt.init)) if stmt.init.any?
+        fputs("while #{translate_expression(stmt.compare)} do")
+        indented do
+          translate_statement(stmt.body)
+          fputs(translate_expressions(stmt.update)) if stmt.update.any?
+        end
+        fputs('end')
+      when ForeachStmt
+        iterable = translate_expression(stmt.iterable)
+        var = stmt.variable.vars.first.id.to_s
+        fputs("#{iterable}.each do |#{var}|")
+        indented { translate_statement(stmt.body) }
+        fputs('end')
+      when ReturnStmt
+        "return #{translate_expression(stmt.expr)}"
+      when ThrowStmt
+        "fail #{translate_expression(stmt.expr)}"
+      when BreakStmt
+        # TODO: Handle labeled `break`s
+        'break'
+      when ContinueStmt
+        # TODO: Handle labeled `continue`s
+        'next'
+      when DoStmt
+        fputs('begin')
+        indented { translate_statement(stmt.body) }
+        fputs("end while #{translate_expression(stmt.condition)}")
+      when SwitchStmt
+        fputs("case #{translate_expression(stmt.selector)}")
+        stmt.entries.each do |entry|
+          fputs(entry.label ? "when #{entry.label}" : 'else')
+          indented do
+            entry.stmts.each { |stmt| translate_statement(stmt) }
+          end
+        end
+        fputs('end')
+      end
     end
 
     def translate_block_statement(block_stmt)
@@ -71,20 +160,56 @@ module Jtor
       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
+    def write_method(method)
+      types = translate_param_types(method.parameters)
+      param_list = translate_param_list(method.parameters)
+      declarer_method = if ModifierSet.static?(method.modifiers)
+        'add_static_java_method'
+      else
+        'add_java_method'
+      end
+      fputs("#{declarer_method}(:#{method.name}, #{types}) do#{param_list}")
+      indented { translate_block_statement(method.body) } if method.body
+      fputs('end')
+    end
+
+    def write_constructor(constructor)
+      types = translate_param_types(constructor.parameters)
+      param_list = translate_param_list(constructor.parameters)
+      stmts = constructor.block && constructor.block.stmts
+      if stmts && stmts.any? && stmts.first.is_a?(ExplicitConstructorInvocationStmt)
+        constructor_stmt = stmts.first
+        stmts = stmts.size > 1 ? stmts.sub_list(1, stmts.size - 1) : []
+        super_call = constructor_stmt.this? ? 'initialize' : 'super'
+        super_call += translate_constructor_call_args(constructor.parameters,
+            constructor_stmt.args)
+      end
+      # Using `#` as the delimiter, as it can't appear on Java expressions
+      fputs("add_java_constructor(#{types}, %q##{super_call}#) do#{param_list}")
+      indented do
+        stmts.each { |stmt| translate_statement(stmt) }
+      end if stmts
       fputs('end')
     end
 
+    def write_field(field)
+      field.variables.each do |var|
+        fputs "attr_accessor :#{var.id}"
+        next unless var.init
+        fputs "add_java_initializer do"
+        indented { fputs "self.#{var.id} ||= #{translate_expression(var.init)}" }
+        fputs "end"
+      end
+    end
+
     def translate_member(member)
       case member
-      when Java::ComGithubJavaparserAstBody::MethodDeclaration
-        write_method(member.name, member.parameters, member.body)
-      when Java::ComGithubJavaparserAstBody::ConstructorDeclaration
-        write_method(:initialize, member.parameters, member.block)
+      when MethodDeclaration
+        write_method(member)
+      when ConstructorDeclaration
+        write_constructor(member)
+      when FieldDeclaration
+        write_field(member)
       end
     end
 
@@ -94,7 +219,7 @@ module Jtor
       end
       fputs("class #{type.name.to_constant_name}#{extends}")
       indented do
-        fputs('extend Jtor::StdLib::Base')
+        fputs('include Jtor::StdLib::Base')
         type.members.each { |member| translate_member(member) }
       end
       fputs('end')

data/lib/jtor/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jtor
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: java
 authors:
 - Alejandro Rodríguez