Saturday, February 28, 2009

Help Us Set Priorities for JRuby 1.3

With JRuby 1.2 almost out the door, I want to talk a bit about where we should go with JRuby 1.3. There's always more work to do, but in this case there's a few different directions we could probably go.

Some obvious items will continue to see work:

  • 1.9 libraries, interp, compiler, parser
  • 1.8.6 bugs
  • "Pure ruby" application support, like Rails deployment stuff (Warbler, AR-JDBC)
But there's other areas that we may want to prioritize:
  • 1.8.7 support
  • Ruby execution performance (how fast do you want it?)
  • Specific library performance (YAML, IO, Java)
  • More Java integration improvement/refactoring (esp. subclassing)
  • "Compiler #2" to produce normal Java classes from Ruby
  • Improvements to AOT compilation (all-at-once, eliminate runtime codegen)
  • Expand support for embedded/mobile platforms
And there's a number of internal chores to work on too:
  • Start generating most of the call path, to reduce duplicate code
  • Specific-arity optimizations for block yield (could be big)
  • Compiler cleanup and refactoring
  • Modularization of core classes that aren't valid on applet, Android, secured envs, etc; also may allow shipping smaller runtimes
  • More startup perf work; I have a few ideas
As always, there's way more tasks than the few of us committing to JRuby can work on, so I think we need to hear from users what's important. Any of these? Other items?

Friday, February 27, 2009

JRuby on Java ME

A number of folks have asked us over the years whether JRuby could run on a Java ME-enabled device. I've always said I believed it would be possible with enough trimming. Strip out all the libraries that ME doesn't support, and you should be left with a runnable "core" of JRuby. Roy Ben Hayun, formerly of Symbian and (I believe) now working at Sun, actually proved it possible but difficult back in 2006 with his JRubyME project, a stripped down JRuby 0.9.8. But that didn't have compiler support, and we were still dog slow in 2006. Has JRuby, with two years of work behind it, grown too complex to run on an embedded device? Is the Rhodes project right when they say JRuby is too large for this to work?

Tony Arcieri, of Revactor fame, put a bug in my ear about Java ME again this week. He's interested in running Ruby on a device hosting the Connected Device Configuration (CDC) level of Java ME. Specifically, the device in question supports CDC plus the APIs included in the Personal Basis Profile (PBP). CDC is probably about the smallest ME profile JRuby could reasonably run in, since anything lower (like CLDC, the Connected Limited Device Configuration) and you're reduced to the most basic collections, IO, and utility APIs.

So, I'm happy to announce that the JRuby CDC Project has spawned out of the JRuby codebase.

Here's what it looks like running, using Sun's reference implementation of CDC+PBP:

~/cdc/Optimized_nosym$ bin/cvm -classpath ../jruby.jar org.jruby.Main -X-C -e "[1,2,3].each {|i| puts i}"
1
2
3

The "cvm" is Sun's reference implementation of an embedded JVM, and this particular package includes the PBP level APIs as well. The jruby.jar here is the one I've stripped in the jruby-cdc project, but with the additional step of retroweaving it back to Java 1.3-compatible bytecode.

My intention with this is to get it running with a base set of Ruby classes but with Java integration still functional. That will allow most basic Ruby scripts to work while providing access to the rest of the Java APIs for bits I had to rip out (like IO APIs)

It's only running interpreted right now, just like the Android version of JRuby, but as in that case I expect most people will want to precompile Ruby code and ship it all as one unit.

Why bother? Well, there are still a lot of Java ME devices out there. And while the device you carry in your pocket may be growing beyond Java ME, the set-top box or Blu-Ray player in your living room is just starting to reach that level. The technology is still sound, if perhaps less obvious than an iPhone or Android. And hey, we want "Ruby everywhere," don't we?

Where do we go from here? I think this and Ruboto are proof that damn near anything is possible with JRuby. It really only took me a couple days of trimming to get this far. Fully supporting Android in Ruboto will not take long, and other "mini ruby" profiles are possible for other platforms and use cases as well. It just takes a little imagination, and maybe a few late-night hacking sessions.

Now...for my next trick...

Wednesday, February 25, 2009

Ruboto Is Your Friend

Ok, so I intentionally made my last post a bit of a "tease". You can't fault me for trying to drum up a little buzz, yeah? And hey, I spent almost as long fiddling with that logo as I did hacking JRuby to run on Android. Here it is again, just for good measure:


On Monday night, the local Ruby group (Ruby Users of Minnesota, or RUM...great buncha guys) hosted three talks: one on Android development, one on iPhone development, and one on migrating from Struts to JRuby a bit at a time. The Android talk kinda hooked me, even though I was working on last-minute JRuby 1.2RC1 issues and not really paying much attention (sorry, Justin).

I'd considered getting JRuby working on Android before, since it's compatible with most Java 1.5 language features, has a much more extensive library than any of the Java ME profiles (which hopefully will be remedied in future ME profiles), and represented the best chance for "mobile JRuby" to date. I had tweeted about it, scammed for a free G1 phone, and briefly browsed the online docs. I had even downloaded it back in early January...but I'd never bothered to try.

So late Monday night, I tried. And about an hour later it was running.

What I Did

There's really two sides to the Android SDK. There's the drag-and-drop fluffy-stuffy GUI in the form of a plugin for Eclipse. That was my first stop; I got it installed, created a sample project, and ran it in the emulator. It worked as expected, and I'll admit it made me want an Android phone a bit more. I'll be the first to admit I've been skeptical of Android, but at this point it's hard to argue with a totally open platform, especially since it has a shipping device now. So yeah, SDK plus sample app was easy and appetite-whetting.

Then I tried to pull in JRuby's main jar file. Nothing seemed to work right. I got errors about not having defined an "application" in some XML file, even though it was there. There was no obvious information on how to add third-party libraries to my app, and I certainly may have done it the wrong way. And of course my lack of knowledge about the structure of an Android app probably didn't help. But ultimately, since I didn't really need a full-on application, I started to dig around in the SDK for "another way".

