File Coverage

blib/lib/Jifty/DBI/SchemaGenerator.pm

Criterion	Covered	Total	%
statement	82	88	93.1
branch	26	28	92.8
condition	20	24	83.3
subroutine	14	15	93.3
pod	5	5	100.0
total	147	160	91.8

use strict;
use warnings;

package Jifty::DBI::SchemaGenerator;

use base qw(Class::Accessor::Fast);
use DBIx::DBSchema;
use DBIx::DBSchema::Column;
use DBIx::DBSchema::Table;
use Class::ReturnValue;
use version;

our $VERSION = '0.01';

# Public accessors
__PACKAGE__->mk_accessors(qw(handle));

# Internal accessors: do not use from outside class
__PACKAGE__->mk_accessors(qw(_db_schema));

=head1 NAME

Jifty::DBI::SchemaGenerator - Generate a table schema from Jifty::DBI records

=head1 DESCRIPTION

This module turns a Jifty::Record object into an SQL schema for your chosen
database. At the moment, your choices are MySQL, SQLite, or PostgreSQL.
Oracle might also work right, though it's untested.

=head1 SYNOPSIS

=head2 The Short Answer

See below for where we get the $handle and $model variables.

  use Jifty::DBI::SchemaGenerator;
  ...
  my $s_gen = Jifty::DBI::SchemaGenerator->new( $handle );
  $s_gen->add_model($model);

  my @statements = $s_gen->create_table_sql_statements;
  print join("\n", @statements, '');
  ...

=head2 The Long Version

See L for details about the first two parts.

=over

=item MyModel

  package MyModel;
  # lib/MyModel.pm

  use warnings;
  use strict;

  use base qw(Jifty::DBI::Record);
  # your custom code goes here.
  1;

=item MyModel::Schema

  package MyModel::Schema;
  # lib/MyModel/Schema.pm

  use warnings;
  use strict;

  use Jifty::DBI::Schema;

  column foo => type is 'text';
  column bar => type is 'text';

  1;

=item myscript.pl

  #!/usr/bin/env perl
  # myscript.pl

  use strict;
  use warnings;

  use Jifty::DBI::SchemaGenerator;

  use Jifty::DBI::Handle;
  use MyModel;
  use MyModel::Schema;

  my $handle = Jifty::DBI::Handle->new();
  $handle->connect(
    driver   => 'SQLite',
    database => 'testdb',
  );

  my $model = MyModel->new($handle);
  my $s_gen = Jifty::DBI::SchemaGenerator->new( $handle );
  $s_gen->add_model($model);

  # here's the basic point of this module:
  my @statements = $s_gen->create_table_sql_statements;
  print join("\n", @statements, '');

  # this part is directly from Jifty::Script::Schema::create_all_tables()
  $handle->begin_transaction;
  for my $statement (@statements) {
    my $ret = $handle->simple_query($statement);
    $ret or die "error creating a table: " . $ret->error_message;
  }
  $handle->commit;

=back

=head1 CONFIGURATION AND ENVIRONMENT

Requires no configuration files or environment variables.


=head1 DEPENDENCIES

Class::Accessor::Fast

DBIx::DBSchema

Class::ReturnValue

=head1 METHODS

=head2 new HANDLE

Creates a new C object.  The single
required argument is a C.

=cut

sub new {
    my $class  = shift;
    my $handle = shift;
    my $self   = $class->SUPER::new();

    $self->handle($handle);

    my $schema = DBIx::DBSchema->new();
    $self->_db_schema($schema);

    return $self;
}

=head2 add_model MODEL

Adds a new model class to the SchemaGenerator.  Model should be an
object which is an instance of C or a subclass
thereof.  It may also be a string which is the name of such a
class/subclass; in the latter case, C will instantiate an
object of the class.

The model must define the instance methods C and C. 




161




 





 





 





 





 





 



   




162




 





 





 





 





 





 



 Returns true if the model was added successfully; returns a false 




163




 





 





 





 





 





 



 C error otherwise. 




164




 





 





 





 





 





 



   




165




 





 





 





 





 





 



 =cut 




166




 





 





 





 





 





 



   




