]> Dogcows Code - chaz/p5-DBIx-Class-ResultSet-RecursiveUpdate/blobdiff - lib/DBIx/Class/ResultSet/RecursiveUpdate.pm
rename $related_result -> $related_resultset
[chaz/p5-DBIx-Class-ResultSet-RecursiveUpdate] / lib / DBIx / Class / ResultSet / RecursiveUpdate.pm
index eeec84cdd240e2007b07101c2d3cd784f184ce62..04685e7a63fbad39516c80ed236291dd3bc58c21 100644 (file)
@@ -1,88 +1,99 @@
 use strict;
 use warnings;
 use strict;
 use warnings;
+
 package DBIx::Class::ResultSet::RecursiveUpdate;
 
 package DBIx::Class::ResultSet::RecursiveUpdate;
 
-our $VERSION = '0.012';
+our $VERSION = '0.013';
 
 use base qw(DBIx::Class::ResultSet);
 
 sub recursive_update {
     my ( $self, $updates, $fixed_fields ) = @_;
 
 use base qw(DBIx::Class::ResultSet);
 
 sub recursive_update {
     my ( $self, $updates, $fixed_fields ) = @_;
-    return DBIx::Class::ResultSet::RecursiveUpdate::Functions::recursive_update(
+    return
+        DBIx::Class::ResultSet::RecursiveUpdate::Functions::recursive_update(
         resultset    => $self,
         updates      => $updates,
         fixed_fields => $fixed_fields
         resultset    => $self,
         updates      => $updates,
         fixed_fields => $fixed_fields
-    );
+        );
 }
 
 package DBIx::Class::ResultSet::RecursiveUpdate::Functions;
 use Carp;
 use Scalar::Util qw( blessed );
 
 }
 
 package DBIx::Class::ResultSet::RecursiveUpdate::Functions;
 use Carp;
 use Scalar::Util qw( blessed );
 
