[ruby-talk:21250] request for help

For a few days now I've been toying with a pet project I came up with when I
read about Tcl Blend.  Tcl Blend is a Tcl extension which allows you to script
Java components, but it is not a pure Java interpeter (which was the benefit in
this case, Jacl is a pure java Tcl interpreter).  At any rate I got to thinking
that Tcl blend could be used (since most ruby installations also have Tcl on
the same machine) to bridge Java and Ruby (especially since I knew Tcl
already).  As the code started to take shape so did my general expectations of
what was possible and how to do it, and Tcl's simple procedural structure has
turned out to be a great asset here rather than a hindrance, allowing me to
impose my own OO structure.  Before I provide facilities for events and
exceptions however, I need to get the object behavior right.  Until now, I have
been able to figure out the behavior of the tcltk interface Ruby provides,
despite the fact that there seem to be some very strange (at least from my
point of view, since I can't read the documentation), string interpolation
happening in the background.  But I've run into something I can't explain, or
figure out despite my best attempts when I've been filling in the JArray class
(specifically line 177 in the getrange method).  These are primitives which I
will use in the forthcoming [], and []= methods.

Which leads me to ask for help from anyone who knows just what is going on here
with tcltk.

I suppose I should give a quick little summary (very quick) of this project
just to get any good samaritan started.  Essentially Ruby interacts with Java
via Tcl (through it's Tcl blend extension).  The basic premise of my system is
to encapsulate the procedures in the java package within three things, the Java
module, which provides a namespace for procs which don't belon anywhere else,
and JObject and JArray, which act as the foundation of the object system.  When
you start up a JObject it uses the introspection capabilities provided by tcl's
java package to gather information about the methods of the Java class you are
initializing (through some very cumbersome parsing code I might add, which is
very open to suggestions by people who grok regular expressions and understand
the string representation of Tcl lists).  Once it has this information, it
defines those methods within the instantiated JObject, so each JObject,
although sharing some base functionality, has different methods depending on
what Java class it was initialized to.  (note: once I have JArray up and
running I'll also do the same for attributes, which will be implemented via
defining name, and name= method much the same way I've done for methods).  This
allows for code such as:

frame = Java.create 'java.awt.Frame'
#to_j is a convenience method I added to String, 
#instantiates a Java string which is passed as the arg to setTitle
#necessary because I don't understand the tcltk interface
frame.setTitle 'hello from Ruby!'.to_j
frame.setVisible true

And will, in the future allow for conveniences such as using [], and []= on
JArray's (with and without Ruby ranges), once I have the primitive methods
(same name as in tcl's java module) filled in.  The default behavior is for
java methods which return a value to always return a String object, but this
can be changed by supplying a few prebuilt procs provided by the Java module as
blocks to whatever the name of the Java method was eg:

#ok since returns a Java string which automatically becomes a Ruby string
title = frame.getTitle
#otherwise it will return a string representation of an integer
width = frame.getWidth &(Java.integer)
#you need this whenever you expect to get a handle to a Java object, otherwise
it will return a string
#representation (example: "java0x4") from Tcl of the Java object, and since no
reference to that Java
#object will exist in Tcl it is subject to garbage collection
size = frame.getSize &(Java.noconvert)

Later on I might use David Alan Black's behaviors package to clean this whole
system up a bit, maybe introducing &(Java.noconvert) as simply &nc for example?
 But that's after I have a more complete system operational, since I don't
believe in having rigid top down models (read Paul Graham's "ANSI Common
Lisp").  Which leads me to some final points:

1) This system is *highly* incomplete, so don't use it in *anything* for now.
2) I mean it, this is not beta, or alpha or anything close, it's a request for
help at the moment.

Whenever this does get released, Ruby Blend as a name seems appropriate, since
it's just a thin layer of Tcl Blend, and its license will be whatever Ruby
uses.  I know there is another project in the works for Ruby-Java integration,
but with any luck this could be in beta stage within a few weeks, so it should
give people something to tide them over until the real thing arrives.  That's
it for now and I appreciate anyone who can help.
best regards,
Alexander Schofield

PS:
get Tcl Blend from dev.scriptics.com, also the documentation for it.  They also
have a whitepaper which describes a bunch of very cool things like embedding
Java awt componenets in Tcl widgets, and if someone knows where there are
examples of this it would be a very cool thing to consider in Ruby Blend.
I warn you though, for unices it's only available as source code, which
souldn't be a problem except on two boxes (solaris 2.8 and a Linux on a 2.4
kernel) I've had no luck getting it to work, after hacking out much obsolete
material from the Makefile I got it to compile, but never to work, which is why
against my will this was all developed on win32, since it was simpler to just
download the binaries and a copy of vim than it was figuring that one out.