X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FSchema%2FLoader%2FRelBuilder.pm;h=c463b77f1457f56cf81618684467fbf3b8bedcca;hb=edf3eb3948266e8e324da57a9b1cc9ecfb5c4a3f;hp=38c865ed0746deb7a8251028194a4522d90c4235;hpb=bb46cd4b8d2cf185f37b632bc339d9669267c7fb;p=dbsrgits%2FDBIx-Class-Schema-Loader.git diff --git a/lib/DBIx/Class/Schema/Loader/RelBuilder.pm b/lib/DBIx/Class/Schema/Loader/RelBuilder.pm index 38c865e..c463b77 100644 --- a/lib/DBIx/Class/Schema/Loader/RelBuilder.pm +++ b/lib/DBIx/Class/Schema/Loader/RelBuilder.pm @@ -18,7 +18,7 @@ use String::ToIdentifier::EN::Unicode (); use Class::Unload (); use Class::Inspector (); -our $VERSION = '0.07021'; +our $VERSION = '0.07038'; # Glossary: # @@ -47,8 +47,8 @@ Arguments: $loader object =head2 generate_code -Arguments: - +Arguments: + [ [ local_moniker1 (scalar), fk_info1 (arrayref), uniq_info1 (arrayref) ] [ local_moniker2 (scalar), fk_info2 (arrayref), uniq_info2 (arrayref) ] @@ -149,8 +149,8 @@ sub new { # validate the relationship_attrs arg if( defined $self->relationship_attrs ) { - ref $self->relationship_attrs eq 'HASH' - or croak "relationship_attrs must be a hashref"; + (ref $self->relationship_attrs eq 'HASH' || ref $self->relationship_attrs eq 'CODE') + or croak "relationship_attrs must be a hashref or coderef"; } return $self; @@ -249,24 +249,39 @@ sub _default_relationship_attrs { +{ }, } } -# accessor for options to be passed to each generated relationship -# type. take single argument, the relationship type name, and returns -# either a hashref (if some options are set), or nothing +# Accessor for options to be passed to each generated relationship type. takes +# the relationship type name and optionally any attributes from the database +# (such as FK ON DELETE/UPDATE and DEFERRABLE clauses), and returns a +# hashref or undef if nothing is set. +# +# The attributes from the database override the default attributes, which in +# turn are overridden by user supplied attributes. sub _relationship_attrs { - my ( $self, $reltype ) = @_; + my ( $self, $reltype, $db_attrs, $params ) = @_; my $r = $self->relationship_attrs; my %composite = ( %{ $self->_default_relationship_attrs->{$reltype} || {} }, - %{ $r->{all} || {} } + %{ $db_attrs || {} }, + ( + ref $r eq 'HASH' ? ( + %{ $r->{all} || {} }, + %{ $r->{$reltype} || {} }, + ) + : + () + ), ); - if( my $specific = $r->{$reltype} ) { - while( my ($k,$v) = each %$specific ) { - $composite{$k} = $v; - } + if (ref $r eq 'CODE') { + $params->{attrs} = \%composite; + + my %ret = %{ $r->(%$params) || {} }; + + %composite = %ret if %ret; } - return \%composite; + + return %composite ? \%composite : undef; } sub _strip_id_postfix { @@ -278,10 +293,10 @@ sub _strip_id_postfix { } sub _remote_attrs { - my ($self, $local_moniker, $local_cols) = @_; + my ($self, $local_moniker, $local_cols, $fk_attrs, $params) = @_; - # get our base set of attrs from _relationship_attrs, if present - my $attrs = $self->_relationship_attrs('belongs_to') || {}; + # get our set of attrs from _relationship_attrs, which uses the FK attrs if available + my $attrs = $self->_relationship_attrs('belongs_to', $fk_attrs, $params) || {}; # If any referring column is nullable, make 'belongs_to' an # outer join, unless explicitly set by relationship_attrs @@ -363,7 +378,7 @@ EOF sub generate_code { my ($self, $tables) = @_; - + # make a copy to destroy my @tables = @$tables; @@ -402,47 +417,81 @@ sub generate_code { $self->_relnames_and_method( $local_moniker, $rel, \%cond, $uniqs, \%counters ); my $local_method = 'belongs_to'; - ($remote_relname) = $self->_rel_name_map($remote_relname, $local_method, $local_class, $local_moniker, $local_cols, $remote_class, $remote_moniker, $remote_cols); - ($local_relname) = $self->_rel_name_map($local_relname, $remote_method, $remote_class, $remote_moniker, $remote_cols, $local_class, $local_moniker, $local_cols); - - $remote_relname = $self->_resolve_relname_collision($local_moniker, $local_cols, $remote_relname); - $local_relname = $self->_resolve_relname_collision($remote_moniker, $remote_cols, $local_relname); - - push(@{$all_code->{$local_class}}, - { method => $local_method, - args => [ $remote_relname, - $remote_class, - \%cond, - $self->_remote_attrs($local_moniker, $local_cols), - ], - extra => { - local_class => $local_class, - local_moniker => $local_moniker, - remote_moniker => $remote_moniker, - }, - } + ($remote_relname) = $self->_rel_name_map( + $remote_relname, $local_method, + $local_class, $local_moniker, $local_cols, + $remote_class, $remote_moniker, $remote_cols, + ); + ($local_relname) = $self->_rel_name_map( + $local_relname, $remote_method, + $remote_class, $remote_moniker, $remote_cols, + $local_class, $local_moniker, $local_cols, + ); + + $remote_relname = $self->_resolve_relname_collision( + $local_moniker, $local_cols, $remote_relname, + ); + $local_relname = $self->_resolve_relname_collision( + $remote_moniker, $remote_cols, $local_relname, ); + my $rel_attrs_params = { + rel_name => $remote_relname, + rel_type => $local_method, + local_source => $self->schema->source($local_moniker), + remote_source => $self->schema->source($remote_moniker), + local_table => $rel->{local_table}, + local_cols => $local_cols, + remote_table => $rel->{remote_table}, + remote_cols => $remote_cols, + }; + + push @{$all_code->{$local_class}}, { + method => $local_method, + args => [ + $remote_relname, + $remote_class, + \%cond, + $self->_remote_attrs($local_moniker, $local_cols, $rel->{attrs}, $rel_attrs_params), + ], + extra => { + local_class => $local_class, + local_moniker => $local_moniker, + remote_moniker => $remote_moniker, + }, + }; + my %rev_cond = reverse %cond; for (keys %rev_cond) { $rev_cond{"foreign.$_"} = "self.".$rev_cond{$_}; delete $rev_cond{$_}; } - push(@{$all_code->{$remote_class}}, - { method => $remote_method, - args => [ $local_relname, - $local_class, - \%rev_cond, - $self->_relationship_attrs($remote_method), - ], - extra => { - local_class => $remote_class, - local_moniker => $remote_moniker, - remote_moniker => $local_moniker, - }, - } - ); + $rel_attrs_params = { + rel_name => $local_relname, + rel_type => $remote_method, + local_source => $self->schema->source($remote_moniker), + remote_source => $self->schema->source($local_moniker), + local_table => $rel->{remote_table}, + local_cols => $remote_cols, + remote_table => $rel->{local_table}, + remote_cols => $local_cols, + }; + + push @{$all_code->{$remote_class}}, { + method => $remote_method, + args => [ + $local_relname, + $local_class, + \%rev_cond, + $self->_relationship_attrs($remote_method, {}, $rel_attrs_params), + ], + extra => { + local_class => $remote_class, + local_moniker => $remote_moniker, + remote_moniker => $local_moniker, + }, + }; } } @@ -480,12 +529,16 @@ sub _generate_m2ms { $_->{method} eq 'has_many' && $_->{args}[1] eq $class } @{ $all_code->{$class1} }; + next unless $class1_to_link_table_rel; + my $class1_to_link_table_rel_name = $class1_to_link_table_rel->{args}[0]; my $class2_to_link_table_rel = first { $_->{method} eq 'has_many' && $_->{args}[1] eq $class } @{ $all_code->{$class2} }; + next unless $class2_to_link_table_rel; + my $class2_to_link_table_rel_name = $class2_to_link_table_rel->{args}[0]; my $class1_link_rel = $rels->[1]{args}[0]; @@ -507,11 +560,13 @@ sub _generate_m2ms { my @class2_to_cols = apply { s/^foreign\.//i } keys %{ $rels->[0]{args}[2] }; + my $link_moniker = $rels->[0]{extra}{local_moniker}; + my @link_table_cols = - @{[ $self->schema->source($rels->[0]{extra}{local_moniker})->columns ]}; + @{[ $self->schema->source($link_moniker)->columns ]}; my @link_table_primary_cols = - @{[ $self->schema->source($rels->[0]{extra}{local_moniker})->primary_columns ]}; + @{[ $self->schema->source($link_moniker)->primary_columns ]}; next unless @class1_link_cols + @class2_link_cols == @link_table_cols && @link_table_cols == @link_table_primary_cols; @@ -525,6 +580,11 @@ sub _generate_m2ms { $class2, $class1_remote_moniker, \@class1_to_cols, + { + link_class => $class, + link_moniker => $link_moniker, + link_rel_name => $class1_to_link_table_rel_name, + }, ); $class1_to_class2_relname = $self->_resolve_relname_collision( @@ -542,6 +602,11 @@ sub _generate_m2ms { $class2, $class2_remote_moniker, \@class2_to_cols, + { + link_class => $class, + link_moniker => $link_moniker, + link_rel_name => $class2_to_link_table_rel_name, + }, ); $class2_to_class1_relname = $self->_resolve_relname_collision( @@ -556,6 +621,16 @@ sub _generate_m2ms { $class1_to_class2_relname, $class1_to_link_table_rel_name, $class1_link_rel, + $self->_relationship_attrs('many_to_many', {}, { + rel_type => 'many_to_many', + rel_name => $class1_to_class2_relname, + local_source => $self->schema->source($class1_local_moniker), + remote_source => $self->schema->source($class1_remote_moniker), + local_table => $self->loader->class_to_table->{$class1}, + local_cols => \@class1_from_cols, + remote_table => $self->loader->class_to_table->{$class2}, + remote_cols => \@class2_from_cols, + }) || (), ], extra => { local_class => $class1, @@ -571,6 +646,16 @@ sub _generate_m2ms { $class2_to_class1_relname, $class2_to_link_table_rel_name, $class2_link_rel, + $self->_relationship_attrs('many_to_many', {}, { + rel_type => 'many_to_many', + rel_name => $class2_to_class1_relname, + local_source => $self->schema->source($class2_local_moniker), + remote_source => $self->schema->source($class2_remote_moniker), + local_table => $self->loader->class_to_table->{$class2}, + local_cols => \@class2_from_cols, + remote_table => $self->loader->class_to_table->{$class1}, + remote_cols => \@class1_from_cols, + }) || (), ], extra => { local_class => $class2, @@ -779,7 +864,7 @@ sub _disambiguate { my $rel_name_mapped; ($relname_new, $rel_name_mapped) = $self->_rel_name_map($relname_new, $rel->{method}, $local_class, $local_moniker, \@from_cols, $to_class, $remote_moniker, \@to_cols); - + my $mapped = $inflect_mapped || $rel_name_mapped; warn <<"EOF" unless $mapped; @@ -872,9 +957,10 @@ sub _relnames_and_method { sub _rel_name_map { my ($self, $relname, $method, $local_class, $local_moniker, $local_cols, - $remote_class, $remote_moniker, $remote_cols) = @_; + $remote_class, $remote_moniker, $remote_cols, $extra) = @_; my $info = { + %{$extra || {}}, name => $relname, type => $method, local_class => $local_class, @@ -885,9 +971,13 @@ sub _rel_name_map { remote_columns => $remote_cols, }; - my $new_name = $relname; + $self->_run_user_map($self->rel_name_map, $info); +} + +sub _run_user_map { + my ($self, $map, $info) = @_; - my $map = $self->rel_name_map; + my $new_name = $info->{name}; my $mapped = 0; if ('HASH' eq ref($map)) { @@ -905,7 +995,14 @@ sub _rel_name_map { } } elsif ('CODE' eq ref($map)) { - my $name = $map->($info); + my $cb = sub { + my ($cb_map) = @_; + croak "reentered rel_name_map must be a hashref" + unless 'HASH' eq ref($cb_map); + my ($cb_name, $cb_mapped) = $self->_run_user_map($cb_map, $info); + return $cb_mapped && $cb_name; + }; + my $name = $map->($info, $cb); if ($name) { $new_name = $name; $mapped = 1;