-
 sub recursive_update {
     my %params = @_;
 sub recursive_update {
     my %params = @_;
-    my ( $self, $updates, $fixed_fields, $object, $resolved, $if_not_submitted ) = @params{ qw/resultset updates fixed_fields object resolved if_not_submitted/ }; 
+    my ( $self, $updates, $fixed_fields, $object, $resolved,
+        $if_not_submitted )
+        = @params{
+        qw/resultset updates fixed_fields object resolved if_not_submitted/};
     $resolved ||= {};
     $resolved ||= {};
+
     # warn 'entering: ' . $self->result_source->from();
     # warn 'entering: ' . $self->result_source->from();
-    carp 'fixed fields needs to be an array ref' if $fixed_fields && ref($fixed_fields) ne 'ARRAY';
+    carp 'fixed fields needs to be an array ref'
+        if $fixed_fields && ref($fixed_fields) ne 'ARRAY';
     my %fixed_fields;
     %fixed_fields = map { $_ => 1 } @$fixed_fields if $fixed_fields;
     if ( blessed($updates) && $updates->isa('DBIx::Class::Row') ) {
         return $updates;
     }
     my %fixed_fields;
     %fixed_fields = map { $_ => 1 } @$fixed_fields if $fixed_fields;
     if ( blessed($updates) && $updates->isa('DBIx::Class::Row') ) {
         return $updates;
     }
-    if ( $updates->{id} ){
+    if ( $updates->{id} ) {
         $object = $self->find( $updates->{id}, { key => 'primary' } );
     }
     my @missing =
         $object = $self->find( $updates->{id}, { key => 'primary' } );
     }
     my @missing =
-      grep { !exists $updates->{$_} && !exists $fixed_fields{$_} } $self->result_source->primary_columns;
+        grep { !exists $updates->{$_} && !exists $fixed_fields{$_} }
+        $self->result_source->primary_columns;
     if ( !$object && !scalar @missing ) {
     if ( !$object && !scalar @missing ) {
-#        warn 'finding by: ' . Dumper( $updates ); use Data::Dumper;
+
+        # warn 'finding by: ' . Dumper( $updates ); use Data::Dumper;
         $object = $self->find( $updates, { key => 'primary' } );
     }
     $updates = { %$updates, %$resolved };
     @missing =
         $object = $self->find( $updates, { key => 'primary' } );
     }
     $updates = { %$updates, %$resolved };
     @missing =
-      grep { !exists $resolved->{$_} } @missing;
+        grep { !exists $resolved->{$_} } @missing;
     if ( !$object && !scalar @missing ) {
     if ( !$object && !scalar @missing ) {
-#        warn 'finding by +resolved: ' . Dumper( $updates ); use Data::Dumper;
+
+       # warn 'finding by +resolved: ' . Dumper( $updates ); use Data::Dumper;
         $object = $self->find( $updates, { key => 'primary' } );
     }
     $object ||= $self->new( {} );
         $object = $self->find( $updates, { key => 'primary' } );
     }
     $object ||= $self->new( {} );
+
     # warn Dumper( $updates ); use Data::Dumper;
     # direct column accessors
     my %columns;
 
     # warn Dumper( $updates ); use Data::Dumper;
     # direct column accessors
     my %columns;
 
-    # relations that that should be done before the row is inserted into the database
-    # like belongs_to
+    # relations that that should be done before the row is inserted into the
+    # database like belongs_to
     my %pre_updates;
 
     my %pre_updates;
 
-    # relations that that should be done after the row is inserted into the database
-    # like has_many and might_have
+    # relations that that should be done after the row is inserted into the
+    # database like has_many, might_have and has_one
     my %post_updates;
     my %other_methods;
     my %post_updates;
     my %other_methods;
-    my %columns_by_accessor = _get_columns_by_accessor( $self );
-#    warn 'resolved: ' . Dumper( $resolved );
-#    warn 'updates: ' . Dumper( $updates ); use Data::Dumper;
-#    warn 'columns: ' . Dumper( \%columns_by_accessor );
+    my %columns_by_accessor = _get_columns_by_accessor($self);
+
+    #    warn 'resolved: ' . Dumper( $resolved );
+    #    warn 'updates: ' . Dumper( $updates ); use Data::Dumper;
+    #    warn 'columns: ' . Dumper( \%columns_by_accessor );
     for my $name ( keys %$updates ) {
         my $source = $self->result_source;
         if ( $columns_by_accessor{$name}
     for my $name ( keys %$updates ) {
         my $source = $self->result_source;
         if ( $columns_by_accessor{$name}
-            && !( $source->has_relationship($name) && ref( $updates->{$name} ) )
-          )
+            && !( $source->has_relationship($name)
+                && ref( $updates->{$name} ) ) )
         {
             $columns{$name} = $updates->{$name};
             next;
         }
         {
             $columns{$name} = $updates->{$name};
             next;
         }
-        if( !( $source->has_relationship($name) ) ){
+        if ( !( $source->has_relationship($name) ) ) {
             $other_methods{$name} = $updates->{$name};
             next;
         }
         my $info = $source->relationship_info($name);
             $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)
+        if (_master_relation_cond(
+                $source, $info->{cond},
+                _get_pk_for_related( $self, $name )
+            )
             )
             )
-          )
         {
             $pre_updates{$name} = $updates->{$name};
         }
         {
             $pre_updates{$name} = $updates->{$name};
         }
@@ -90,52 +101,59 @@ sub recursive_update {
             $post_updates{$name} = $updates->{$name};
         }
     }
             $post_updates{$name} = $updates->{$name};
         }
     }
+
     # warn 'other: ' . Dumper( \%other_methods ); use Data::Dumper;
 
     # warn 'other: ' . Dumper( \%other_methods ); use Data::Dumper;
 
-    # first update columns and other accessors - so that later related records can be found
+    # first update columns and other accessors
+    # so that later related records can be found
     for my $name ( keys %columns ) {
         $object->$name( $columns{$name} );
     }
     for my $name ( keys %columns ) {
         $object->$name( $columns{$name} );
     }
