use strict;
use warnings;
+use Class::C3;
use Carp::Clan qw/^DBIx::Class/;
use Lingua::EN::Inflect::Number ();
-our $VERSION = '0.04999_07';
+our $VERSION = '0.05002';
=head1 NAME
=cut
sub new {
- my ( $class, $schema, $inflect_pl, $inflect_singular ) = @_;
+
+ my ( $class, $schema, $inflect_pl, $inflect_singular, $rel_attrs ) = @_;
my $self = {
schema => $schema,
inflect_plural => $inflect_pl,
inflect_singular => $inflect_singular,
+ relationship_attrs => $rel_attrs,
};
- bless $self => $class;
+ # validate the relationship_attrs arg
+ if( defined $self->{relationship_attrs} ) {
+ ref($self->{relationship_attrs}) eq 'HASH'
+ or croak "relationship_attrs must be a hashref";
+ }
- $self;
+ return bless $self => $class;
}
return Lingua::EN::Inflect::Number::to_S($relname);
}
+# 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
+sub _relationship_attrs {
+ my ( $self, $reltype ) = @_;
+ my $r = $self->{relationship_attrs};
+ return unless $r && ( $r->{all} || $r->{$reltype} );
+
+ my %composite = %{ $r->{all} || {} };
+ if( my $specific = $r->{$reltype} ) {
+ while( my ($k,$v) = each %$specific ) {
+ $composite{$k} = $v;
+ }
+ }
+ return \%composite;
+}
+
sub _array_eq {
my ($a, $b) = @_;
return 1;
}
+sub _uniq_fk_rel {
+ my ($self, $local_moniker, $local_relname, $local_cols, $uniqs) = @_;
+
+ my $remote_method = 'has_many';
+
+ # If the local columns have a UNIQUE constraint, this is a one-to-one rel
+ my $local_source = $self->{schema}->source($local_moniker);
+ if (_array_eq([ $local_source->primary_columns ], $local_cols) ||
+ grep { _array_eq($_->[1], $local_cols) } @$uniqs) {
+ $remote_method = 'might_have';
+ $local_relname = $self->_inflect_singular($local_relname);
+ }
+
+ return ($remote_method, $local_relname);
+}
+
+sub _remote_attrs {
+ my ($self, $local_moniker, $local_cols) = @_;
+
+ # get our base set of attrs from _relationship_attrs, if present
+ my $attrs = $self->_relationship_attrs('belongs_to') || {};
+
+ # If the referring column is nullable, make 'belongs_to' an
+ # outer join, unless explicitly set by relationship_attrs
+ my $nullable = grep { $self->{schema}->source($local_moniker)->column_info($_)->{is_nullable} }
+ @$local_cols;
+ $attrs->{join_type} = 'LEFT'
+ if $nullable && !defined $attrs->{join_type};
+
+ return $attrs;
+}
+
+sub _remote_relname {
+ my ($self, $remote_table, $cond) = @_;
+
+ my $remote_relname;
+ # for single-column case, set the remote relname to the column
+ # name, to make filter accessors work, but strip trailing _id
+ if(scalar keys %{$cond} == 1) {
+ my ($col) = values %{$cond};
+ $col =~ s/_id$//;
+ $remote_relname = $self->_inflect_singular($col);
+ }
+ else {
+ $remote_relname = $self->_inflect_singular(lc $remote_table);
+ }
+
+ return $remote_relname;
+}
+
sub generate_code {
my ($self, $local_moniker, $rels, $uniqs) = @_;
}
my $local_relname;
- my $remote_relname;
-
- # for single-column case, set the remote relname to the column
- # name, to make filter accessors work, but strip trailing _id
- if(scalar keys %cond == 1) {
- my ($col) = values %cond;
- $col =~ s/_id$//;
- $remote_relname = $self->_inflect_singular($col);
- }
- else {
- $remote_relname = $self->_inflect_singular(lc $remote_table);
- }
+ my $remote_relname = $self->_remote_relname($remote_table, \%cond);
# If more than one rel between this pair of tables, use the local
# col names to distinguish
if($counters{$remote_moniker} > 1) {
my $colnames = q{_} . join(q{_}, @$local_cols);
- $local_relname = $self->_inflect_plural(
- lc($local_table) . $colnames
- );
$remote_relname .= $colnames if keys %cond > 1;
+
+ my $is_singular =
+ ($self->_uniq_fk_rel($local_moniker, 'dummy', $local_cols, $uniqs))[0] ne 'has_many';
+
+ $local_relname = $self->_multi_rel_local_relname(
+ $remote_class, $local_table, $local_cols, $is_singular
+ );
} else {
$local_relname = $self->_inflect_plural(lc $local_table);
}
delete $rev_cond{$_};
}
- my $remote_method = 'has_many';
+ my ($remote_method);
- # If the local columns have a UNIQUE constraint, this is a one-to-one rel
- my $local_source = $self->{schema}->source($local_moniker);
- if (_array_eq([ $local_source->primary_columns ], $local_cols) ||
- grep { _array_eq($_->[1], $local_cols) } @$uniqs) {
- $remote_method = 'might_have';
- $local_relname = $self->_inflect_singular($local_relname);
- }
-
- # If the referring column is nullable, make 'belongs_to' an outer join:
- my $nullable = grep { $local_source->column_info($_)->{is_nullable} }
- @$local_cols;
+ ($remote_method, $local_relname) = $self->_uniq_fk_rel($local_moniker, $local_relname, $local_cols, $uniqs);
push(@{$all_code->{$local_class}},
{ method => 'belongs_to',
args => [ $remote_relname,
$remote_class,
\%cond,
- $nullable ? { join_type => 'LEFT' } : ()
+ $self->_remote_attrs($local_moniker, $local_cols),
],
}
);
args => [ $local_relname,
$local_class,
\%rev_cond,
+ $self->_relationship_attrs($remote_method),
],
}
);
return $all_code;
}
+sub _multi_rel_local_relname {
+ my ($self, $remote_class, $local_table, $local_cols, $is_singular) = @_;
+
+ my $inflect = $is_singular ? '_inflect_singular' : '_inflect_plural';
+ $inflect = $self->can($inflect);
+
+ my $colnames = q{_} . join(q{_}, @$local_cols);
+ my $old_relname = #< TODO: remove me after 0.05003 release
+ my $local_relname = lc($local_table) . $colnames;
+ my $stripped_id = $local_relname =~ s/_id$//; #< strip off any trailing _id
+ $local_relname = $self->$inflect( $local_relname );
+
+ # TODO: remove me after 0.05003 release
+ $old_relname = $self->$inflect( $old_relname );
+ warn __PACKAGE__." $VERSION: warning, stripping trailing _id from ${remote_class} relation '$old_relname', renaming to '$local_relname'. This behavior is new as of 0.05003.\n"
+ if $stripped_id;
+
+ return $local_relname;
+}
+
+=head1 AUTHOR
+
+See L<DBIx::Class::Schema::Loader/AUTHOR> and L<DBIx::Class::Schema::Loader/CONTRIBUTORS>.
+
+=head1 LICENSE
+
+This library is free software; you can redistribute it and/or modify it under
+the same terms as Perl itself.
+
+=cut
+
1;