[Gnue-dev] Restructuring of GNUe Common directory

[Jason Cater]

Good evening, all.

As anyone accessing CVS will notice, we have recently reorganized the
structure of several GNUe-Common elements. The main gnue/common/src
directory was getting cluttered with many, many often unrelated files.
We've tried to group them into functionality as follows:

apps/              * Classes specific to a client or server app instance
cursing/           * A UI abstraction library for a curses environment.
datasources/       * Anything database-related
definitions/       * Document definition framework (GFDs, GRDs, etc)
events/            * An event framework
external/          * License-compatable non-GNUe code that we 
formatting/        * Support for formatting strings, numbers, dates, etc.
logic/             * Development "logic" classes (aka, scripting/triggers)
rpc/               * The RPC abstraction library
utils/             * Miscellaneous "handy" utilities

Of course, as with any attempt to organize code into such neat little
categories, there is bound to be overlap. Oh, well... it's better than
what we had :)

-- Jason 

Detailed structure 
------------------

apps/                 * Classes specific to a client or server app
instance
  GBaseApp.py         * All apps inherit this. Provides command line
attribute
                        support, automatic help generation, etc. 
  GClientApp.py       * A client app - contains routines for connecting to

                        GServerApp instances, etc. 
  GConfig.py          * Config-file support
  GDebug.py           * Classes for debugging output to screen or file, 
                        with output filtered by a "level" indicator. 
  GLogger.py          * Classes for logfile generation
  GServerApp.py       * A server application. Contains hooks for RPC 
                        exposure, daemonization, etc.
  RuntimeSettings.py  * Temporary run-time config file support (i.e., 
                        last window positions, etc.)

                        
cursing/              * A UI abstraction library for a curses environment.
                        May become a standalone toolkit some day.

                        
datasources/          * Data connections
  GConditions.py      * Support for datasource conditionals
  GConnections.py     * Connection/Database Manager
  GDataObjects.py     * Base for the drivers. Defines ResultSets
                        and RecordSets.
  GDataSource.py      * Support for the basic datasource, which is 
                        really a vendor-neutral wrapper for a 
                        vendor-specific GDataObject
  GLoginHandler.py    * Base class for login handlers. Meant to be 
                        subclassed by the client program.
    
                        
  drivers/            * Base directory for datasource drivers
    postgresql/       * Base directory for any pgsql-related drivers
      Base/           * Code common to all the pgsql data drivers
      Schema/         * Schema tools for pgsql              
        Discovery/    * Code to extract schema information from a
                        database.  Primarily used by Designer. 
        Creation/     * Code to generate schema objects in a database.
                        These should be able to generate DDL that can
                        be written to a script file as well as written
                        directly to the database. 
      Extensions/     * PG extensions to the basic GDataObject spec. 
                        (For example, code to run raw SQL in triggers, 
                        get the database time, get a sequence value, etc.)
      popy/           * The "popy" driver
      psycopg/        * The "psycopg" driver
      pygresql/       * The "pygresql" driver
      pypgsql/        * The "pypgsql" driver
    ... (other db drivers)
  
  schema/             * Generate schema definitions. Uses 
                        drivers/*/Schema/Creation
    parser/           * The Parser classes to load/design schema
definitions
    scripter/         * Utility to actually write out schema definitions

    
definitions/          * Document definitions (GFDs, GRDs, etc)
  GObjects.py         * The basic document node
  GParser.py          * Load from an XML format into GObject format
  GParserHelpers.py   * Support classes for GParser
  GRootObj.py         * Support classes for GObjects
  drivers/            * This is still in planning and doesn't yet exist, 
                        but will contain drivers for loading/saving 
                        definition files. 
    xml/              * All the "To/From" XML code that's currently in 
                        GObjects and GParser will be moved here. 
    datasources/      * Code to store/retrieve definitions from a
datasource
                        (i.e., stored in a database)
  
                        
events/               * An event framework 
  Event.py            * An actual event
  EventAware.py       * An class that can receive events
  EventController.py  * A class that can manage events

  
external/             * License-compatable non-GNUe code that we 
                        put in our tree for convenience. 
  shellwords.py       * Parse a string into words like a POSIX shell does

  
formatting/           * Support for formatting strings, numbers, dates,
etc.
  BaseMask.py         * Base for the mask system. Not used directly by an
app.
  DateMask.py         * A format mask system (input and output) for dates
  FormatExceptions.py * Exceptions raised by the *Mask.py classes
  GDataFormatter.py   * A very general formatting system. In the future,
it 
                        will directly use the *Mask system, but at the
moment
                        hard-codes several common formats for use in
Reports.
  GTypecast.py        * Typecasting system used by GParser
  NumberMask.py       * A format mask system (input and output) for dates
  TextMask.py         * A format mask system (input and output) for dates

  
gear/                 * The GNUe Archive system... store definitions in a 
                        single compressed archive file. ** This will be
moved
                        to "definitions/drivers" some time soon as a
storage 
                        adapter.

                        
logic/                * Development "logic" classes
  GFormula.py         * Formula support. Formulas appear almost as fields
                        to the application. They are not passed values,
but
                        can take existing fields' values and generate it's
                        own value. Formulas cannot alter the data they
pull 
                        from. 
  GTrigger.py         * Trigger support. Triggers are code that can be
bound
                        to certain application events. They cannot be
passed
                        values or return values, though they can alter the
                        values of data. 
  GTriggerCore.py     * Common core code for trigger support
  NamespaceCore.py    * Core code for namespace generation
  GProcedure.py       * Procedure support. These are different from
Formulas
                        and triggers in that Procedures can be passed
values
                        and can return values. 
  
rpc/                  * The RPC abstraction library
  GComm.py            * Core RPC utility.  Creates the necessary adapters
  drivers/            * Contains all the RPC drivers
    Base/             * Common class definitions for all RPC drivers
    xmlrpc/           * Driver files for XML-RPC layer
    ... (other)


utils/                * Miscellaneous "handy" utilities
  FileUtils.py        * File manipulation tools
  GDateTime.py        * Very basic datetime class
  GMimeTypes.py       * List of common mime types
  TextUtils.py        * Text formatting utilities