X-Git-Url: https://git.dogcows.com/gitweb?p=chaz%2Fp5-DBIx-Class-ResultSet-RecursiveUpdate;a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FResultSet%2FRecursiveUpdate.pm;h=2f50ee10202c44127c84530d44264d8d3555e3a3;hp=1438959cd5c237c87addab57bea33d51b43887c5;hb=edca0430a3c442627c6c771a774a0e3fc34dee99;hpb=eb13d753a7ffc84f4c63c32a07df3ec38ebaca7c

diff --git a/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm b/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm
index 1438959..2f50ee1 100644
--- a/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm
+++ b/lib/DBIx/Class/ResultSet/RecursiveUpdate.pm
@@ -77,29 +77,60 @@ sub recursive_update {
     #    warn 'columns: ' . Dumper( \%columns_by_accessor );
     for my $name ( keys %$updates ) {
         my $source = $self->result_source;
-        if ( $columns_by_accessor{$name}
+
+        # columns
+        if ( exists $columns_by_accessor{$name}
             && !( $source->has_relationship($name)
                 && ref( $updates->{$name} ) ) )
         {
+
+            #warn "$name is a column";
             $columns{$name} = $updates->{$name};
             next;
         }
-        if ( !( $source->has_relationship($name) ) ) {
+
+        # relationships
+        if ( $source->has_relationship($name) ) {
+            my $info = $source->relationship_info($name);
+            if (_master_relation_cond(
+                    $source, $info->{cond},
+                    _get_pk_for_related( $self, $name )
+                )
+                )
+            {
+
+                #warn "$name is a pre-update rel";
+                $pre_updates{$name} = $updates->{$name};
+                next;
+            }
+            else {
+
+                #warn "$name is a post-update rel";
+                $post_updates{$name} = $updates->{$name};
+                next;
+            }
+        }
+
+        # many-to-many helper accessors
+        if ( is_m2m( $self, $name ) ) {
+
+            #warn "$name is a many-to-many helper accessor";
             $other_methods{$name} = $updates->{$name};
             next;
         }
-        my $info = $source->relationship_info($name);
-        if (_master_relation_cond(
-                $source, $info->{cond},
-                _get_pk_for_related( $self, $name )
-            )
-            )
-        {
-            $pre_updates{$name} = $updates->{$name};
-        }
-        else {
-            $post_updates{$name} = $updates->{$name};
+
+        # accessors
+        if ( $object->can($name) && not $source->has_relationship($name) ) {
+
+            #warn "$name is an accessor";
+            $other_methods{$name} = $updates->{$name};
+            next;
         }
+
+        # unknown
+        $self->throw_exception(
+            "No such column, relationship, many-to-many helper accessor or generic accessor '$name'"
+        );
     }
 
     # warn 'other: ' . Dumper( \%other_methods ); use Data::Dumper;
@@ -110,11 +141,10 @@ sub recursive_update {
         $object->$name( $columns{$name} );
     }
     for my $name ( keys %other_methods ) {
-        $object->$name( $updates->{$name} ) if $object->can($name);
+        $object->$name( $updates->{$name} );
     }
     for my $name ( keys %pre_updates ) {
-        my $info = $object->result_source->relationship_info($name);
-        _update_relation( $self, $name, $updates, $object, $info,
+        _update_relation( $self, $name, $updates->{$name}, $object,
             $if_not_submitted );
     }
 
@@ -161,8 +191,7 @@ sub recursive_update {
         }
     }
     for my $name ( keys %post_updates ) {
-        my $info = $object->result_source->relationship_info($name);
-        _update_relation( $self, $name, $updates, $object, $info,
+        _update_relation( $self, $name, $updates->{$name}, $object,
             $if_not_submitted );
     }
     return $object;
@@ -181,9 +210,20 @@ sub _get_columns_by_accessor {
     return %columns;
 }
 
+# Arguments: $name, $updates, $object, $if_not_submitted
+
 sub _update_relation {
-    my ( $self, $name, $updates, $object, $info, $if_not_submitted ) = @_;
-    my $related_result =
+    my ( $self, $name, $updates, $object, $if_not_submitted ) = @_;
+
+    # this should never happen because we're checking the paramters passed to
+    # recursive_update, but just to be sure...
+    $object->throw_exception("No such relationship '$name' on ")
+        unless $object->has_relationship($name);
+
+    my $info = $object->result_source->relationship_info($name);
+
+    # get a related resultset without a condition
+    my $related_resultset =
         $self->related_resultset($name)->result_source->resultset;
     my $resolved;
     if ( $self->result_source->can('_resolve_condition') ) {
@@ -191,28 +231,36 @@ sub _update_relation {
             $self->result_source->_resolve_condition( $info->{cond}, $name,
             $object );
     }
-    else {
-        $resolved =
-            $self->result_source->resolve_condition( $info->{cond}, $name,
-            $object );
-    }
 
-    # warn 'resolved: ' . Dumper( $resolved ); use Data::Dumper;
+    # warn "$name resolved: " . Dumper( $resolved ); use Data::Dumper;
     $resolved = {}
         if defined $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION
             && $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION
             == $resolved;
-    if ( ref $updates->{$name} eq 'ARRAY' ) {
+
+    my $rel_col_cnt = scalar keys %{ $info->{cond} };
+    use Data::Dumper;
+    warn "RELINFO for $name: " . Dumper($info);
+    warn "REL_COL_CNT: $rel_col_cnt";
+
+    #warn "REV RELINFO for $name: " . Dumper($revrelinfo);
+
+    # the only valid datatype for a has_many rels is an arrayref
+    if ( $info->{attrs}{accessor} eq 'multi') {
+        $self->throw_exception( "data for has_many relationship '$name' must be an arrayref")
+            unless ref $updates eq 'ARRAY';
+
         my @updated_ids;
-        for my $sub_updates ( @{ $updates->{$name} } ) {
+        for my $sub_updates ( @{$updates} ) {
+            warn "updating $name";
             my $sub_object = recursive_update(
-                resultset => $related_result,
+                resultset => $related_resultset,
                 updates   => $sub_updates,
                 resolved  => $resolved
             );
             push @updated_ids, $sub_object->id;
         }
-        my @related_pks = $related_result->result_source->primary_columns;
+        my @related_pks = $related_resultset->result_source->primary_columns;
         if ( defined $if_not_submitted && $if_not_submitted eq 'delete' ) {
 
             # only handles related result classes with single primary keys
@@ -235,33 +283,34 @@ sub _update_relation {
             }
         }
     }
-    else {
-        my $sub_updates = $updates->{$name};
+    elsif ($info->{attrs}{accessor} eq 'single'
+        || $info->{attrs}{accessor} eq 'filter' )
+    {
         my $sub_object;
-        if ( ref $sub_updates ) {
+        if ( ref $updates ) {
 
             # for might_have relationship
             if ( $info->{attrs}{accessor} eq 'single'
                 && defined $object->$name )
             {
                 $sub_object = recursive_update(
-                    resultset => $related_result,
-                    updates   => $sub_updates,
+                    resultset => $related_resultset,
+                    updates   => $updates,
                     object    => $object->$name
                 );
             }
             else {
                 $sub_object = recursive_update(
-                    resultset => $related_result,
-                    updates   => $sub_updates,
+                    resultset => $related_resultset,
+                    updates   => $updates,
                     resolved  => $resolved
                 );
             }
         }
-        elsif ( !ref $sub_updates ) {
-            $sub_object = $related_result->find($sub_updates)
+        else {
+            $sub_object = $related_resultset->find($updates)
                 unless (
-                !$sub_updates
+                !$updates
                 && ( exists $info->{attrs}{join_type}
                     && $info->{attrs}{join_type} eq 'LEFT' )
                 );
@@ -269,11 +318,14 @@ sub _update_relation {
         $object->set_from_related( $name, $sub_object )
             unless (
                !$sub_object
-            && !$sub_updates
+            && !$updates
             && ( exists $info->{attrs}{join_type}
                 && $info->{attrs}{join_type} eq 'LEFT' )
             );
     }
+    else {
+        $self->throw_exception( "recursive_update doesn't now how to handle relationship '$name' with accessor " . $info->{attrs}{accessor});
+    }
 }
 
 sub is_m2m {
@@ -578,15 +630,16 @@ Clearing the relationship:
 =head2 Treatment of many-to-many pseudo relations
 
 The function gets the information about m2m relations from DBIx::Class::IntrospectableM2M.
-If it is not loaded in the ResultSource classes - then the code relies on the fact that:
+If it isn't loaded in the ResultSource classes the code relies on the fact that:
+
     if($object->can($name) and
              !$object->result_source->has_relationship($name) and
              $object->can( 'set_' . $name )
          )
 
-then $name must be a many to many pseudo relation.  And that in a
-similarly ugly was I find out what is the ResultSource of objects from
-that many to many pseudo relation.
+Then $name must be a many to many pseudo relation.
+And that in a similarly ugly was I find out what is the ResultSource of
+objects from that many to many pseudo relation.
 
 
 =head1 INTERFACE