Dogcows Code - chaz/p5-DBIx-Class-ResultSet-RecursiveUpdate/blob - lib/DBIx/Class/ResultSet/RecursiveUpdate.pm

   1 use strict;
   2 use warnings;
   3
   4 package DBIx::Class::ResultSet::RecursiveUpdate;
   5
   6 our $VERSION = '0.013';
   7
   8 use base qw(DBIx::Class::ResultSet);
   9
  10 sub recursive_update {
  11     my ( $self, $updates, $fixed_fields ) = @_;
  12     return
  13         DBIx::Class::ResultSet::RecursiveUpdate::Functions::recursive_update(
  14         resultset    => $self,
  15         updates      => $updates,
  16         fixed_fields => $fixed_fields
  17         );
  18 }
  19
  20 package DBIx::Class::ResultSet::RecursiveUpdate::Functions;
  21 use Carp;
  22 use Scalar::Util qw( blessed );
  23 use List::MoreUtils qw/ any /;
  24
  25 sub recursive_update {
  26     my %params = @_;
  27     my ( $self, $updates, $fixed_fields, $object, $resolved,
  28         $if_not_submitted )
  29         = @params{
  30         qw/resultset updates fixed_fields object resolved if_not_submitted/};
  31     $resolved ||= {};
  32
  33     # warn 'entering: ' . $self->result_source->from();
  34     carp 'fixed fields needs to be an array ref'
  35         if $fixed_fields && ref($fixed_fields) ne 'ARRAY';
  36     my %fixed_fields;
  37     %fixed_fields = map { $_ => 1 } @$fixed_fields if $fixed_fields;
  38     if ( blessed($updates) && $updates->isa('DBIx::Class::Row') ) {
  39         return $updates;
  40     }
  41     if ( $updates->{id} ) {
  42         $object = $self->find( $updates->{id}, { key => 'primary' } );
  43     }
  44     my @missing =
  45         grep { !exists $updates->{$_} && !exists $fixed_fields{$_} }
  46         $self->result_source->primary_columns;
  47     if ( !$object && !scalar @missing ) {
  48
  49         # warn 'finding by: ' . Dumper( $updates ); use Data::Dumper;
  50         $object = $self->find( $updates, { key => 'primary' } );
  51     }
  52     $updates = { %$updates, %$resolved };
  53     @missing =
  54         grep { !exists $resolved->{$_} } @missing;
  55     if ( !$object && !scalar @missing ) {
  56
  57        # warn 'finding by +resolved: ' . Dumper( $updates ); use Data::Dumper;
  58         $object = $self->find( $updates, { key => 'primary' } );
  59     }
  60     $object ||= $self->new( {} );
  61
  62     # warn Dumper( $updates ); use Data::Dumper;
  63     # direct column accessors
  64     my %columns;
  65
  66     # relations that that should be done before the row is inserted into the
  67     # database like belongs_to
  68     my %pre_updates;
  69
  70     # relations that that should be done after the row is inserted into the
  71     # database like has_many, might_have and has_one
  72     my %post_updates;
  73     my %other_methods;
  74     my %columns_by_accessor = _get_columns_by_accessor($self);
  75
  76     #    warn 'resolved: ' . Dumper( $resolved );
  77     #    warn 'updates: ' . Dumper( $updates ); use Data::Dumper;
  78     #    warn 'columns: ' . Dumper( \%columns_by_accessor );
  79     for my $name ( keys %$updates ) {
  80         my $source = $self->result_source;
  81
  82         # columns
  83         if ( exists $columns_by_accessor{$name}
  84             && !( $source->has_relationship($name)
  85                 && ref( $updates->{$name} ) ) )
  86         {
  87
  88             #warn "$name is a column\n";
  89             $columns{$name} = $updates->{$name};
  90             next;
  91         }
  92
  93         # relationships
  94         if ( $source->has_relationship($name) ) {
  95             if ( _master_relation_cond( $self, $name ) ) {
  96
  97                 #warn "$name is a pre-update rel\n";
  98                 $pre_updates{$name} = $updates->{$name};
  99                 next;
 100             }
 101             else {
 102
 103                 #warn "$name is a post-update rel\n";
 104                 $post_updates{$name} = $updates->{$name};
 105                 next;
 106             }
 107         }
 108
 109         # many-to-many helper accessors
 110         if ( is_m2m( $self, $name ) ) {
 111
 112             #warn "$name is a many-to-many helper accessor\n";
 113             $other_methods{$name} = $updates->{$name};
 114             next;
 115         }
 116
 117         # accessors
 118         if ( $object->can($name) && not $source->has_relationship($name) ) {
 119
 120             #warn "$name is an accessor";
 121             $other_methods{$name} = $updates->{$name};
 122             next;
 123         }
 124
 125         # unknown
 126         # TODO: don't throw a warning instead of an exception to give users
 127         #       time to adapt to the new API
 128         $self->throw_exception(
 129             "No such column, relationship, many-to-many helper accessor or generic accessor '$name'"
 130         );
 131     }
 132
 133     # warn 'other: ' . Dumper( \%other_methods ); use Data::Dumper;
 134
 135     # first update columns and other accessors
 136     # so that later related records can be found
 137     for my $name ( keys %columns ) {
 138
 139         #warn "update col $name\n";
 140         $object->$name( $columns{$name} );
 141     }
 142     for my $name ( keys %other_methods ) {
 143
 144         #warn "update other $name\n";
 145         $object->$name( $updates->{$name} );
 146     }
 147     for my $name ( keys %pre_updates ) {
 148
 149         #warn "pre_update $name\n";
 150         _update_relation( $self, $name, $pre_updates{$name}, $object,
 151             $if_not_submitted );
 152     }
 153
 154     # $self->_delete_empty_auto_increment($object);
 155     # don't allow insert to recurse to related objects
 156     # do the recursion ourselves
 157     # $object->{_rel_in_storage} = 1;
 158     #warn "CHANGED: " . $object->is_changed . " IN STOR: " .  $object->in_storage . "\n";
 159     $object->update_or_insert if $object->is_changed;
 160
 161     # updating many_to_many
 162     for my $name ( keys %$updates ) {
 163         next if exists $columns{$name};
 164         my $value = $updates->{$name};
 165
 166         if ( is_m2m( $self, $name ) ) {
 167
 168             #warn "update m2m $name\n";
 169             my ($pk) = _get_pk_for_related( $self, $name );
 170             my @rows;
 171             my $result_source = $object->$name->result_source;
 172             my @updates;
 173             if ( !defined $value ) {
 174                 next;
 175             }
 176             elsif ( ref $value ) {
 177                 @updates = @{$value};
 178             }
 179             else {
 180                 @updates = ($value);
 181             }
 182             for my $elem (@updates) {
 183                 if ( ref $elem ) {
 184                     push @rows,
 185                         recursive_update(
 186                         resultset => $result_source->resultset,
 187                         updates   => $elem
 188                         );
 189                 }
 190                 else {
 191                     push @rows,
 192                         $result_source->resultset->find( { $pk => $elem } );
 193                 }
 194             }
 195             my $set_meth = 'set_' . $name;
 196             $object->$set_meth( \@rows );
 197         }
 198     }
 199     for my $name ( keys %post_updates ) {
 200
 201         #warn "post_update $name\n";
 202         _update_relation( $self, $name, $post_updates{$name}, $object,
 203             $if_not_submitted );
 204     }
 205     return $object;
 206 }
 207
 208 # returns DBIx::Class::ResultSource::column_info as a hash indexed by column accessor || name
 209 sub _get_columns_by_accessor {
 210     my $self   = shift;
 211     my $source = $self->result_source;
 212     my %columns;
 213     for my $name ( $source->columns ) {
 214         my $info = $source->column_info($name);
 215         $info->{name} = $name;
 216         $columns{ $info->{accessor} || $name } = $info;
 217     }
 218     return %columns;
 219 }
 220
 221 # Arguments: $rs, $name, $updates, $row, $if_not_submitted
 222 sub _update_relation {
 223     my ( $self, $name, $updates, $object, $if_not_submitted ) = @_;
 224
 225     # this should never happen because we're checking the paramters passed to
 226     # recursive_update, but just to be sure...
 227     $object->throw_exception("No such relationship '$name'")
 228         unless $object->has_relationship($name);
 229
 230     #warn "_update_relation $name: OBJ: " . ref($object) . "\n";
 231
 232     my $info = $object->result_source->relationship_info($name);
 233
 234     # get a related resultset without a condition
 235     my $related_resultset =
 236         $self->related_resultset($name)->result_source->resultset;
 237     my $resolved;
 238     if ( $self->result_source->can('_resolve_condition') ) {
 239         $resolved =
 240             $self->result_source->_resolve_condition( $info->{cond}, $name,
 241             $object );
 242     }
 243     else {
 244         $self->throw_exception(
 245             "result_source must support _resolve_condition");
 246     }
 247
 248     # warn "$name resolved: " . Dumper( $resolved ); use Data::Dumper;
 249     $resolved = {}
 250         if defined $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION
 251             && $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION
 252             == $resolved;
 253
 254     my $rel_col_cnt = scalar keys %{ $info->{cond} };
 255     use Data::Dumper;
 256     warn "RELINFO for $name: " . Dumper($info);
 257     warn "REL_COL_CNT: $rel_col_cnt";
 258
 259     #warn "REV RELINFO for $name: " . Dumper($revrelinfo);
 260
 261     # the only valid datatype for a has_many rels is an arrayref
 262     if ( $info->{attrs}{accessor} eq 'multi' ) {
 263         $self->throw_exception(
 264             "data for has_many relationship '$name' must be an arrayref")
 265             unless ref $updates eq 'ARRAY';
 266
 267         my @updated_ids;
 268         for my $sub_updates ( @{$updates} ) {
 269             my $sub_object = recursive_update(
 270                 resultset => $related_resultset,
 271                 updates   => $sub_updates,
 272                 resolved  => $resolved
 273             );
 274             push @updated_ids, $sub_object->id;
 275         }
 276         my @related_pks = $related_resultset->result_source->primary_columns;
 277         if ( defined $if_not_submitted && $if_not_submitted eq 'delete' ) {
 278
 279             # only handles related result classes with single primary keys
 280             if ( 1 == scalar @related_pks ) {
 281                 $object->$name->search(
 282                     { $related_pks[0] => { -not_in => \@updated_ids } } )
 283                     ->delete;
 284             }
 285         }
 286         elsif ( defined $if_not_submitted
 287             && $if_not_submitted eq 'set_to_null' )
 288         {
 289
 290             # only handles related result classes with single primary keys
 291             if ( 1 == scalar @related_pks ) {
 292                 my @fk = keys %$resolved;
 293                 $object->$name->search(
 294                     { $related_pks[0] => { -not_in => \@updated_ids } } )
 295                     ->update( { $fk[0] => undef } );
 296             }
 297         }
 298     }
 299     elsif ($info->{attrs}{accessor} eq 'single'
 300         || $info->{attrs}{accessor} eq 'filter' )
 301     {
 302         #warn "\tupdating rel '$name': $if_not_submitted\n";
 303         my $sub_object;
 304         if ( ref $updates ) {
 305
 306             # for might_have relationship
 307             if ( $info->{attrs}{accessor} eq 'single'
 308                 && defined $object->$name )
 309             {
 310                 $sub_object = recursive_update(
 311                     resultset => $related_resultset,
 312                     updates   => $updates,
 313                     object    => $object->$name
 314                 );
 315             }
 316             else {
 317                 $sub_object = recursive_update(
 318                     resultset => $related_resultset,
 319                     updates   => $updates,
 320                     resolved  => $resolved
 321                 );
 322             }
 323         }
 324         else {
 325             $sub_object = $related_resultset->find($updates)
 326                 unless (
 327                 !$updates
 328                 && ( exists $info->{attrs}{join_type}
 329                     && $info->{attrs}{join_type} eq 'LEFT' )
 330                 );
 331         }
 332         $object->set_from_related( $name, $sub_object )
 333             unless (
 334                !$sub_object
 335             && !$updates
 336             && ( exists $info->{attrs}{join_type}
 337                 && $info->{attrs}{join_type} eq 'LEFT' )
 338             );
 339     }
 340     else {
 341         $self->throw_exception(
 342             "recursive_update doesn't now how to handle relationship '$name' with accessor "
 343                 . $info->{attrs}{accessor} );
 344     }
 345 }
 346
 347 sub is_m2m {
 348     my ( $self, $relation ) = @_;
 349     my $rclass = $self->result_class;
 350
 351     # DBIx::Class::IntrospectableM2M
 352     if ( $rclass->can('_m2m_metadata') ) {
 353         return $rclass->_m2m_metadata->{$relation};
 354     }
 355     my $object = $self->new( {} );
 356     if (    $object->can($relation)
 357         and !$self->result_source->has_relationship($relation)
 358         and $object->can( 'set_' . $relation ) )
 359     {
 360         return 1;
 361     }
 362     return;
 363 }
 364
 365 sub get_m2m_source {
 366     my ( $self, $relation ) = @_;
 367     my $rclass = $self->result_class;
 368
 369     # DBIx::Class::IntrospectableM2M
 370     if ( $rclass->can('_m2m_metadata') ) {
 371         return $self->result_source->related_source(
 372             $rclass->_m2m_metadata->{$relation}{relation} )
 373             ->related_source(
 374             $rclass->_m2m_metadata->{$relation}{foreign_relation} );
 375     }
 376     my $object = $self->new( {} );
 377     my $r = $object->$relation;
 378     return $r->result_source;
 379 }
 380
 381 sub _delete_empty_auto_increment {
 382     my ( $self, $object ) = @_;
 383     for my $col ( keys %{ $object->{_column_data} } ) {
 384         if ($object->result_source->column_info($col)->{is_auto_increment}
 385             and ( !defined $object->{_column_data}{$col}
 386                 or $object->{_column_data}{$col} eq '' )
 387             )
 388         {
 389             delete $object->{_column_data}{$col};
 390         }
 391     }
 392 }
 393
 394 sub _get_pk_for_related {
 395     my ( $self, $relation ) = @_;
 396     my $result_source;
 397     if ( $self->result_source->has_relationship($relation) ) {
 398         $result_source = $self->result_source->related_source($relation);
 399     }
 400
 401     # many to many case
 402     if ( is_m2m( $self, $relation ) ) {
 403         $result_source = get_m2m_source( $self, $relation );
 404     }
 405     return $result_source->primary_columns;
 406 }
 407
 408 # This function determines wheter a relationship should be done before or
 409 # after the row is inserted into the database
 410 # relationships before: belongs_to
 411 # relationships after: has_many, might_have and has_one
 412 # true means before, false after
 413 sub _master_relation_cond {
 414     my ( $self, $name ) = @_;
 415
 416     my $source = $self->result_source;
 417     my $info   = $source->relationship_info($name);
 418
 419     #warn "INFO: " . Dumper($info) . "\n";
 420
 421     # has_many rels are always after
 422     return 0
 423         if $info->{attrs}->{accessor} eq 'multi';
 424
 425     my @foreign_ids = _get_pk_for_related( $self, $name );
 426
 427     #warn "IDS: " . join(', ', @foreign_ids) . "\n";
 428
 429     my $cond = $info->{cond};
 430
 431     sub _inner {
 432         my ( $source, $cond, @foreign_ids ) = @_;
 433
 434         while ( my ( $f_key, $col ) = each %{$cond} ) {
 435
 436             # might_have is not master
 437             $col   =~ s/^self\.//;
 438             $f_key =~ s/^foreign\.//;
 439             if ( $source->column_info($col)->{is_auto_increment} ) {
 440                 return 0;
 441             }
 442             if ( any { $_ eq $f_key } @foreign_ids ) {
 443                 return 1;
 444             }
 445         }
 446         return 0;
 447     }
 448
 449     if ( ref $cond eq 'HASH' ) {
 450         return _inner( $source, $cond, @foreign_ids );
 451     }
 452
 453     # arrayref of hashrefs
 454     elsif ( ref $cond eq 'ARRAY' ) {
 455         for my $new_cond (@$cond) {
 456             return _inner( $source, $new_cond, @foreign_ids );
 457         }
 458     }
 459     else {
 460         $source->throw_exception(
 461             "unhandled relation condition " . ref($cond) );
 462     }
 463     return;
 464 }
 465
 466 1;    # Magic true value required at end of module
 467 __END__
 468
 469 =head1 NAME
 470
 471 DBIx::Class::ResultSet::RecursiveUpdate - like update_or_create - but recursive
 472
 473 =head1 SYNOPSIS
 474
 475 The functional interface:
 476
 477     my $new_item = DBIx::Class::ResultSet::RecursiveUpdate::Functions::recursive_update({
 478         resultset => $schema->resultset( 'Dvd' ),
 479         updates => {
 480             id => 1,
 481             owned_dvds => [
 482                 {
 483                   title => 'One Flew Over the Cuckoo's Nest'
 484                 }
 485             ]
 486         }
 487     });
 488
 489
 490 As ResultSet subclass:
 491
 492     __PACKAGE__->load_namespaces( default_resultset_class => '+DBIx::Class::ResultSet::RecursiveUpdate' );
 493
 494 in the Schema file (see t/lib/DBSchema.pm).  Or appriopriate 'use base' in the ResultSet classes.
 495
 496 Then:
 497
 498     my $user = $user_rs->recursive_update( {
 499         id => 1,
 500         owned_dvds => [
 501         {
 502           title => 'One Flew Over the Cuckoo's Nest'
 503         }
 504         ]
 505       }
 506     );
 507
 508
 509 =head1 DESCRIPTION
 510
 511 This is still experimental. I've added a functional interface so that it can be used
 512 in Form Processors and not require modification of the model.
 513
 514 You can feed the ->create method with a recursive datastructure and have the related records
 515 created.  Unfortunately you cannot do a similar thing with update_or_create - this module
 516 tries to fill that void.
 517
 518 It is a base class for ResultSets providing just one method: recursive_update
 519 which works just like update_or_create but can recursively update or create
 520 data objects composed of multiple rows. All rows need to be identified by primary keys
 521 - so you need to provide them in the update structure (unless they can be deduced from
 522 the parent row - for example when you have a belongs_to relationship).
 523 If not all colums comprising the primary key are specified - then a new row will be created,
 524 with the expectation that the missing columns will be filled by it (as in the case of auto_increment
 525 primary keys).
 526
 527
 528 If the resultset itself stores an assignement for the primary key,
 529 like in the case of:
 530
 531     my $restricted_rs = $user_rs->search( { id => 1 } );
 532
 533 then you need to inform recursive_update about additional predicate with a second argument:
 534
 535     my $user = $restricted_rs->recursive_update( {
 536         owned_dvds => [
 537         {
 538           title => 'One Flew Over the Cuckoo's Nest'
 539         }
 540         ]
 541       },
 542       [ 'id' ]
 543     );
 544
 545 This will work with a new DBIC release.
 546
 547 For a many_to_many (pseudo) relation you can supply a list of primary keys
 548 from the other table - and it will link the record at hand to those and
 549 only those records identified by them.  This is convenient for handling web
 550 forms with check boxes (or a SELECT box with multiple choice) that let you
 551 update such (pseudo) relations.
 552
 553 For a description how to set up base classes for ResultSets see load_namespaces
 554 in DBIx::Class::Schema.
 555
 556 =head1 DESIGN CHOICES
 557
 558 Columns and relationships which are excluded from the updates hashref aren't
 559 touched at all.
 560
 561 =head2 Treatment of belongs_to relations
 562
 563 In case the relationship is included but undefined in the updates hashref,
 564 all columns forming the relationship will be set to null.
 565 If not all of them are nullable, DBIx::Class will throw an error.
 566
 567 Updating the relationship:
 568
 569     my $dvd = $dvd_rs->recursive_update( {
 570         id    => 1,
 571         owner => $user->id,
 572     });
 573
 574 Clearing the relationship (only works if cols are nullable!):
 575
 576     my $dvd = $dvd_rs->recursive_update( {
 577         id    => 1,
 578         owner => undef,
 579     });
 580
 581 =head2 Treatment of might_have relationships
 582
 583 In case the relationship is included but undefined in the updates hashref,
 584 all columns forming the relationship will be set to null.
 585
 586 Updating the relationship:
 587
 588     my $user = $user_rs->recursive_update( {
 589         id => 1,
 590         address => {
 591             street => "101 Main Street",
 592             city   => "Podunk",
 593             state  => "New York",
 594         }
 595     });
 596
 597 Clearing the relationship:
 598
 599     my $user = $user_rs->recursive_update( {
 600         id => 1,
 601         address => undef,
 602     });
 603
 604 =head2 Treatment of has_many relations
 605
 606 If a relationship key is included in the data structure with a value of undef
 607 or an empty array, all existing related rows will be deleted, or their foreign
 608 key columns will be set to null.
 609
 610 The exact behaviour depends on the nullability of the foreign key columns and
 611 the value of the "if_not_submitted" parameter. The parameter defaults to
 612 undefined which neither nullifies nor deletes.
 613
 614 When the array contains elements they are updated if they exist, created when
 615 not and deleted if not included.
 616
 617 =head3 All foreign table columns are nullable
 618
 619 In this case recursive_update defaults to nullifying the foreign columns.
 620
 621 =head3 Not all foreign table columns are nullable
 622
 623 In this case recursive_update deletes the foreign rows.
 624
 625 Updating the relationship:
 626
 627     Passing ids:
 628
 629     my $dvd = $dvd_rs->recursive_update( {
 630         id   => 1,
 631         tags => [1, 2],
 632     });
 633
 634     Passing hashrefs:
 635
 636     my $dvd = $dvd_rs->recursive_update( {
 637         id   => 1,
 638         tags => [
 639             {
 640                 id   => 1,
 641                 file => 'file0'
 642             },
 643             {
 644                 id   => 2,
 645                 file => 'file1',
 646             },
 647         ],
 648     });
 649
 650     Passing objects:
 651
 652     TODO
 653
 654     You can even mix them:
 655
 656     my $dvd = $dvd_rs->recursive_update( {
 657         id   => 1,
 658         tags => [ '2', { id => '3' } ],
 659     });
 660
 661 Clearing the relationship:
 662
 663     my $dvd = $dvd_rs->recursive_update( {
 664         id   => 1,
 665         tags => undef,
 666     });
 667
 668     This is the same as passing an empty array:
 669
 670     my $dvd = $dvd_rs->recursive_update( {
 671         id   => 1,
 672         tags => [],
 673     });
 674
 675 =head2 Treatment of many-to-many pseudo relations
 676
 677 The function gets the information about m2m relations from DBIx::Class::IntrospectableM2M.
 678 If it isn't loaded in the ResultSource classes the code relies on the fact that:
 679
 680     if($object->can($name) and
 681              !$object->result_source->has_relationship($name) and
 682              $object->can( 'set_' . $name )
 683          )
 684
 685 Then $name must be a many to many pseudo relation.
 686 And that in a similarly ugly was I find out what is the ResultSource of
 687 objects from that many to many pseudo relation.
 688
 689
 690 =head1 INTERFACE
 691
 692 =head1 METHODS
 693
 694 =head2 recursive_update
 695
 696 The method that does the work here.
 697
 698 =head2 is_m2m
 699
 700 $self->is_m2m( 'name ' ) - answers the question if 'name' is a many to many
 701 (pseudo) relation on $self.
 702
 703 =head2 get_m2m_source
 704
 705 $self->get_m2m_source( 'name' ) - returns the ResultSource linked to by the many
 706 to many (pseudo) relation 'name' from $self.
 707
 708
 709 =head1 DIAGNOSTICS
 710
 711
 712 =head1 CONFIGURATION AND ENVIRONMENT
 713
 714 DBIx::Class::RecursiveUpdate requires no configuration files or environment variables.
 715
 716 =head1 DEPENDENCIES
 717
 718     DBIx::Class
 719
 720 =head1 INCOMPATIBILITIES
 721
 722 None reported.
 723
 724
 725 =head1 BUGS AND LIMITATIONS
 726
 727 No bugs have been reported.
 728
 729 Please report any bugs or feature requests to
 730 C<bug-dbix-class-recursiveput@rt.cpan.org>, or through the web interface at
 731 L<http://rt.cpan.org>.
 732
 733
 734 =head1 AUTHOR
 735
 736 Zbigniew Lukasiak  C<< <zby@cpan.org> >>
 737 Influenced by code by Pedro Melo.
 738
 739 =head1 LICENCE AND COPYRIGHT
 740
 741 Copyright (c) 2008, Zbigniew Lukasiak C<< <zby@cpan.org> >>. All rights reserved.
 742
 743 This module is free software; you can redistribute it and/or
 744 modify it under the same terms as Perl itself. See L<perlartistic>.
 745
 746
 747 =head1 DISCLAIMER OF WARRANTY
 748
 749 BECAUSE THIS SOFTWARE IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
 750 FOR THE SOFTWARE, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
 751 OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
 752 PROVIDE THE SOFTWARE "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER
 753 EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 754 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE
 755 ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE SOFTWARE IS WITH
 756 YOU. SHOULD THE SOFTWARE PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
 757 NECESSARY SERVICING, REPAIR, OR CORRECTION.
 758
 759 IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
 760 WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
 761 REDISTRIBUTE THE SOFTWARE AS PERMITTED BY THE ABOVE LICENCE, BE
 762 LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL,
 763 OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
 764 THE SOFTWARE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
 765 RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
 766 FAILURE OF THE SOFTWARE TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
 767 SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
 768 SUCH DAMAGES.