include_package doesn't seem to propagate constants right

appears a work around is to reference it before needing it in the internal class:

  require'java'
 
  module M
    include_package "javax.swing"
    include_package "java.awt.image" # BufferedImage
    BufferedImage
    class ShowImage < JFrame
     BufferedImage.new
    end

  end

Or use M:: prefix.

module M
  include_package 'javax.swing'
  include_package 'java.awt.image'

  class ShowImage < JFrame
    M::BufferedImage.new 100,100, M::BufferedImage::TYPE_BYTE_GRAY
  end
end

Because there's no standard API on the JVM for getting a list of all classes in a given package, include_package works by adding a const_missing hook. The unfortunate side effect is that what looks like normal constants (the const_missing-provided classes) do not propagate according to constant-scoping rules (since const_missing only fires on the actual class, not up-hierarchy or up-scope as constant lookups do).

We have toyed with some utilities for actively adding constants during an include_package, but they're all only partial solutions and they all ignore the fact that new classes could be loaded into the same package later. As a result, there's no way to fix this.

I recommend a pattern where you have a single Ruby file that defines a nice Ruby module that explicitly imports all classes you need. Add additional classes there, and avoid include_package if you want to have consistent constant scoping behavior.

Is re-tooling const_missing (i.e. before doing const_missing, scan parents for included packages, check for classes) an option?

If not maybe it would be useful to include a helper.

Either one of the utilities you mentioned, just make it explicit that it only loads currently available classes, or some ruby helper that overrides const_missing, like

 
module M
  class A
    redirect_const_missing_to(M)
  end
end

or some odd...

We could make include_package insert a special pseudo-module into the hierarchy that has extra smarts in its const lookup logic. This would allow the normal hierarchical constant search to be aware of package imports and run another check in addition to looking at the normal constant table.

It would be a bit hacky, but it's doable...

maybe there's a way to add something like

class A
include_package 'org.abcd'
end

?

that would be especially useful if it could be "global" or what not (like you can set it to make those classes available everywhere).

It might be a nice work around if either of these two were made possible:

import 'java.io.*' # sucks in what classes it knows about -- this would be enough, or
for class in java.io.enum_current_classes; import class; end

Thoughts?
=r

I've started a separate bug to discuss improvements to include_package here: http://jira.codehaus.org/browse/JRUBY-5558