Concrete Java classes result

decompile.java

package rubyobj.Umm.Paintbrush;

import com.test.SecondaryClass;
import java.util.List;
import org.jruby.Ruby;
import org.jruby.RubyArray;
import org.jruby.RubyClass;
import org.jruby.java.proxies.ConcreteJavaProxy;
import org.jruby.javasupport.JavaConstructor;
import org.jruby.javasupport.JavaUtil;
import org.jruby.javasupport.Java.JCreateMethod;
import org.jruby.javasupport.Java.JCtorCache;
import org.jruby.javasupport.proxy.JavaProxyClass;
import org.jruby.javasupport.proxy.ReifiedJavaProxy;
import org.jruby.runtime.Block;
import org.jruby.runtime.builtin.IRubyObject;

public class Balloons extends SecondaryClass implements ReifiedJavaProxy {
   // $FF: synthetic field
   private final ConcreteJavaProxy this$rubyObject;
   // $FF: synthetic field
   private static final JavaProxyClass this$rubyProxyClass;
   // $FF: synthetic field
   private static final JCtorCache this$rubyCtorCache;
   // $FF: synthetic field
   private static final Ruby ruby;
   // $FF: synthetic field
   private static final RubyClass rubyClass;

   public Balloons(String var1, boolean var2, Ruby var3, RubyClass var4) {
      this(new ConcreteJavaProxy(var3, var4), false, new IRubyObject[]{JavaUtil.convertJavaToUsableRubyObject(var3, var1), JavaUtil.convertJavaToRuby(var3, var2)}, Block.NULL_BLOCK, var3, var4);
   }

   public Balloons(String var1, boolean var2) {
      RubyClass var4 = rubyClass;
      Ruby var3 = ruby;
      this(new ConcreteJavaProxy(var3, var4), false, new IRubyObject[]{JavaUtil.convertJavaToUsableRubyObject(var3, var1), JavaUtil.convertJavaToRuby(var3, var2)}, Block.NULL_BLOCK, var3, var4);
   }

   public Balloons(int var1, String var2, Ruby var3, RubyClass var4) {
      this(new ConcreteJavaProxy(var3, var4), false, new IRubyObject[]{JavaUtil.convertJavaToRuby(var3, var1), JavaUtil.convertJavaToUsableRubyObject(var3, var2)}, Block.NULL_BLOCK, var3, var4);
   }

   public Balloons(int var1, String var2) {
      RubyClass var4 = rubyClass;
      Ruby var3 = ruby;
      this(new ConcreteJavaProxy(var3, var4), false, new IRubyObject[]{JavaUtil.convertJavaToRuby(var3, var1), JavaUtil.convertJavaToUsableRubyObject(var3, var2)}, Block.NULL_BLOCK, var3, var4);
   }

   // $FF: synthetic method
   public Balloons(ConcreteJavaProxy var1, IRubyObject[] var2, Block var3, Ruby var4, RubyClass var5) {
      this(var1, false, var2, var3, var4, var5);
   }

   // $FF: synthetic method
   protected Balloons(ConcreteJavaProxy var1, boolean var2, IRubyObject[] var3, Block var4, Ruby var5, RubyClass var6) {
      this.this$rubyObject = var1;
      Object[] var10000 = var1.splitInitialized(var2 ? rubyClass : var6, var3, var4);
      IRubyObject var10001 = (IRubyObject)var10000[0];
      RubyArray var7;
      switch(JCreateMethod.forTypes((IRubyObject)var10000[0], this$rubyCtorCache, var5)) {
      case 0:
         var7 = var10001.convertToArray();
         super((String)var7.entry(0).toJava(String.class), (Boolean)var7.entry(1).toJava(Boolean.TYPE));
         break;
      case 1:
         var7 = var10001.convertToArray();
         super(((Number)var7.entry(0).toJava(Integer.TYPE)).intValue(), (String)var7.entry(1).toJava(String.class));
         break;
      default:
         throw new IllegalStateException("No available superconstructors match that type signature");
      }

      var1.setObject(this);
      var1.finishInitialize(var10000);
   }