Not one for reading documentation, I immediately started running the executables under "tools" with --help and guessing at combinations of arguments. Immediately I saw "emulator" and started that. Yay, an emulator! Then I saw dx, which looked intriguing. A-ha! It's the tool for converting an existing class or jar into Dalvik bytecode. A bit more fidding with flags, and I finally found the right incantation:

dx -JXmx1024M --dex --output=ruboto.jar jruby.jar

For the newbs: that's -JXmx1024M to allow dx to use up to a gig of memory, --dex to convert to Dalvik bytecode, and --output to specify an output file.

So, suddenly I had what I assumed was a Dalvik-ready ruboto.jar file. A quick jar -t confirmed that everything appeared to be there, along with a "classes.dex" file.
...
builtin/yaml.rb
builtin/yaml/store.rb
builtin/yaml/syck.rb
classes.dex
com/sun/jna/darwin/libjnidispatch.jnilib
com/sun/jna/freebsd-amd64/libjnidispatch.so
com/sun/jna/freebsd-i386/libjnidispatch.so
...

There were also a bunch of warnings about "Ignoring InnerClasses attribute for an anonymous inner class that doesn't come with an associated EnclosingMethod attribute." but warnings don't stop a true adventurer. I pressed on!

So, the next step was getting it into the emulator, eh? Hmm. Well there's no "upload" option in the emulator's OS X menu, and nothing obvious in the Android UI. There must be a tool. Like maybe a debugging tool of some kind... like a "jdb" but for Android. Hmm.....this "adb" executable looks promising...
$ ~/android-sdk-mac_x86-1.0_r2/tools/adb --help
Android Debug Bridge version 1.0.20
...

Ahh, bingo. And one of the adb subcommands was "push" for pushing files to the device. A few minutes and experiments later, I figured out incantation #2:
$ ~/android-sdk-mac_x86-1.0_r2/tools/adb push ruboto.jar ruboto.jar
failed to copy 'ruboto.jar' to 'ruboto.jar': Read-only file system

Or at least, I almost had it. Obviously the device was being closed-minded about the whole thing. So back to adb to run another subcommand and have a look around:
$ ~/android-sdk-mac_x86-1.0_r2/tools/adb shell
# ls
sqlite_stmt_journals
cache
sdcard
etc
system
sys
sbin
proc
init.rc
init.goldfish.rc
init
default.prop
data
root
dev

Hmm. "data". That looks promising. I mean, a "data" directory couldn't possibly be read-only, right? So let's give that a try.
$ ~/android-sdk-mac_x86-1.0_r2/tools/adb push ruboto.jar data/ruboto.jar
1702 KB/s (3249363 bytes in 1.863s)

BING! We have liftoff!

Ok, so we've "dexed" the jar, uploaded it to the emulator, and now we want to run it. Back into the shell we go!

There's obviously an sbin above, but it's pretty slim:
# ls sbin
adbd

Another debugging thingy I suppose. Maybe I'll have a look at that later. What about under "system"? I've gotten used to the bulk of my system living under something called "system" from running OS X. And as in that case, "system" was much more populous, with a bin directory containing all sorts of goodies. However one of them jumped out at me immediately:
# ls system/bin
am
app_process
cat
chmod
cmp
dalvikvm
date
dbus-daemon
dd
...

Oh, goodie, "dalvikvm". Could it possibly be the equivalent of the "java" command on a desktop? Could it really be that easy?
# dalvikvm -help

dalvikvm: [options] class [argument ...]
dalvikvm: [options] -jar file.jar [argument ...]

The following standard options are recognized:
-classpath classpath
...

It could! My hands began to tremble. My heart began to pound. Could I simply do
dalvikvm -jar ruboto.jar -e "puts 'hello'"

And expect it to work?
# dalvikvm -jar data/ruboto.jar -e "puts 'hello'"
-jar not yet handled
Dalvik VM unable to locate class 'data/ruboto/jar'
java.lang.NoClassDefFoundError: data.ruboto.jar
...

Curses! Ignoring for the moment how strange it seemed to have a -jar flag that simply doesn't work, I tried specifying -classpath and org.jruby.Main.

Aaaaaaaand...