167




 





 





 





 





 





 



 sub add_model { 




168




14





 





 




  
14
  



  
1
  




2113



     my $self  = shift; 




169




14





 





 





 





 





11



     my $model = shift; 




170




 





 





 





 





 





 



   




171




 





 





 





 





 





 



     # $model could either be a (presumably unfilled) object of a subclass of 




172




 





 





 





 





 





 



     # Jifty::DBI::Record, or it could be the name of such a subclass. 




173




 





 





 





 





 





 



   




174




14




  
100
  



  
 66
  




 





 





46



     unless ( ref $model and UNIVERSAL::isa( $model, 'Jifty::DBI::Record' ) ) { 




175




12





 





 





 





 





7



         my $new_model; 




176




12





 





 





 





 





9



         eval { $new_model = $model->new; }; 




 




12





 





 





 





 





45



   




177




 





 





 





 





 





 



   




178




12




  
100
  




 





 





 





15



         if ($@) { 




179




1





 





 





 





 





5



             return $self->_error("Error making new object from $model: $@"); 




180




 





 





 





 





 





 



         } 




181




 





 





 





 





 





 



   




182




11




  
 50
  




 





 





 





28



         unless ( UNIVERSAL::isa( $new_model, 'Jifty::DBI::Record' ) ) { 




183




0





 





 





 





 





0



             return $self->_error( 




184




 





 





 





 





 





 



                 "Didn't get a Jifty::DBI::Record from $model, got $new_model" 




185




 





 





 





 





 





 



             ); 




186




 





 





 





 





 





 



         } 




187




11





 





 





 





 





9



         $model = $new_model; 




188




 





 





 





 





 





 



     } 




189




 





 





 





 





 





 



   




190




13





 





 





 





 





19



     my $table_obj = $self->_db_schema_table_from_model($model); 




191




 





 





 





 





 





 



   




192




13





 





 





 





 





23



     $self->_db_schema->addtable($table_obj); 




193




 





 





 





 





 





 



   




194




13





 





 





 





 





138



     return 1; 




195




 





 





 





 





 





 



 } 




196




 





 





 





 





 





 



   




197




 





 





 





 





 





 



 =head2 column_definition_sql TABLENAME COLUMNNAME 




198




 





 





 





 





 





 



   




199




 





 





 





 





 





 



 Given a table name and a column name, returns the SQL fragment  




200




 





 





 





 





 





 



 describing that column for the current database. 




201




 





 





 





 





 





 



   




202




 





 





 





 





 





 



 =cut 




203




 





 





 





 





 





 



   




204




 





 





 





 





 





 



 sub column_definition_sql { 




205




0





 





 




  
0
  



  
1
  




0



     my $self = shift; 




206




0





 





 





 





 





0



     my $table = shift; 




207




0





 





 





 





 





0



     my $col = shift; 




208




0





 





 





 





 





0



     my $table_obj = $self->_db_schema->table($table); 




209




0





 





 





 





 





0



     return $table_obj->column( $col )->line( $self->handle->dbh ) 




210




 





 





 





 





 





 



 } 




211




 





 





 





 





 





 



   




212




 





 





 





 





 





 



 =head2 create_table_sql_statements 




213




 





 





 





 





 





 



   




214




 





 





 





 





 





 



 Returns a list of SQL statements (as strings) to create tables for all of 




215




 





 





 





 





 





 



 the models added to the SchemaGenerator. 




216




 





 





 





 





 





 



   




217




 





 





 





 





 





 



 =cut 




218




 





 





 





 





 





 



   




219




 





 





 





 





 





 



 sub create_table_sql_statements { 




220




17





 





 




  
17
  



  
1
  




508



     my $self = shift; 




221




 





 





 





 





 





 



   




222




22





 





 





 





 





4993



     return  map { $self->_db_schema->table($_)->sql_create_table($self->handle->dbh) } 




 




10





 





 





 





 





39



   




223




17





 





 





 





 





34



            sort { $a cmp $b } 




224




 





 





 





 





 





 



                 $self->_db_schema->tables; 




225




 





 





 





 





 





 



 } 