   public List myAbstractFunc() {
      this.this$rubyObject.ensureThis(this);
      Ruby var1 = ruby;
      return (List)this.this$rubyObject.callMethod("myAbstractFunc", IRubyObject.NULL_ARRAY).toJava(List.class);
   }

   public int thing(long var1) {
      this.this$rubyObject.ensureThis(this);
      Ruby var3 = ruby;
      return ((Number)this.this$rubyObject.callMethod("thing", new IRubyObject[]{JavaUtil.convertJavaToRuby(var3, var1)}).toJava(Integer.TYPE)).intValue();
   }

   public static IRubyObject fake_new() {
      return rubyClass.callMethod("fake_new");
   }

   // $FF: synthetic method
   public IRubyObject ___jruby$rubyObject() {
      return this.this$rubyObject;
   }

   // $FF: synthetic method
   public JavaProxyClass ___jruby$proxyClass() {
      return this$rubyProxyClass;
   }

   static {
      Object[] var10002 = JavaProxyClass.getStaticInitLookup(11);
      ruby = (Ruby)var10002[0];
      rubyClass = (RubyClass)var10002[1];
      this$rubyCtorCache = new JCtorCache((JavaConstructor[])var10002[2]);
      this$rubyProxyClass = JavaProxyClass.setProxyClassReified(ruby, rubyClass, Balloons.class, true);
   }
}

Gen.rb

module Umm
module Paintbrush

#TODO: test self.to_java on non-super'd non-become_java'd things
class Balloons < com.test.SecondaryClass

    def initialize(*args)
    	puts "yay, helo(i), with #{args.inspect}"
    	#raise "ack" #java.lang.NullPointerException.new
    	egads = args.length + 5
    	p egads
    	p self
    	#super
        super(5, "Pink Elephant")
        puts "Goty init #{args.inspect} w egads #{egads}"
        p self
        p self.to_java
        if true
        	puts "eg is #{egads}"
        	trytrace2
        end
        #raise "Egads"
        #raise java.lang.NullPointerException.new
    end
    
    def trytrace2
    trytrace
    end
    
    def trytrace
     puts caller
     puts "000000000"
     raise "traced"
    end
    
    def zj_initialize(*args)
    	puts "yay, helo(j), with #{args.inspect}"
    	p self
        return [[4, "Pink Elephant"], lambda do
        puts "Goty initj2 #{args.inspect}"
        p self
        p self.to_java
        end]
    end
=begin
    def testinit(*args)
    	stuff = code()
    	super(foo, *args)
    	other(*args, stuff)
    end
    
    def testinit(*args)
    	stuff = code()
    	return [[foo, *args], lambda do
	    	other(*args, stuff)
    		end]
    end
=end

#calling new without prefix?

# TODO:
	configure_java_class call_init: true, methods: :all, ctors: :all

    def myAbstractFunc()
        list = ArrayList.new
        list << "Fall foliage"
        list << "Disasterous Doughnuts"
        #raise "augh"
        list << "Whole thing"
        return list
    end
    
    def extra()
    	puts "Extra?!"
        p self
        p self.to_java
    end
    
    def thing(a)
        #raise java.lang.NullPointerException.new
    	a+4
	end
	
	def self.fake_new
		aa = allocate
		p aa
		#aa.send :__jallocate!, "dippy", true
		aa.send :initialize, "dippy", true
		p aa
		aa
	end
	
   become_java!("/tmp")
end

puts "java, became"

end
end

puts "Making Bad choices"
p Umm::Paintbrush::Balloons
p Umm::Paintbrush::Balloons.java_class

r = Umm::Paintbrush::Balloons.new(5,"yes")#("skippy", "skappy", 5,6,7, true)#5, "yes")
p r
r.extra

puts "alloc results::"
aa = Umm::Paintbrush::Balloons.fake_new
p aa