It blew up with my first official JRuby-on-Android exception!
# dalvikvm -classpath ruboto.jar org.jruby.Main -e "puts 'hello'"
HugeEnumSet.java:102:in `next': java.lang.ArrayIndexOutOfBoundsException
from HugeEnumSet.java:52:in `next'
from Ruby.java:1237:in `initErrno'
...

Hmm. The code in question simply iterated over an EnumSet. After thinking through a few scenarios, I concluded this was not JRuby's fault. It seemed that I had discovered my first Android bug, the first time I tried to run anything on it. And that made me sad.

But only for a moment! The code in question turned out to be unimportant for a normal application; it was simply iterating over a set of Errno enums we use to report errors. Commented it out, and I was on to my next issue:
(I've lost the original error, but it was a VerifyError loading org.jruby.Ruby since it referenced BeanManager which referenced JMX classes. There is no JMX on Android.

Ok, VerifyError because of missing JMX stuff...that's no problem, I can just disable it for now. So, one more attempt, and if it fails I'm going to start doing iPhone development I SWEAR.
# dalvikvm -classpath data/ruboto.jar org.jruby.Main -e "puts 'hello'"
Error, could not compile; pass -d or -J-Djruby.jit.logging.verbose=true for more details
hello

SUCCESS!

More Details

Ok, so we all agree Android dodged a bullet there. But what's the real status of JRuby on Android?

It turns out there were very few changes necessary. I fixed the EnumSet stuff by just iterating over an Errno[] (EnumSet was not actually needed). I fixed the JMX stuff by creating a BeanManagerFactory (yay GOF) that loaded the JMX version via reflection, falling back on a dummy if that failed. And I fixed some warnings Dalvik was spouting about default BufferedReader and BufferedInputStream constructors by hardcoding specific buffer sizes (I think Dalvik is wrong here, and I'm arguing my case on the android-platform ML). And that's really all there was to it. JRuby pretty much "just worked".

Of course you see the "could not compile" error up there. What's up with that?

JRuby normally runs mixed-mode, interpreting Ruby code for a while and eventually compiling it down to Java bytecode if it's used enough. But we do try to immediately compile the target script, since it doesn't cost much and gives you better cold-start performance for simple scripts. The error above was simply JRuby reporting that it could not compile my little -e script. Why couldn't it? Because the JRuby compiler is generating JVM bytecode, not Dalvik bytecode. Dalvik does not run JVM bytecode. Here's the actual error you get:
# dalvikvm -classpath data/ruboto.jar org.jruby.Main -d -e "puts 'hello'"
could not compile: -e because of: "can't load this type of class file"
java.lang.UnsupportedOperationException: can't load this type of class file
at java.lang.VMClassLoader.defineClass(Native Method)
at java.lang.ClassLoader.defineClass(ClassLoader.java:261)
at org.jruby.util.JRubyClassLoader.defineClass(JRubyClassLoader.java:22)
...

So that's caveat #1: this is currently only running in interpreted mode. To avoid the compiler warning, you can pass -X-C to JRuby to disable compilation entirely.

Unfortunately, interpretation means JRuby is none too fast at the moment. That may not matter if you're scripting a "real" app, but we'll definitely find ways to improve performance soon. That may mean providing an all-at-once compilation tool for Ruby code (we have an ahead-of-time (AOT) compiler right now, but it's per-file, and still expects to generate some code at runtime), or it may mean a second compiler that generates Dalvik bytecode. Either way...it's coming.

Caveat #2 is that a large number of libraries aren't working, especially any that depend on native code:
# dalvikvm -classpath data/ruboto.jar org.jruby.Main -X-C -e "require 'readline'"
-e:1:in `require': library `readline' could not be loaded: java.lang.VerifyError: org.jruby.ext.Readline (LoadError)
from -e:1
# dalvikvm -classpath data/ruboto.jar org.jruby.Main -X-C -e "require 'ffi'"
-e:1:in `require': library `ffi' could not be loaded: java.lang.ExceptionInInitializerError (LoadError)
from -e:1

And so on. There's nothing to say these libraries can't be made to work, but they're not working yet. And thankfully, our most important library seems to work fine:
# dalvikvm -classpath data/ruboto.jar org.jruby.Main -X-C -e "require 'java'; puts java.lang.System.get_property('java.vendor')"
The Android Project

And that leads me to caveat #3, better demonstrated than explained:
# dalvikvm -classpath data/ruboto.jar org.jruby.Main -X-C -e "require 'java'; import 'android.content.Context'"
Class.java:-2:in `getDeclaredMethods': java.lang.NoSuchMethodException
from ClassCache.java:137:in `getDeclaredMethods'
from Class.java:666:in `getDeclaredMethods'
from JavaClass.java:1738:in `getMethods'
...

Bummer, dude. There seems to be some feature (i.e. a bug) preventing some Android core classes from reflecting properly, which means that for the moment you may not be able to access them in JRuby.

Next Steps

Overall, I think it was a great success. We obviously weren't doing anything in critical JRuby code that Android could not handle. Kudos to the Android team for that, and kudos to us for still supporting Java 1.5. But success in software only leads to more opportunities:
  • All the changes necessary to run JRuby on Android have already been shipped in JRuby 1.2RC1. So you can grab those files and dex them yourself, or wait for me to add Android-related build targets.
  • Android's default stack size is incredibly small, 8kb. So for all but the most trivial Ruby code you're going to want to bump it up with -Xss. See the final snippit at the bottom of this post for an example. And of course you all know about using -Xmx to increase the max heap; it applies to Android as well.
  • I need to report the bugs I've found in Android's bug tracker and provide some steps to reproduce them. I'll probably get to this in the next couple days. Hopefully they can be fixed quickly, and hopefully patched Android doesn't take too long to filter out to users.
  • Meanwhile, I'll probably start poking at an all-at-once compilation mode, since I think that's simpler initially than emitting Dalvik bytecode. It's already done in my head. You'll run a command to "fully compile" a target script or scripts, and it will create the .class file it does now along with all the method binding .class files it normally generates at runtime. I've been planning this feature for a while anyway. With the "completely compiled" Ruby code you should be able to just "dex" it and upload to the device.
  • Given that most people will probably want to ship precompiled code, and given the fact that many libraries will never work, we need to modularize JRuby a bit more so we can rip out unsupported libraries, parser guts, interpreter guts, and compiler guts. That should shrink the total size of the binary substantially. And I have other ideas for shrinking it too.
  • We in the JRuby community also need to start brainstorming how to use this newfound power. Assuming the above items are all completed soon, what will we want to do with JRuby on Android? Build apps entirely in Ruby? Script existing ones? What Ruby features would we be willing to drop in order to boost Android-based performance a bit more? Hopefully this discussion can start in the comments and continue on the JRuby mailing lists.
The Bottom Line

JRuby works on Android, that much is certain. The remaining issues will get worked out. And I dare say this is probably the best way to get Ruby on any embedded device yet; after dexing, it's literally just "upload and run". So there's a great opportunity here. I'm excited.

And just one more example to show that not just JRuby itself, but also Ruby libraries that ship with it work (using the "complete" JRuby jar in this case):
# dalvikvm -Xss128k -classpath data/ruboto.jar org.jruby.Main -X-C -e "require 'irb'; IRB.start"
trap not supported or not allowed by this VM
irb(main):001:0> puts "Hello, JRuby on Android!"
Hello, JRuby on Android!
=> nil
irb(main):002:0>

Tuesday, February 24, 2009

Domo Arigato, Mr. Ruboto

# cat test.rb
require 'java'
import java.lang.System

class Ruboto
def greet(who)
puts "Hello, #{who}!"
end
end

name = System.get_property('java.runtime.name')
Ruboto.new.greet(name)