226




 





 





 





 





 





 



   




227




 





 





 





 





 





 



 =head2 create_table_sql_text 




228




 





 





 





 





 





 



   




229




 





 





 





 





 





 



 Returns a string containing a sequence of SQL statements to create tables for all of 




230




 





 





 





 





 





 



 the models added to the SchemaGenerator. 




231




 





 





 





 





 





 



   




232




 





 





 





 





 





 



 This is just a trivial wrapper around L. 




233




 





 





 





 





 





 



   




234




 





 





 





 





 





 



 =cut 




235




 





 





 





 





 





 



   




236




 





 





 





 





 





 



 sub create_table_sql_text { 




237




16





 





 




  
16
  



  
1
  




6883



     my $self = shift; 




238




 





 





 





 





 





 



   




239




16





 





 





 





 





33



     return join "\n", map {"$_ ;\n"} $self->create_table_sql_statements; 




 




22





 





 





 





 





13464



   




240




 





 





 





 





 





 



 } 




241




 





 





 





 





 





 



   




242




 





 





 





 





 





 



 =head2 PRIVATE _db_schema_table_from_model MODEL 




243




 





 





 





 





 





 



   




244




 





 





 





 





 





 



 Takes an object of a subclass of Jifty::DBI::Record; returns a new 




245




 





 





 





 





 





 



 C object corresponding to the model. 




246




 





 





 





 





 





 



   




247




 





 





 





 





 





 



 =cut 




248




 





 





 





 





 





 



   




249




 





 





 





 





 





 



 sub _db_schema_table_from_model { 




250




13





 





 




  
13
  




 





10



     my $self  = shift; 




251




13





 





 





 





 





11



     my $model = shift; 




252




 





 





 





 





 





 



   




253




13





 





 





 





 





33



     my $table_name = $model->table; 




254




13





 





 





 





 





73



     my @columns    = $model->columns; 




255




 





 





 





 





 





 



   




256




13





 





 





 





 





163



     my @cols; 




257




 





 





 





 





 





 



     my @indexes; 




258




 





 





 





 





 





 



   




259




13





 





 





 





 





15



     for my $column (@columns) { 




260




 





 





 





 





 





 



   




261




 





 





 





 





 





 



         # Skip "Virtual" columns - (foreign keys to collections) 




262




57




  
100
  




 





 





 





179



         next if $column->virtual; 




263




 





 





 





 





 





 



   




264




 





 





 





 





 





 



         # Skip computed columns 




265




51




  
100
  




 





 





 





163



         next if $column->computed; 




266




 





 





 





 





 





 



   




267




 





 





 





 





 





 



         # If schema_version is defined, make sure columns are for that version 




268




50




  
100
  



  
100
  




 





 





229



         if ($model->can('schema_version') and defined $model->schema_version) { 




269




 





 





 





 





 





 



   




270




 





 





 





 





 





 



             # Skip it if the app version is earlier than the column version 




271




37




  
100
  



  
100
  




 





 





186



             next if defined $column->since  




272




 





 





 





 





 





 



                 and $model->schema_version <  version->new($column->since); 




273




 





 





 





 





 





 



   




274




 





 





 





 





 





 



             # Skip it if the app version is the same as or later than the  




275




 





 





 





 





 





 



             # column version 




276




36




  
100
  



  
100
  




 





 





219



             next if defined $column->till 




277




 





 





 





 





 





 



                 and $model->schema_version >= version->new($column->till); 




278




 





 





 





 





 





 



   




279




 





 





 





 





 





 



         } 




280




 





 





 





 





 





 



   




281




 





 





 





 





 





 



         # Otherwise, assume the latest version and eliminate till columns 




282




47




  
100
  



  
100
  




 





 





261



         next if (!$model->can('schema_version') or !defined $model->schema_version) 




 




 





 




  
100
  




 





 





 



   




283




 





 





 





 





 





 



             and defined $column->till; 




284




 





 





 





 





 





 



   




285




 





 





 





 





 





 



         # Encode default values 




286




45





 





 





 





 





238



         my $default = $column->default; 




287




 





 





 





 





 





 



   




288




 





 





 





 





 





 



         # Scalar::Defer-powered defaults do not get a default in the database 




289




45




  
100
  



  
 66
  




 





 





182



         if (ref($default) ne '0' && defined $default) { 




290




6





 





 





 





 





10



             $model->_handle($self->handle); 




291




6





 





 





 





 





17



             $model->_apply_input_filters( 




292




 





 





 





 





 





 



                 column    => $column, 




293




 





 





 





 





 





 



                 value_ref => \$default, 




294




 





 





 





 





 





 



             ); 




295




6




  
 50
  



  
 33
  




 





 





22



             $default = \"''" if defined $default and not length $default; 




296




6





 





 





 





 





11



             $model->_handle(undef); 




297




 





 





 





 





 





 



         } else { 




298




39





 





 





 





 





38



             $default = ''; 




299




 





 





 





 





 





 



         } 




300




 





 





 





 





 





 



   




301




45




  
100
  




 





 





 





62



         push @cols, 




302




 





 





 





 





 





 



             DBIx::DBSchema::Column->new( 




303




 





 





 





 





 





 



             {   name     => $column->name, 




304




 





 





 





 





 





 



                 type     => $column->type, 




305




 





 





 





 





 





 



                 null     => $column->mandatory ? 0 : 1, 




306




 





 





 





 





 





 



                 default  => $default, 




307




 





 





 





 





 





 



             } 




308




 





 





 





 





 





 



             ); 




309




 





 





 





 





 





 



   




310




45




  
100
  




 





 





 





620



         if ($column->indexed) { 




311




1





 





 





 





 





4



             push @indexes,[$column->name]; 




312




 





 





 





 





 





 



         } 




313




 





 





 





 





 





 



     } 




314




 





 





 





 





 





 



   




315




13





 





 





 





 





96



     my $index_count = 1; 




316




1





 





 





 





 





7



     my $table = DBIx::DBSchema::Table->new( 




317




 





 





 





 





 





 



         {   name        => $table_name, 




318




 





 





 





 





 





 



             primary_key => "id", 




319




 





 





 





 





 





 



             columns     => \@cols, 




320




13




  
100
  




 





 





 





55



             (@indexes) ? (indices => [map {DBIx::DBSchema::Index->new(name => $table_name.$index_count++, columns => $_) } @indexes]) : () 




321




 





 





 





 





 





 



         } 




322




 





 





 





 





 





 



     ); 




323




 





 





 





 





 





 



   




324




13





 





 





 





 





622



     return $table; 




325




 





 





 





 





 





 



 } 




