Okay, so it's time to writeup this whole way of working.

The basic concept is that we checkout code from a subversion repository,
and it becomes the code that runs when we execute that command from
anywhere on the system, without having to use LIB options, absolute
paths or etc.

For Perl code, we use the $PERL5LIB environment variable, but only
because of where the symlinks are made.  If you wanted to compile perl
with a specific directory, or create symlinks into your global LIB
directories, that works too.  It's basically about permissions, and
whether you want to synchronize the symlinks across multiple systems.
Ideally, svn would support symlinks and we could just checkin the
symlink directories (update:  it does, but I haven't found that to be
directly useful in the context of this system.)  Anyway, I'm getting
sidetracked here.

With Python, the PYTHONPATH variable has a similar function.  Also,
RUBYPATH for ruby.

To check your setup:

perl -e 'print join("\n", @INC);'

python -c '
import sys
for p in sys.path:
  print p'

ruby -e 'puts $:'

The same scheme should work for any interpreted code, be it libraries or
scripts.  For compiled code, a similar system could be used, but I
haven't explored this.

With the utilities in "Module-Subversion-Juggle/trunk/data/scripts/", we
can maintain a huge pile of symlinks which all point back to one or more
central locations.  To bootstrap the system, first do this:

  mkdir -p /usr/local/perl_lib/svn_hop/
  cd /usr/local/perl_lib/svn_hop/
  svn co http://ericwilhelm.homeip.net/svn/Module-Subversion-Juggle/
  cd Module-Subversion-Juggle/trunk/data/scripts/
  perl hop_to_links ./ ~/.bin/

Now there is a link in your ~/.bin/ directory to everything in the
scripts/ directory.  Existing files will not be over-written.  Note that
the links are to absolute paths, so the "./" directory works fine.  This
is NOT how "ln" works.  The "relink" program has a similar function, but
will overwrite existing symlinks (not existing files.)

This just scratches the surface.  hop_to_links is capable of creating
links for nested directories, but it only creates links to files.  If
the directory structure does not exist, it creates the directories and
puts the links inside them.

So, to install links for the Math::Vec library, you would do this:

  mkdir /usr/local/perl_lib/stable/
  cd /usr/local/perl_lib/
  ln -s stable active
  cd ../svn_hop/
  svn co http://ericwilhelm.homeip.net/svn/Math-Vec
  hop_to_links Math-Vec/trunk/code/ ../active/

This creates ../stable/Math/ and links Vec.pm into it.  Now, all you
have to do is set PERL5LIB='/usr/local/perl_lib/active' somewhere in one
of your startup files (I use "/etc/bash.bashrc".)

All of this could get confusing, so you can use which_module to find a
perl module just like you use which to find a program.

  which_module Math::Vec


########################################################################

From here, this gets a bit disjointed.  I really need to sit down and
write a proper paper about it.

What I'm working with now is a scenario like the following:

1.  Check-out one or more groups of modules from the cvs/svn server into
~/.svn_hop/, so we have a tree like so:

.
|-- CAD-Calc
|   |-- branches
|   `-- trunk
|       |-- code
|       |   `-- CAD
|       |       |-- Calc
|       |       |   `-- Line
|       |       |       `-- Extensible.pm
|       |       `-- Calc.pm
|       |-- data
|       `-- dist
|           `-- CAD
|               `-- Calc
|                   |-- Line
|                   |   |-- MANIFEST
|                   |   |-- Makefile.PL
|                   |   `-- test.pl
|                   |-- MANIFEST
|                   |-- Makefile.PL
|                   `-- test.pl
`-- CAD-Drawing
    |-- branches
    `-- trunk
        |-- code
        |   `-- CAD
        |       |-- DXF
        |       |   |-- Dime
        |       |   |   `-- functions.cpp
        |       |   `-- Dime.pm
        |       `-- Drawing.pm
        |-- data
        `-- dist
            `-- CAD
                `-- DXF
                    `-- Dime

2.  make symlinks from ~/.svn_hop/CAD-Calc/trunk/code/ to ~/.test_libs/
and export PERL5LIB=~/.test_libs

3.  Edit the files as if they were one tree under ~/.test_libs/

4.  Check-in or branch changes back to cvs

~5.  copy or install stable code into /usr/lib/perl5/.../

I'm dealing with only a few systems and only a few users, so it's not a
big deal if something unstable slips in.  It's more important for me to
be able to develop quickly and get the changes into effect, but I've
been working without version control, which can be problematic.

A few other things that I've discovered:

1.  MakeMaker will build correctly from symlinks, so symlinking the two
styles of trees together from the svn_hop/ root works great.

2.  If the svn_hop and the symlink tree are kept somewhere global, like
/usr/local/perl_lib/, then they will work identically across machines
and can be used by multiple users.