# dalvikvm -classpath ruboto.jar org.jruby.Main -X-C test.rb
Hello, Android Runtime!




Portions of this page are modifications based on work created and shared by Google and used according to terms described in the Creative Commons 2.5 Attribution License.

Wednesday, February 18, 2009

JRuby 1.2: Coping With Bugs

We get a lot of bug reports on the JRuby project. No, it's not because JRuby's a buggy POS. It's because we're implementing the core of an entire platform. It's hard.

Over the past year or so we kinda let the bug tracker go a little wild. We've never had more than two full-time people on the project, and community contributions wax and wane with the seasons, so we've had to choose our battles. For some amount of time, we would focus on performance, since without a reasonably-performing implementation, nobody would choose to use JRuby. Then we'd cycle back to fixing bugs, usually in the last couple weeks before a release. So the flow of bug fixes waxed and waned with our release cycles.

The problem with this approach was that we really couldn't keep up with all the reports coming in and continue to work on the "unreported issues" of JRuby like performance. So something had to give, and it was sometimes the bugs.

Roughly around September, we crossed an important threshold: 500 open bugs. They dated as far back as 2006 (we moved to Codehaus in 2006), and across the entire release sequence of JRuby; there were even some bug reports against pre-1.0 versions. From September until about mid-January, we worked to keep the number of open bugs below 500. Sometimes it would peek above, but we were generally successful.

About mid-January, I figured it was time to really bite the bullet, and I started walking from the oldest bug forward. It has been a long slog, but I'm making great progress.

So far, I've managed to whittle the total number of bugs down from 506 to 326, and that's with a couple dozen more filed in the past two weeks. The majority of these were either already fixed or invalid/incomplete bugs, but I've also made a concentrated effort to focus on and fix as many as possible. At the very least, I've made an attempt on every single one.

During that process, I learned a bit about how my brain works. During the past year, if I didn't know immediately how to fix a bug I often walked away from it and worked on something fun like compiler optimization. But during this latest bug hunt, because I did not want to just punt all those bugs one more time, I did something a little different.

Whenever I encountered a bug that seemed difficult or that I simply didn't want to fix, I would do one of two things:

  • Take a break. Often this meant I had reached my limit and needed a breather. A little Wii, a glass of scotch, a movie...anything to take my mind of it for a bit.
  • Count to ten. Sometimes, after reading through the bug, all I really needed was a moment for my brain to start "wondering" about the solution. Once the wheels started turning, I was almost compelled to dig deeper.
As a result, many long-standing bugs--including bugs I thought we would never fix--are now resolved and ready for the 1.2 release. I'm going on three weeks now of 12-hour days trying to fix what seems like an endless stream of bugs, but the end is in sight. And I want to stress that this level of effort has never happened in a single release. There's as much work in JRuby 1.2 as in multiple 1.1.x releases combined. I'll be blogging more of these posts over the next couple weeks.

For your amusement, here is the complete list of bugs we have resolved during the past nine weeks, since shortly after the 1.1.6 release. These aren't all fixes, but even the "already fixed", "won't fix", "not a bug", or "incomplete" ones were reviewed, tested, and considered. A couple of these I just applied patches or marked resolved based on someone else's work. And of course we're not done with JRuby 1.2 yet. Just you wait and see :)

