A N N O U N C I N G

                    Ruby Facets, v 2005-10-30

                The Proverbial Zoo-of-More for Ruby

ABSTRACT: Ruby Facets is a cornicopia of extension methods and
module/class
additions for the Ruby programming language. The extensions, known as
the
the Atomic Library, is unique by virtue of thier atomicity. Methods are
stored in their own files, allowing for highly granular control of
requirements. In addition Facets includes a large selection of useful
classes, modules and microframeworks (once known as Calibre Classes).

                       For More Information
                    http://facets.rubyforge.org

                 ALL YOUR BASE ARE BELONG TO RUBY!

------------------------------------------------------------------------
(from ANN)

I'm pleased to finally announce the next major release of Facets
--the Halloween release (2005-10-30). Baring any signifficant
issues arising in Novemeber, this release will be stamped "Stable"
on the first of December.

If you'll recall, our last release was a brief flirt with new names
Nano Methods and Mega Modules. With this release we've decided to
go back to the original name Facets, having deemed it in the interm
to be the better course, and to which it will *stay for good*.
Namespace compatability is being maintained with this release, so
all the following will work as expected:

  require 'facet/...'
  require 'nano/...'
  require 'mega/...'

This release also begins a transition to a more robust require
mechanism. You should require the main facitlity before utilizing
the rest of Facets with:

  require 'facets'

This loads all base methods (about a two dozen very basic methods)
and the Facets module. Then, where you would have used the
Kernel#require method like so:

  require 'facet/time/stamp'    # to be deprecated

You should instead begin transitioning to:

  Time.use Facets, :stamp

Using this method allows Facets to work more perceisely and
efficiently.
For instance one of the clear advantages of this method is that Facets
can search the class hierarchy for a method. For example if you wanted
to use #each_permutation on an Array.

  Array.use Facets, :each_permutation

And even though #each_permutation is an Enumerable method this will
still work. It also allows for the use operators without special
recourse. For instance, the Proc composition operator can be required
simply:

  Proc.use Facets, :*

The reason the Facets module is specified is because #use is a general
method. Anyone can easily take advantage of this functionality by
utilizing Facets Module Code Package system (package.rb). See the API
Documentation for further details of putting this to use in your
programs.

All in all, there's plently of new stuff in here and a good bit of code
clean-up. Some of the most notable additions include:

  * annotation.rb - An advance annotations system George Moschovitis
    and I developed.

  * units.rb - An extensive SI Units system by Peter Vanbreokhoven.

  * class_inherit - THE way to have modules include class methods when
    inherited. This takes the next step beyond ClassMethods.

  * inheritor.rb - A neat and useful way to inherit data through the
    class heirarchy.

For the rest please see the Website, CHANGELOG and the API Docs.

*** Extra special thanks to Peter and George! ***

Thanks,

  trans.

first, let me say I find your work on facets/carats/nano/mega useful and
I thank you for this, but may I suggest a little more thinking is put on
radical changes like requiring logic and names?

AFAIR in most new releases there was a major change (naming scheme for
methods, require logic, module names etc).

  String.use Facets, :capitalized?

Notice there is no mention of any location in the file system. Consider
also the punctiuation mark being used and the fact that this can search
the class hierarcy for the method. This all adds up to a more robust,
more reliable system.

So yes, its a change and a transition. A different way of doing things.
But there is a great deal of benefit to gain from it. I'm trying to
make the transistion as gentle as possible.

But if your just starting to use Facets, you have much less to worry
about --there will be one more significant transition with the next
release which will add built in versioning. But even then that won't be
as significant a change as this realease. And from there it's all
downhill, only getting more and more stable as time goes on.

Time.use :facets, :stamp
or
Time.use_facet : stamp

I also prefer the current form:

require 'facets/time/stamp'

regards,
George.

  class Module

    def package( name, &block )
      @__package__ ||= {}
      return @__package__ unless block_given?
      @__package__[name.to_sym] = block
    end

    def provide_features( base, *selection )
      selection.each do |s|
        base.class_eval( &@__package__[s.to_sym] )
      end
    end

    def use( package, *selection )
      package.provide_features( self, *selection )
    end

  end

  Time.use :Facets, :stamp

if that's helpful.