326




 





 





 





 





 





 



   




327




 





 





 





 





 





 



 =head2 PRIVATE _error STRING 




328




 





 





 





 





 





 



   




329




 





 





 





 





 





 



 Takes in a string and returns it as a Class::ReturnValue error object. 




330




 





 





 





 





 





 



   




331




 





 





 





 





 





 



 =cut 




332




 





 





 





 





 





 



   




333




 





 





 





 





 





 



 sub _error { 




334




1





 





 




  
1
  




 





1



     my $self    = shift; 




335




1





 





 





 





 





1



     my $message = shift; 




336




 





 





 





 





 





 



   




337




1





 





 





 





 





6



     my $ret = Class::ReturnValue->new; 




338




1





 





 





 





 





5



     $ret->as_error( errno => 1, message => $message ); 




339




1





 





 





 





 





498



     return $ret->return_value; 




340




 





 





 





 





 





 



 } 




341




 





 





 





 





 





 



   




342




 





 





 





 





 





 



 1;    # Magic true value required at end of module 




343




 





 





 





 





 





 



   




344




 





 





 





 





 





 



 =head1 INCOMPATIBILITIES 




345




 





 





 





 





 





 



   




346




 





 





 





 





 





 



 None reported. 




347




 





 





 





 





 





 



   




348




 





 





 





 





 





 



 =head1 BUGS AND LIMITATIONS 




349




 





 





 





 





 





 



   




350




 





 





 





 





 





 



 No bugs have been reported. 




351




 





 





 





 





 





 



   




352




 





 





 





 





 





 



 Please report any bugs or feature requests to 