-    for my $name ( keys %other_methods) {
-        $object->$name( $updates->{$name} ) if $object->can( $name );
+    for my $name ( keys %other_methods ) {
+        $object->$name( $updates->{$name} ) if $object->can($name);
     }
     for my $name ( keys %pre_updates ) {
         my $info = $object->result_source->relationship_info($name);
     }
     for my $name ( keys %pre_updates ) {
         my $info = $object->result_source->relationship_info($name);
-        _update_relation( $self, $name, $updates, $object, $info, $if_not_submitted );
+        _update_relation( $self, $name, $updates->{$name}, $object, $info,
+            $if_not_submitted );
     }
     }
-#    $self->_delete_empty_auto_increment($object);
-# don't allow insert to recurse to related objects - we do the recursion ourselves
-#    $object->{_rel_in_storage} = 1;
-
-    $object->update_or_insert;
 
 
+    # $self->_delete_empty_auto_increment($object);
+    # don't allow insert to recurse to related objects
+    # do the recursion ourselves
+    # $object->{_rel_in_storage} = 1;
+    $object->update_or_insert if $object->is_changed;
 
     # updating many_to_many
     for my $name ( keys %$updates ) {
         next if exists $columns{$name};
         my $value = $updates->{$name};
 
 
     # updating many_to_many
     for my $name ( keys %$updates ) {
         next if exists $columns{$name};
         my $value = $updates->{$name};
 
-        if ( is_m2m( $self, $name) ) {
-            my ($pk) = _get_pk_for_related( $self, $name);
+        if ( is_m2m( $self, $name ) ) {
+            my ($pk) = _get_pk_for_related( $self, $name );
             my @rows;
             my $result_source = $object->$name->result_source;
             my @updates;
             my @rows;
             my $result_source = $object->$name->result_source;
             my @updates;
-            if( ! defined $value ){
+            if ( !defined $value ) {
                 next;
             }
                 next;
             }
-            elsif( ref $value ){
-                @updates = @{ $value };
+            elsif ( ref $value ) {
+                @updates = @{$value};
             }
             }
-            else{
-                @updates = ( $value );
+            else {
+                @updates = ($value);
             }
             }
-            for my $elem ( @updates ) {
+            for my $elem (@updates) {
                 if ( ref $elem ) {
                 if ( ref $elem ) {
-                    push @rows, recursive_update( resultset => $result_source->resultset, updates => $elem );
+                    push @rows,
+                        recursive_update(
+                        resultset => $result_source->resultset,
+                        updates   => $elem
+                        );
                 }
                 else {
                     push @rows,
                 }
                 else {
                     push @rows,
-                      $result_source->resultset->find( { $pk => $elem } );
+                        $result_source->resultset->find( { $pk => $elem } );
                 }
             }
             my $set_meth = 'set_' . $name;
                 }
             }
             my $set_meth = 'set_' . $name;
@@ -144,11 +162,13 @@ sub recursive_update {
     }
     for my $name ( keys %post_updates ) {
         my $info = $object->result_source->relationship_info($name);
     }
     for my $name ( keys %post_updates ) {
         my $info = $object->result_source->relationship_info($name);
-        _update_relation( $self, $name, $updates, $object, $info, $if_not_submitted );
+        _update_relation( $self, $name, $updates->{$name}, $object, $info,
+            $if_not_submitted );
     }
     return $object;
 }
 
     }
     return $object;
 }
 
+# returns DBIx::Class::ResultSource::column_info as a hash indexed by column accessor || name
 sub _get_columns_by_accessor {
     my $self   = shift;
     my $source = $self->result_source;
 sub _get_columns_by_accessor {
     my $self   = shift;
     my $source = $self->result_source;
@@ -161,64 +181,102 @@ sub _get_columns_by_accessor {
     return %columns;
 }
 
     return %columns;
 }
 
+# Arguments: $name, $updates, $object, $info, $if_not_submitted
+
 sub _update_relation {
     my ( $self, $name, $updates, $object, $info, $if_not_submitted ) = @_;
 sub _update_relation {
     my ( $self, $name, $updates, $object, $info, $if_not_submitted ) = @_;
-    my $related_result =
-      $self->related_resultset($name)->result_source->resultset;
+    # get a related resultset without a condition
+    my $related_resultset =
+        $self->related_resultset($name)->result_source->resultset;
     my $resolved;
     my $resolved;
-    if( $self->result_source->can( '_resolve_condition' ) ){
-        $resolved = $self->result_source->_resolve_condition( $info->{cond}, $name, $object );
+    if ( $self->result_source->can('_resolve_condition') ) {
+        $resolved =
+            $self->result_source->_resolve_condition( $info->{cond}, $name,
+            $object );
     }
     }
-    else{
-        $resolved = $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 = {}
     $resolved = {}
-      if defined $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION && $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION == $resolved;
-    if ( ref $updates->{$name} eq 'ARRAY' ) {
+        if defined $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION
+            && $DBIx::Class::ResultSource::UNRESOLVABLE_CONDITION
+            == $resolved;
+
+    # an arrayref is only valid for has_many rels
+    if ( ref $updates eq 'ARRAY' ) {
         my @updated_ids;
         my @updated_ids;
-        for my $sub_updates ( @{ $updates->{$name} } ) {
-            my $sub_object =
-              recursive_update( resultset => $related_result, updates => $sub_updates, resolved => $resolved );
+        for my $sub_updates ( @{$updates} ) {
+            my $sub_object = recursive_update(
+                resultset => $related_resultset,
+                updates   => $sub_updates,
+                resolved  => $resolved
+            );
             push @updated_ids, $sub_object->id;
         }
             push @updated_ids, $sub_object->id;
         }
-        my @related_pks = $related_result->result_source->primary_columns;
-        if( defined $if_not_submitted && $if_not_submitted eq 'delete' ){
-            if ( 1 == scalar @related_pks ){
-                $object->$name->search( { $related_pks[0] => { -not_in => \@updated_ids } } )->delete;
+        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
+            if ( 1 == scalar @related_pks ) {
+                $object->$name->search(
+                    { $related_pks[0] => { -not_in => \@updated_ids } } )
+                    ->delete;
             }
         }
             }
         }
-        elsif( defined $if_not_submitted && $if_not_submitted eq 'set_to_null' ){
-            if ( 1 == scalar @related_pks ){
+        elsif ( defined $if_not_submitted
+            && $if_not_submitted eq 'set_to_null' )
+        {
+
+            # only handles related result classes with single primary keys
+            if ( 1 == scalar @related_pks ) {
                 my @fk = keys %$resolved;
                 my @fk = keys %$resolved;
-                $object->$name->search( { $related_pks[0] => { -not_in => \@updated_ids } } )->update( { $fk[0] => undef } );
+                $object->$name->search(
+                    { $related_pks[0] => { -not_in => \@updated_ids } } )
+                    ->update( { $fk[0] => undef } );
             }
         }
     }
     else {
             }
         }
     }
     else {
-        my $sub_updates = $updates->{$name};
         my $sub_object;
         my $sub_object;
-        if( ref $sub_updates ){
+        if ( ref $updates ) {
+
             # for might_have relationship
             # for might_have relationship
-            if( $info->{attrs}{accessor} eq 'single' && defined $object->$name ){
-                $sub_object = recursive_update( 
-                    resultset => $related_result, 
-                    updates => $sub_updates, 
-                    object =>  $object->$name 
+            if ( $info->{attrs}{accessor} eq 'single'
+                && defined $object->$name )
+            {
+                $sub_object = recursive_update(
+                    resultset => $related_resultset,
+                    updates   => $updates,
+                    object    => $object->$name
                 );
             }
                 );
             }
-            else{
-                $sub_object =
-                recursive_update( resultset => $related_result, updates => $sub_updates, resolved => $resolved );
+            else {
+                $sub_object = recursive_update(
+                    resultset => $related_resultset,
+                    updates   => $updates,
+                    resolved  => $resolved
+                );
             }
         }
             }
         }
-        elsif( ! ref $sub_updates ){
-            $sub_object = $related_result->find( $sub_updates ) 
-             unless (!$sub_updates && ($info->{attrs}{join_type} eq 'LEFT'));
+        elsif ( !ref $updates ) {
+            $sub_object = $related_resultset->find($updates)
+                unless (
+                !$updates
+                && ( exists $info->{attrs}{join_type}
+                    && $info->{attrs}{join_type} eq 'LEFT' )
+                );
         }
         $object->set_from_related( $name, $sub_object )
         }
         $object->set_from_related( $name, $sub_object )
-          unless (!$sub_object && !$sub_updates && ($info->{attrs}{join_type} eq 'LEFT'));
+            unless (
+               !$sub_object
+            && !$updates
+            && ( exists $info->{attrs}{join_type}
+                && $info->{attrs}{join_type} eq 'LEFT' )
+            );
     }
 }
 
     }
 }
 
@@ -248,7 +306,7 @@ sub get_m2m_source {
     if ( $rclass->can('_m2m_metadata') ) {
         return $self->result_source->related_source(
             $rclass->_m2m_metadata->{$relation}{relation} )
     if ( $rclass->can('_m2m_metadata') ) {
         return $self->result_source->related_source(
             $rclass->_m2m_metadata->{$relation}{relation} )
-          ->related_source(
+            ->related_source(
             $rclass->_m2m_metadata->{$relation}{foreign_relation} );
     }
     my $object = $self->new( {} );
             $rclass->_m2m_metadata->{$relation}{foreign_relation} );
     }
     my $object = $self->new( {} );
@@ -259,11 +317,10 @@ sub get_m2m_source {
 sub _delete_empty_auto_increment {
     my ( $self, $object ) = @_;
     for my $col ( keys %{ $object->{_column_data} } ) {
 sub _delete_empty_auto_increment {
     my ( $self, $object ) = @_;
     for my $col ( keys %{ $object->{_column_data} } ) {
-        if (
-            $object->result_source->column_info($col)->{is_auto_increment}
+        if ($object->result_source->column_info($col)->{is_auto_increment}
             and ( !defined $object->{_column_data}{$col}
                 or $object->{_column_data}{$col} eq '' )
             and ( !defined $object->{_column_data}{$col}
                 or $object->{_column_data}{$col} eq '' )
-          )
+            )
         {
             delete $object->{_column_data}{$col};
         }
         {
             delete $object->{_column_data}{$col};
         }
@@ -278,12 +335,16 @@ sub _get_pk_for_related {
     }
 
     # many to many case
     }
 
     # many to many case
-    if ( is_m2m($self, $relation) ) {
-        $result_source = get_m2m_source($self, $relation);
+    if ( is_m2m( $self, $relation ) ) {
+        $result_source = get_m2m_source( $self, $relation );
     }
     return $result_source->primary_columns;
 }
 
     }
     return $result_source->primary_columns;
 }
 
+# This function determines wheter a relationship should be done before or
+# after the row is inserted into the database
+# relationships before: belongs_to
+# relationships after: has_many, might_have and has_one
 sub _master_relation_cond {
     my ( $source, $cond, @foreign_ids ) = @_;
     my $foreign_ids_re = join '|', @foreign_ids;
 sub _master_relation_cond {
     my ( $source, $cond, @foreign_ids ) = @_;
     my $foreign_ids_re = join '|', @foreign_ids;
@@ -303,8 +364,7 @@ sub _master_relation_cond {
     }
     elsif ( ref $cond eq 'ARRAY' ) {
         for my $new_cond (@$cond) {
     }
     elsif ( ref $cond eq 'ARRAY' ) {
         for my $new_cond (@$cond) {
-            return 1
-              if _master_relation_cond( $source, $new_cond, @foreign_ids );
+            return _master_relation_cond( $source, $new_cond, @foreign_ids );
         }
     }
     return;
         }
     }
     return;
@@ -317,12 +377,6 @@ __END__
 
 DBIx::Class::ResultSet::RecursiveUpdate - like update_or_create - but recursive
 
 
 DBIx::Class::ResultSet::RecursiveUpdate - like update_or_create - but recursive
 
-
-=head1 VERSION
-
-This document describes DBIx::Class::ResultSet::RecursiveUpdate version 0.006
-
-
 =head1 SYNOPSIS
 
 The functional interface:
 =head1 SYNOPSIS
 
 The functional interface:
@@ -360,6 +414,7 @@ Then:
 
   
 =head1 DESCRIPTION
 
   
 =head1 DESCRIPTION
+
 This is still experimental. I've added a functional interface so that it can be used 
 in Form Processors and not require modification of the model.
 
 This is still experimental. I've added a functional interface so that it can be used 
 in Form Processors and not require modification of the model.
 
@@ -407,18 +462,136 @@ in DBIx::Class::Schema.
 
 =head1 DESIGN CHOICES
 
 
 =head1 DESIGN CHOICES
 
-=head2 Treatment of many to many pseudo relations
+Columns and relationships which are excluded from the updates hashref aren't
+touched at all.
+
+=head2 Treatment of belongs_to relations
+
+In case the relationship is included but undefined in the updates hashref,
+all columns forming the relationship will be set to null.
+If not all of them are nullable, DBIx::Class will throw an error.
+
+Updating the relationship:
+
+    my $dvd = $dvd_rs->recursive_update( {
+        id    => 1,
+        owner => $user->id,
+    });
+
+Clearing the relationship (only works if cols are nullable!):
+
+    my $dvd = $dvd_rs->recursive_update( {
+        id    => 1,
+        owner => undef,
+    });
+
+=head2 Treatment of might_have relationships
+
+In case the relationship is included but undefined in the updates hashref,
+all columns forming the relationship will be set to null.
+
+Updating the relationship:
+
+    my $user = $user_rs->recursive_update( {
+        id => 1,
+        address => {
+            street => "101 Main Street",
+            city   => "Podunk",
+            state  => "New York",
+        }
+    });
+
+Clearing the relationship:
+
+    my $user = $user_rs->recursive_update( {
+        id => 1,
+        address => undef,
+    });
+
+=head2 Treatment of has_many relations
+
+If a relationship key is included in the data structure with a value of undef
+or an empty array, all existing related rows will be deleted, or their foreign
+key columns will be set to null.
+
+The exact behaviour depends on the nullability of the foreign key columns and
+the value of the "if_not_submitted" parameter. The parameter defaults to
+undefined which neither nullifies nor deletes.
+
+When the array contains elements they are updated if they exist, created when
+not and deleted if not included.
+
+=head3 All foreign table columns are nullable
+
+In this case recursive_update defaults to nullifying the foreign columns.
+
+=head3 Not all foreign table columns are nullable
+
+In this case recursive_update deletes the foreign rows.
+
+Updating the relationship:
+
+    Passing ids:
+
+    my $dvd = $dvd_rs->recursive_update( {
+        id   => 1,
+        tags => [1, 2],
+    });
+
+    Passing hashrefs:
+
+    my $dvd = $dvd_rs->recursive_update( {
+        id   => 1,
+        tags => [
+            {
+                id   => 1,
+                file => 'file0'
+            },
+            {
+                id   => 2,
+                file => 'file1',
+            },
+        ],
+    });
+
+    Passing objects:
+
+    TODO
+
+    You can even mix them:
+
+    my $dvd = $dvd_rs->recursive_update( {
+        id   => 1,
+        tags => [ '2', { id => '3' } ],
+    });
+
+Clearing the relationship:
+
+    my $dvd = $dvd_rs->recursive_update( {
+        id   => 1,
+        tags => undef,
+    });
+
+    This is the same as passing an empty array:
+
+    my $dvd = $dvd_rs->recursive_update( {
+        id   => 1,
+        tags => [],
+    });
+
+=head2 Treatment of many-to-many pseudo relations
 
 The function gets the information about m2m relations from DBIx::Class::IntrospectableM2M.
 
 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 )
          )
 
     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 
 
 
 =head1 INTERFACE 
@@ -453,15 +626,11 @@ DBIx::Class::RecursiveUpdate requires no configuration files or environment vari
 
 =head1 INCOMPATIBILITIES
 
 
 =head1 INCOMPATIBILITIES
 
-=for author to fill in:
-
 None reported.
 
 
 =head1 BUGS AND LIMITATIONS
 
 None reported.
 
 
 =head1 BUGS AND LIMITATIONS
 
-=for author to fill in:
-
 No bugs have been reported.
 
 Please report any bugs or feature requests to
 No bugs have been reported.
 
 Please report any bugs or feature requests to
This page took 0.033447 seconds and 4 git commands to generate.