Bugs Resolved (Fixed, Won't Fix, Not A Bug, or Incomplete Information), Past Nine Weeks:

(in the order they were resolved)

JRUBY-2538

File#chmod always returns -1, fails rubyspec

JRUBY-1505

Solidify public APIs separate from those that might change

JRUBY-3208

ant task api-docs runs out of memory, patch included

JRUBY-3221

Rubinius -bad instanceof tests in RubiniusMachine for attempt at fast path evaluation

JRUBY-3232

Zlib::GzipReader.each_line yields compressed data

JRUBY-3244

[PATCH] Support atime updates via utime

JRUBY-3249

Testing errors in test_java_mime.rb

JRUBY-3250

test_java_pkcs7.rb - Problem coercing Bignum into class java.math.BigInteger

JRUBY-2992

Bad cast in jruby-openssl X509Utils

JRUBY-3204

IO.read and IO.readlines do not take a block

JRUBY-3251

ConcurrencyError bug when installing Merb on JRuby

JRUBY-3248

jruby can't load file produced with jrubyc

JRUBY-3257

RaiseException#printStrackTrace doesn't deal well with nil messages

JRUBY-3259

sqlite db file on MRI is put in db dir. We put it in CWD.

JRUBY-3260

:date is stored as integer (not date) in sqlite3

JRUBY-2425

NPE at Connection Shutdown

JRUBY-2329

java.lang.NullPointerException when trying to connect to a Oracle XE database

JRUBY-3023

Renaming indexed columns fails

JRUBY-2384

Rails migrations fail with: undefined method `create_database' for class `#'

JRUBY-2400

ActiveRecord/JRuby Memory leak in update_attributes!()

JRUBY-2040

new samples/jnlp dir: includes both unsigned and signed examples that work in Java 1.5 and 1.6

JRUBY-3270

using activerecord 'to_xml' method crashes JRuby (and debugger)

JRUBY-3277

Constant lookup should omit topmost lexical scope; not bail out on first Object-hosting lexical scope

JRUBY-3278

Array#reduce is undefined

JRUBY-3187

JRuby command line scripts do not work with spaces in the path

JRUBY-3267

patch attached to update eclipse .classpath to refer to bytelist-1.0.1.jar

JRUBY-3280

patch attached to update eclipse .classpath to add new jars in build_lib/

JRUBY-3276

New IO#readpartial and IO#seek spec failures

JRUBY-3256

jruby -S script/console fails in Rails application

JRUBY-3199

IllegalArgumentException in X509V3CertificateGenerator when executing Hoe's rake gem running on SoyLatte JDK

JRUBY-3275

New ARGF spec failures

JRUBY-3287

Add public RubyInstanceConfig#setCompatVersion

JRUBY-3171

loading rake breaks import

JRUBY-3290

Float range to restrictive in FFI code

JRUBY-2826

Array#pack('w') is broken (exceptions and wrong results)

JRUBY-3116

ArrayIndexOutOfBoundsException in tmail

JRUBY-2522

Can not execute JRuby 1.1.1 "ant test" with IBM JDK

JRUBY-2426

JRuby trunk does not build with IBM JVM 1.5

JRUBY-3042

undefined method `quote' for Regexp:Class (NoMethodError) when runs gem list on AIX with IBM JAVA 1.5

JRUBY-1950

'-i flag not supported

JRUBY-3302

Doesn't biuld on windows for ffi problem

JRUBY-3303

[1.9] splat of array at front of assignment broken (same for other grammatical constructs)

JRUBY-3307

tempfile.rb sucks in JRuby

JRUBY-3305

Fixnums & Floats should be coerced to the narrowest java.lang.Number when passed to a java method that expects Object

JRUBY-2768

jdbc_mysql.rb should not enforce the utf8_bin collation on table creation

JRUBY-2115

Error doing add_column with Derby and jdbc-adapter-0.7.2

JRUBY-2967

[PATCH] Derby handling of binary/date/time fields. hsqldb handling of binary fields.

JRUBY-2647

[activerecord-jdbcsqlite3 adapter] Date/Datetime/Time fields simplification to INTEGER sqlite storage type is not correctly handled

JRUBY-3073

JRuby script engine does not load on IBM JDK

JRUBY-3109

Update stdlib to an appropriate 1.8.6 patchlevel

JRUBY-2541

Time assumes UTC timezone

JRUBY-3254

Make JRuby's Time#local behave more like MRI

JRUBY-2740

BigDecimal#precs fails two new rubyspec tests

JRUBY-3298

Kernel.srand calls #to_i on number

JRUBY-2987

Kernel#system does not work correctly

JRUBY-3242

Performance degradation on write operations

JRUBY-2128

error accessing JRuby DRb server from MRI DRb client

JRUBY-3268

JRuby DRb client cannot connect to MRI DRb server

JRUBY-3274

Many new Array#pack failures in updated RubySpecs

JRUBY-3147

Time#_load RubySpec failures

JRUBY-3146

Time#_dump RubySpec failures

JRUBY-3148

Array#fill spec failures

JRUBY-3142

Dir.pwd correctly displays dirs with unicode characters in them

JRUBY-2609

spec --line does not work with JRuby

JRUBY-3317

require "tempfile"; Dir.tmpdir fails

JRUBY-2364

The private keyword doesn't change visiblity of previously called methods with same send/call site

JRUBY-2796

Missing constant in Process::Constants on Mac OS X (darwin)

JRUBY-3226

Including more than one java interface stops Test::Unit execution

JRUBY-3035

Get Rails tests running in a CI server somewhere before 1.1.6 release, to ensure no future breakages

JRUBY-3318

If 'jruby' executable is a relative symlink, JRuby won't start

JRUBY-3328

Incorrect behavior for case/when when true or false are the first conditions

JRUBY-3269

SystemStackError with YAML.dump

JRUBY-3229

Javasand does not compile with JRuby 1.1.5

JRUBY-3333

idea

JRUBY-3332

ConcurrentModificationException In Application Startup

JRUBY-3329

Major divergence in threading behaviour between Ruby 1.8.6 and JRuby 1.1.6

JRUBY-3308

Deadlock between RubyModule.includeModule() and RubyClass.invalidateCacheDescendants()

JRUBY-3324

Error in string encoding conversion

JRUBY-3340

String#unpack('m') fails with ArrayIndexOutOfBoundsException

JRUBY-3341

The body of POST requests is not passing through jruby-rack

JRUBY-3312

JRuby can double slash ("//") the directory given by __FILE__ when "everything" suits this thing to happen. :-)

JRUBY-2884

jdbc_postgre.rb issue handling nil booleans

JRUBY-2208

Memory Leak in ActiveRecord-jdbc or JRubyEngine used with BeanScriptingFramework

JRUBY-2897

jdbc_postgre.rb needs microsecond support

JRUBY-2995

activerecord jdbc derby adapter should quote columns called "year"

JRUBY-2949

jdbcderby adapter should ignore :limit for INTEGER

JRUBY-2718

jdbcsqlite3 at JRuby on Rails do not work properly

JRUBY-3344

Update H2 to a later version

JRUBY-3342

Wrabler escapes config.ru twice

JRUBY-3282

Upgrade to derby 10.4.2.0 to allow unique constraints with nullable columns

JRUBY-2767

Mistake in selecting identity with H2/HSQLDB

JRUBY-2433

java.lang.IllegalArgumentException in debug mode when using CLOB

JRUBY-3310

Race condition in JRuby when Active Support is overriding Kernel.require

JRUBY-3127

Inconsistent DynamicScope instances in evalScriptlet

JRUBY-3339

java.lang.ArrayIndexOutOfBoundsException in RubyArray.java

JRUBY-3351

Tempfile defaults to a directory that does not exist on Windows

JRUBY-3353

String#unpack invalid output

JRUBY-3361

Compiled case/when blows up with arrays as when clauses

JRUBY-3362

attr_accessor, attr_reader, attr_writer, and attr not obeying visibility

JRUBY-1034

Post parse processing of the result comment placing as example

JRUBY-48

Ability to write JUnit4+ tests in JRuby

JRUBY-1572

Allow visible fields from inherited Java classes show up as instance variables (@foo)

JRUBY-2108

IOWaitLibrary ready? returns nil when ready

JRUBY-1895

JRUBY-1890 IO.popen does not support "-"

JRUBY-852

jirb exits on ESC followed by any arrow key followed by return

JRUBY-2015

"RAILS_ROOT" cannot be put on a place different from "Context root" in Goldspike.

JRUBY-2139

jruby.compile.frameless=true cause "Superclass method 'initialize' disabled."

JRUBY-2174

Method#to_proc.call invocations much slower than normal Method#call invocations

JRUBY-2170

Very unverbose message when problem with native library exists

JRUBY-3338

jIRB cannot get any input with Polish characters (utf-8) on Mac OSX

JRUBY-2252

Kernel#exec should not raise SystemExit

JRUBY-1855

EOF handling in case of reading program from standard input

JRUBY-1997

System.gc() is extremely expensive when calling Java code from JRuby

JRUBY-821

getting in $SAFE level 4 freezes

JRUBY-1770

weakref-based singleton class "attached" can blow up in certain unusual circumstances

JRUBY-1555

DST bug in second form of Time.local

JRUBY-1872

next statement should return the argument passed, not nil

JRUBY-2214

Pure-Java version of lstat doesn't fail on non-existing file

JRUBY-1901

standardize and publish public API for embedders

JRUBY-2211

SNMP Requests does not timeout properly

JRUBY-2298

We should generate method binding code with APT

JRUBY-2305

File output cuts off at a certain point?

JRUBY-2306

NPE in org.jruby.RubyIO.flush

JRUBY-2288

UDP locking problems when receiving from multiple senders on same port

JRUBY-2333

usage of unexistant variable in REXML::SourceFactory

JRUBY-2346

Nailgun does not compile under HP-UX

JRUBY-2353

Process.kill breaks up JRuby, while works in MRI on Windows

JRUBY-2369

'ant spec' failures on on MacOS

JRUBY-2168

test_io (test_copy_dev_null) fails under WinXP

JRUBY-2410

Multiple assignment could be made faster by not returning unused array

JRUBY-2389

java.util.ConcurrentModificationException

JRUBY-929

Java input/output streams from Ruby string's backing byte array

JRUBY-1681

Pathological slowdown in Array#insert

JRUBY-1470

FileTest methods only work with string arguments

JRUBY-1576

multi-byte character encoding probrem

JRUBY-2119

Jruby shell script don't work on KSH shell

JRUBY-3360

Pure-Java tempfile does not use a #make_tmpname callback

JRUBY-2518

Dir["some glob"] doesn't work for files inside a jar

JRUBY-3367

Dir.glob processes nested braces incorrectly

JRUBY-3366

Faulty marshalling error blows up in ActiveSupport

JRUBY-2027

Problems with the H2 jdbc adapter, schema metadata behavior

JRUBY-2417

Make fields immutable where possible

JRUBY-1565

ReWriteVisitor transforms Fixnums into base 10 despite their original format

JRUBY-2917

Missing peephole optimizations in parser, compiler

JRUBY-2542

DATA.flock causes ClassCastException

JRUBY-2545

Recursively locking on a mutex results in deadlock

JRUBY-2285

Regression: rubyspec run with -V option breaks JRuby

JRUBY-2120

Wrong stacktraces from exceptions about wrong number of arguments

JRUBY-1639

Exception when stopping WEBrick running the new rails application

JRUBY-2534

jdbcpostgresql adapter inserts invalid number literals into generated SQL, causes exceptions

JRUBY-3375

'attr' implementation is incompatible with MRI 1.9.1 behavior

JRUBY-3365

Objects with custom to_yaml methods break collection to_yaml

JRUBY-2603

Couple of new rubyspec failures for URI library

JRUBY-2465

2 digit year resolves to 1st century rather than 20th when using postgres timestamp with timezone + activerecord-jdbcpostgresql-adapter

JRUBY-2672

BasicSocket#close_read and #close_write not working

JRUBY-2655

TCPSocket.new('localhost', 2001) connects on the wrong interface

JRUBY-2759

Time Zone "MET" maps to Asia/Tehran

JRUBY-2758

Class Socket is missing #bind

JRUBY-2761

Thread#wakeup fails when sleep is called with a parameter

JRUBY-2772

Zlib::Deflate doesn't appear to deflate

JRUBY-3289

ArgumentError: dump format error() when unmarshalling Rails session and EOFError when unmarshalling hash with containing value of type ActionController::Flash::FlashHash

JRUBY-3228

Some error saving to a Rails session [Marshalling bug?]

JRUBY-2792

Net::HTTP spec failures in get_print spec; IO not getting expected "print" call

JRUBY-2804

IO.popen of 'yes' process hangs on close

JRUBY-2755

Precompiled scripts do not set initial position information correctly

JRUBY-2484

unicode symbol not supported as in MRI

JRUBY-2817

File.chown works with 64bit JDK, but raises NotImplementedError on 32 bit JDK

JRUBY-2912

MS SQL-Server - Create/Drop Database bug

JRUBY-2815

System triggered from inside of tracing behaves oddly

JRUBY-3069

dbd-jdbc: Support Ruby DBI Statement.fetch_scroll

JRUBY-3235

dbd-jdbc: Add helper functions to wrap already existing jdbc Connection and Statement objects

JRUBY-3068

dbd-jdbc: Override Ruby DBI's default database return value coercion for Date / Time / Timestamp columns

JRUBY-3067

dbd-jdbc: Register a handler for DBI 0.4.x's default parameter binding type coercion

JRUBY-1345

Files added to a module via Kernel.autoload are not automatically loaded if the class they contain is extended

JRUBY-2727

ActiveScaffold 1.1.1 fails with JRuby 1.1.2, probable path problem

JRUBY-2699

If user's PATH contains '.' and 'jruby' resolves to './jruby', JRUBY_HOME is incorrectly set to '.', leading to 'NoClassDefFoundError'

JRUBY-2820

Most Etc methods behave diferently on Windows under x32 and x64 JVMs

JRUBY-2841

String#<<>

JRUBY-2844

Memcache session store does not work across multiple application servers

JRUBY-2845

'-S switch breaks if you have directory in pwd matching name of file in bin/PATH

JRUBY-2849

CCE using proc{} in AR callbacks

JRUBY-2862

Improve JRuby::Commands' handling of bindir

JRUBY-2861

Cannot call super inside a method that overrides a protected method on Java base class

JRUBY-2868

ThreadService.getRubyThreadFromThread supports only one non-rubynative thread at a time.

JRUBY-2782

"No such file or directory (IOError)" when JAR file named in java.class.path but not active filesystem

JRUBY-2901

JRuby does not support options in shebang line

JRUBY-2846

gem generate_index broken

JRUBY-2832

Rails static page caching won't generally work with Java ServletFilter unless some serious hack with the cache directory is found

JRUBY-414

Serialization of wrapped Java objects could be handled as user-marshalled data by Marshal

JRUBY-2921

Newly overridden methods are not called if the old superclass method has already been called

JRUBY-2661

specs hang under Apple Java 5

JRUBY-2933

Ruby runtimes are pinned to memory due to ChannelStream

JRUBY-1578

Incomplete HTTS response from Microsoft IIS servers using net/https

JRUBY-2941

popen IO lockup with multiple threads

JRUBY-2925

Java Integration can now instantiate Java classes with no public constructor

JRUBY-2802

JRuby wrapped Java objects formerly exposed readers for non-public fields

JRUBY-2504

JAR URLs are inconsistently supported by APIs that access the filesystem

JRUBY-1846

Kernel::fork should use forkall(2) on solaris instead of fork(2)

JRUBY-2395

Have to call setPaint instead of assigning to g.paint

JRUBY-1401

Pathname#realpath fails for Windows drive letters

JRUBY-2296

convertToRuby does not work if to_s does not return a String (but for example nil)

JRUBY-2904

Need a better solution for tracking Java object wrappers

JRUBY-1327

When define_method replaces an inherited Java method, the ruby_case_version is not replaced

JRUBY-2951

repeated popen call may throw NULL pointer exception

JRUBY-2974

multi-byte exception message turned into garbled characters when Java Exception nested NativeException.

JRUBY-2980

String#<<>

JRUBY-2981

alias_method_chain pattern is extremely show on jruby

JRUBY-2982

Unicode regular expressions by UTF-8 don't work

JRUBY-2988

jirb does not echo characters to the terminal after suspend and resume in the shell

JRUBY-2997

Dir[] results in NPE depending on permissions

JRUBY-3000

integration issues with Java classes containing inner classes

JRUBY-3007

Message method value of Exception is missing in Java when exception raised in ruby

JRUBY-3016

Nested Class/Enum issue with JRockit

JRUBY-3011

java classes with non-public constructors are incorrectly instantiated

JRUBY-2999

Regression: Inheriting method with same name from two Java interfaces causes Java classloader error

JRUBY-2700

jdbcsqlite3 adapter does not respect default parameter

JRUBY-3026

[Derby] Allow select/delete/update conditions with comparison to NULL using '='

JRUBY-3288

jruby-openssl: SSLSocket.syswrite error for big (>16k) data

JRUBY-3017

DRb "premature header" error on JRuby client

JRUBY-2766

Create caching mechanism for all our many calls to callMethod from Java code

JRUBY-3200

insert statement returns null from the postgresql jdbc adapter

JRUBY-2996

Migration step with create_table with string column with :default => "" fails due to missing default value in SQL

JRUBY-2184

ActiveRecord is slower on JRuby than on MRI

JRUBY-3202

url style Postgres configuration is broken in rake.

JRUBY-1854

def is almost 3x slower in JRuby

JRUBY-2618

Table does not exist error possibly caused by upper case table name

JRUBY-3003

ArrayStoreException in compiler when calling Array.fill

JRUBY-2180

break performance is slower than MRI, sometimes slower than interpreted

JRUBY-2304

active_scaffold - No such file or directory

JRUBY-3386

Array#eql? rubyspec failure

JRUBY-3387

Array#== rubyspec failure

JRUBY-3054

Thread#status is "run" when thread is blocking on condition variable

JRUBY-3390

RubySpec: Numeric#coerce calls #to_f to convert other if self responds to #to_f

JRUBY-3055

permission javax.management.MBeanServerPermission "createMBeanServer";

JRUBY-3072

Using a ruby Numeric to set a parameter with a signature of java.lang.Integer causes a java.lang.ClassCastException

JRUBY-3082

1.1.4 unable to use 'logging' gem (works in 1.1.3)

JRUBY-3398

Attributes defined from Java tried to use current frame for visibility

JRUBY-3397

defined? CONST is not following proper constant lookup rules

JRUBY-3089

Digest::Base stores in memory all bytes passed to the digest, causing OutOfMemoryError

JRUBY-3125

Some Socket constants not supported.

JRUBY-3128

Different jruby behaviour that ruby 1.8.6/1.8.7/1.9 when running file that is named as one of required file.

JRUBY-3175

Cloning java byte array returns incorrect object

JRUBY-3177

ConcurrentModificationException

JRUBY-3178

http spec tests fail when webrick starts on address 0.0.0.0

JRUBY-2548

JRuby conversion of String to Java String is arcane

JRUBY-3174

FFI MemoryPointer#get_string(0, x) gets confused by null byte in the buffer

JRUBY-2896

jruby -S picks up script from local directory

JRUBY-3163

Incorrect namespace for CipherError

JRUBY-1853

define_method methods do not display the correct stack trace, may not be using frame safely

JRUBY-2855

Classpath search order is not respected by require when classpath includes both jars and directories

JRUBY-3222

Problems with migrations where direct type specified

JRUBY-2424

running with -rprofile with multithreaded test causes NPE

JRUBY-2691

Update sybase driver to pass simple unit tests with jtds and verify it works with the new dialect keyword

JRUBY-3065

New public LoadService#findFileToLoad method

JRUBY-2261

ThreadContext should use SoftReference instead of WeakReference

JRUBY-2116

import org.eclipse.jface.dialogs.MessageDialog -- causes java.lang.NullPointerException

JRUBY-2898

Exception trying to use BSF (java.lang.NoClassDefFoundError: org/apache/bsf/util/BSFEngineImp)

JRUBY-2003

rexml pretty printing wrap() error

JRUBY-752

undef'ing and redef'ing methods should give disabled message?

JRUBY-2262

Java toString() mapping to invoke(... to_s ...).toString() doesn

JRUBY-3121

Glassfish Gem 0.9.0 does not work with JRuby 1.1.5

JRUBY-551

JRUBY-549 bfts test_file_test failures

JRUBY-2248

Problem with active_scaffold defaults defined in application.rb

JRUBY-2446

httprequest error for a SOAP request to a Rails ActiveWebService

JRUBY-3005

Stomp gem hangs in Stomp::Client#subscribe

JRUBY-3180

Class in default package can't be reopened under Java namespace

JRUBY-3047

IO.select sometime reports Unable to establish loopback

JRUBY-2851

JDBC adapter in JAR file not being picked up by java.lang.Class.forName in 1.1.3 (worked in 1.1.2)

JRUBY-2313

Automatically convert RubyFile to java.io.File

JRUBY-2328

Overriding require causes eval to give wrong __FILE__ in certain circumstances

JRUBY-2794

Failure in String#crypt specs, Mac OS X, Soylatte

JRUBY-2137

ENV[] is case sensitive on Windows

JRUBY-2797

File.expand_path rubyspec failure on Mac OS X, Soylatte

JRUBY-2608

Examine whether -Xrs flag to JVM could be used to improve our signal-handling logic

JRUBY-2675

jirb + jline do not work in cygwin

JRUBY-2521

Compilation Warning for Sun proprietary API using

JRUBY-2263

Running merb under a concurrent load causes ArrayIndexOutOfBoundsExceptions

JRUBY-2706

File.stat('/home') treated as a relative path

JRUBY-2557

NPE when yielding method

JRUBY-2860

EOFError while consuming REST web service from glassfish v3

JRUBY-2835

rails image_tag generates url get 404

JRUBY-3095

chmod_R broken

JRUBY-2830

String#unpack with 'w' is completely unimplemented

JRUBY-3038

Unable to insert YAML into t.text field (behavior different from Ruby 1.8.6)

JRUBY-3004

Excess warnings when using rake TestTask

JRUBY-1606

File.expand_path does not work as expected

JRUBY-750

defineAlias reports original name and not aliased one in stack traces

JRUBY-1201

TCPSocket.new(dest_adrr, dest_port, src_addr, src_port) missing from JRuby

JRUBY-3160

REXML returns error for add_attribute

JRUBY-2732

org.jruby.util.RubyInputStream is unused

JRUBY-2455

"jruby" script failed to find JRUBY_HOME leads to class not found

JRUBY-3190

method `module_eval' for main:Object should be undefined?

JRUBY-2950

Net::IMAP#authenticate stalls / blocks in recent versions of JRuby

JRUBY-1542

1.1b1 doesn't build with gcj 4.2

JRUBY-2788

Make Time.now monotonically increasing

JRUBY-3296

Etc.getpwuid should raise TypeError if invalid type

JRUBY-3167

loadpath and classpath problem

JRUBY-2983

JRuby crashes after running 110 RSpec examples

JRUBY-3085

Add constant caching for Colon2 and Colon3 (specific module and Object cases)

JRUBY-3207

super error message is inaccurate when superclass doesn't implement method.

JRUBY-2979

File#getc fails on illegal seek when reading from /dev/ttyS0 on Linux

JRUBY-3076

RubyUDPSocket.send tries to do inet address lookup, pauses too long for inet6 failure

JRUBY-2555

CLONE -JIT max and JIT threshold should be adjusted for improvements in JRuby over the past months

JRUBY-3407

FFI Stack Level Too Deep on Library.send(:method, args)

JRUBY-3410

Add -y flag to debug the parser

JRUBY-3103

Compiler closures use two different binding mechanisms, need better construction and caching logic

JRUBY-3179

JRuby can't handle do/end blocks within String-inlined expressions

JRUBY-3316

Group expression class path fails to parse

JRUBY-3151

OpenSSL::Random#pseudo_bytes raises ArgumentError on negative arguments

JRUBY-3088

"RStone" port of PyStone is slower on JRuby than 1.9

JRUBY-3120

Regression: error serializing array of objects with custom to_yaml def to yaml

JRUBY-3211

builder library is slower in JRuby than in MRI

JRUBY-1884

handling of file close while reading differs from mri

JRUBY-3214

load and require don't work correctly for .class files

JRUBY-3218

Import is sometimes confused by unquoted class name

JRUBY-3224

Array#to_java with java object reference doesn't carry over object identity

JRUBY-1079

IO.sysopen not defined

JRUBY-3071

Illegal seek error trying to read() from pipe

JRUBY-3152

Process.times returns invalid values

JRUBY-3064

Process.uid does not work on non-natve platforms (jna-posix)

JRUBY-2757

Compiled argument processing and arity checking are too large, too much bytecode

JRUBY-3061

NKF(unsupported Q encode stream)

JRUBY-3105

Embedding JRuby-Rack (non-war deployment)

JRUBY-3077

Update ruby_test tests and incorporate changes into build

JRUBY-2970

Timeout.rb is not working in special cases (Thread may block whole application).

JRUBY-3253

Lack of default jruby.home in embedded usage causes NPE

JRUBY-3063

File::link using CIFS raises Errno::EEXIST error if the 'old_file' is open while Matz Ruby raises Errno::ETXTBSY

JRUBY-3252

Iterative String concatenation operations in JRuby degrade faster than in MRI.

JRUBY-3255

jruby -S script/server fails in Rails application

JRUBY-3258

after installing minigems (and after minigem setup gems not working on 1.1.6)

JRUBY-1235

DRb hangs when transferring Ruby objects created in Java

JRUBY-3271

Java Stacktrace and exception is swallowed

JRUBY-2063

Wrong monitor handling in o.j.util.ChannelStream.read

JRUBY-2131

Select with nil arrays should throw an exception