353




 





 





 





 





 





 



 CRT [e-mail]>, or through the web interface at 




354




 





 





 





 





 





 



 L. 




355




 





 





 





 





 





 



   




356




 





 





 





 





 





 



 =head1 AUTHOR 




357




 





 





 





 





 





 



   




358




 





 





 





 





 





 



 David Glasser  C<< [e-mail] >> 




359




 





 





 





 





 





 



   




360




 





 





 





 





 





 



 Some pod by Eric Wilhelm  




361




 





 





 





 





 





 



   




362




 





 





 





 





 





 



 =head1 LICENCE AND COPYRIGHT 




363




 





 





 





 





 





 



   




364




 





 





 





 





 





 



 Copyright (c) 2005, Best Practical Solutions, LLC.  All rights reserved. 




365




 





 





 





 





 





 



   




366




 





 





 





 





 





 



 This module is free software; you can redistribute it and/or 




367




 





 





 





 





 





 



 modify it under the same terms as Perl itself. See L. 




368




 





 





 





 





 





 



   




369




 





 





 





 





 





 



 =head1 DISCLAIMER OF WARRANTY 




370




 





 





 





 





 





 



   




371




 





 





 





 





 





 



 BECAUSE THIS SOFTWARE IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY 




372




 





 





 





 





 





 



 FOR THE SOFTWARE, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN 




373




 





 





 





 





 





 



 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES 




374




 





 





 





 





 





 



 PROVIDE THE SOFTWARE "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER 




375




 





 





 





 





 





 



 EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 




376




 





 





 





 





 





 



 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE 




377




 





 





 





 





 





 



 ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE SOFTWARE IS WITH 




378




 





 





 





 





 





 



 YOU. SHOULD THE SOFTWARE PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL 




379




 





 





 





 





 





 



 NECESSARY SERVICING, REPAIR, OR CORRECTION. 




380




 





 





 





 





 





 



   




381




 





 





 





 





 





 



 IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING 




382




 





 





 





 





 





 



 WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR 




383




 





 





 





 





 





 



 REDISTRIBUTE THE SOFTWARE AS PERMITTED BY THE ABOVE LICENCE, BE 




384




 





 





 





 





 





 



 LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL, 




385




 





 





 





 





 





 



 OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE 




386




 





 





 





 





 





 



 THE SOFTWARE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING 




387




 





 





 





 





 





 



 RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A 




388




 





 





 





 





 





 



 FAILURE OF THE SOFTWARE TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF 




389




 





 





 





 





 





 



 SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF 




390




 





 





 





 





 





 



 SUCH DAMAGES. 




391




 





 





 





 





 





 



   




392




 





 





 





 





 





 



 =cut 




393

Returns true if the model was added successfully; returns a false
C error otherwise.

=cut

sub add_model {
    my $self  = shift;
    my $model = shift;

    # $model could either be a (presumably unfilled) object of a subclass of
    # Jifty::DBI::Record, or it could be the name of such a subclass.

    unless ( ref $model and UNIVERSAL::isa( $model, 'Jifty::DBI::Record' ) ) {
        my $new_model;
        eval { $new_model = $model->new; };

        if ($@) {
            return $self->_error("Error making new object from $model: $@");
        }

        unless ( UNIVERSAL::isa( $new_model, 'Jifty::DBI::Record' ) ) {
            return $self->_error(
                "Didn't get a Jifty::DBI::Record from $model, got $new_model"
            );
        }
        $model = $new_model;
    }

    my $table_obj = $self->_db_schema_table_from_model($model);

    $self->_db_schema->addtable($table_obj);

    return 1;
}

=head2 column_definition_sql TABLENAME COLUMNNAME

Given a table name and a column name, returns the SQL fragment
describing that column for the current database.

=cut

sub column_definition_sql {
    my $self = shift;
    my $table = shift;
    my $col = shift;
    my $table_obj = $self->_db_schema->table($table);
    return $table_obj->column( $col )->line( $self->handle->dbh )
}

=head2 create_table_sql_statements

Returns a list of SQL statements (as strings) to create tables for all of
the models added to the SchemaGenerator.

=cut

sub create_table_sql_statements {
    my $self = shift;

    return  map { $self->_db_schema->table($_)->sql_create_table($self->handle->dbh) }
           sort { $a cmp $b }
                $self->_db_schema->tables;
}

=head2 create_table_sql_text

Returns a string containing a sequence of SQL statements to create tables for all of
the models added to the SchemaGenerator.

This is just a trivial wrapper around L.

=cut

sub create_table_sql_text {
    my $self = shift;

    return join "\n", map {"$_ ;\n"} $self->create_table_sql_statements;
}

=head2 PRIVATE _db_schema_table_from_model MODEL

Takes an object of a subclass of Jifty::DBI::Record; returns a new
C object corresponding to the model.

=cut

sub _db_schema_table_from_model {
    my $self  = shift;
    my $model = shift;

    my $table_name = $model->table;
    my @columns    = $model->columns;

    my @cols;
    my @indexes;

    for my $column (@columns) {

        # Skip "Virtual" columns - (foreign keys to collections)
        next if $column->virtual;

        # Skip computed columns
        next if $column->computed;

        # If schema_version is defined, make sure columns are for that version
        if ($model->can('schema_version') and defined $model->schema_version) {

            # Skip it if the app version is earlier than the column version
            next if defined $column->since
                and $model->schema_version <  version->new($column->since);

            # Skip it if the app version is the same as or later than the
            # column version
            next if defined $column->till
                and $model->schema_version >= version->new($column->till);

        }

        # Otherwise, assume the latest version and eliminate till columns
        next if (!$model->can('schema_version') or !defined $model->schema_version)
            and defined $column->till;

        # Encode default values
        my $default = $column->default;

        # Scalar::Defer-powered defaults do not get a default in the database
        if (ref($default) ne '0' && defined $default) {
            $model->_handle($self->handle);
            $model->_apply_input_filters(
                column    => $column,
                value_ref => \$default,
            );
            $default = \"''" if defined $default and not length $default;
            $model->_handle(undef);
        } else {
            $default = '';
        }

        push @cols,
            DBIx::DBSchema::Column->new(
            {   name     => $column->name,
                type     => $column->type,
                null     => $column->mandatory ? 0 : 1,
                default  => $default,
            }
            );

        if ($column->indexed) {
            push @indexes,[$column->name];
        }
    }

    my $index_count = 1;
    my $table = DBIx::DBSchema::Table->new(
        {   name        => $table_name,
            primary_key => "id",
            columns     => \@cols,
            (@indexes) ? (indices => [map {DBIx::DBSchema::Index->new(name => $table_name.$index_count++, columns => $_) } @indexes]) : ()
        }
    );

    return $table;
}

=head2 PRIVATE _error STRING

Takes in a string and returns it as a Class::ReturnValue error object.

=cut

sub _error {
    my $self    = shift;
    my $message = shift;

    my $ret = Class::ReturnValue->new;
    $ret->as_error( errno => 1, message => $message );
    return $ret->return_value;
}

1;    # Magic true value required at end of module

=head1 INCOMPATIBILITIES

None reported.

=head1 BUGS AND LIMITATIONS

No bugs have been reported.

Please report any bugs or feature requests to
CRT [e-mail]>, or through the web interface at
L.

=head1 AUTHOR

David Glasser  C<< [e-mail] >>

Some pod by Eric Wilhelm

=head1 LICENCE AND COPYRIGHT

Copyright (c) 2005, Best Practical Solutions, LLC.  All rights reserved.

This module is free software; you can redistribute it and/or
modify it under the same terms as Perl itself. See L.

=head1 DISCLAIMER OF WARRANTY

BECAUSE THIS SOFTWARE IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE SOFTWARE, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE SOFTWARE "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE SOFTWARE IS WITH
YOU. SHOULD THE SOFTWARE PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
NECESSARY SERVICING, REPAIR, OR CORRECTION.

IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE SOFTWARE AS PERMITTED BY THE ABOVE LICENCE, BE
LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL,
OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
THE SOFTWARE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE SOFTWARE TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.

=cut