use DBIx::Class ();
use namespace::clean;
-our $VERSION = '0.07002';
+our $VERSION = '0.07010';
__PACKAGE__->mk_group_ro_accessors('simple', qw/
schema
skip_relationships
skip_load_external
moniker_map
+ col_accessor_map
custom_column_info
inflect_singular
inflect_plural
pod_comment_spillover_length
preserve_case
col_collision_map
+ rel_collision_map
real_dump_directory
+ result_component_map
+ datetime_undef_if_invalid
+ _result_class_methods
/);
=head1 NAME
stations_visited | StationVisited
routeChange | RouteChange
+=head2 col_accessor_map
+
+Same as moniker_map, but for column accessor names. If a coderef is
+passed, the code is called with arguments of
+
+ the name of the column in the underlying database,
+ default accessor name that DBICSL would ordinarily give this column,
+ {
+ table_class => name of the DBIC class we are building,
+ table_moniker => calculated moniker for this table (after moniker_map if present),
+ table_name => name of the database table,
+ full_table_name => schema-qualified name of the database table (RDBMS specific),
+ schema_class => name of the schema class we are building,
+ column_info => hashref of column info (data_type, is_nullable, etc),
+ }
+
=head2 inflect_plural
Just like L</moniker_map> above (can be hash/code-ref, falls back to default
classes. A good example would be
L<InflateColumn::DateTime|DBIx::Class::InflateColumn::DateTime>
+=head2 result_component_map
+
+A hashref of moniker keys and component values. Unlike C<components>, which loads the
+given components into every table class, this option allows you to load certain
+components for specified tables. For example:
+
+ result_component_map => {
+ StationVisited => '+YourApp::Schema::Component::StationVisited',
+ RouteChange => [
+ '+YourApp::Schema::Component::RouteChange',
+ 'InflateColumn::DateTime',
+ ],
+ }
+
+You may use this in conjunction with C<components>.
+
=head2 use_namespaces
This is now the default, to go back to L<DBIx::Class::Schema/load_classes> pass
Sets the locale attribute for L<DBIx::Class::InflateColumn::DateTime> for all
columns with the DATE/DATETIME/TIMESTAMP data_types.
+=head2 datetime_undef_if_invalid
+
+Pass a C<0> for this option when using MySQL if you B<DON'T> want C<<
+datetime_undef_if_invalid => 1 >> in your column info for DATE, DATETIME and
+TIMESTAMP columns.
+
+The default is recommended to deal with data such as C<00/00/00> which
+sometimes ends up in such columns in MySQL.
+
=head2 config_file
File in Perl format, which should return a HASH reference, from which to read
col_collision_map => { '(foo).*(bar)' => 'column_%s_%s' }
+=head2 rel_collision_map
+
+Works just like L</col_collision_map>, but for relationship names/accessors
+rather than column names/accessors.
+
+The default is to just append C<_rel> to the relationship name, see
+L</RELATIONSHIP NAME COLLISIONS>.
+
=head1 METHODS
None of these methods are intended for direct invocation by regular
sub new {
my ( $class, %args ) = @_;
+ if (exists $args{column_accessor_map}) {
+ $args{col_accessor_map} = delete $args{column_accessor_map};
+ }
+
my $self = { %args };
# don't lose undef options
$self->_validate_class_args;
+ if ($self->result_component_map) {
+ my %rc_map = %{ $self->result_component_map };
+ foreach my $moniker (keys %rc_map) {
+ $rc_map{$moniker} = [ $rc_map{$moniker} ] unless ref $rc_map{$moniker};
+ }
+ $self->result_component_map(\%rc_map);
+ }
+ else {
+ $self->result_component_map({});
+ }
+ $self->_validate_result_component_map;
+
if ($self->use_moose) {
if (not DBIx::Class::Schema::Loader::Optional::Dependencies->req_ok_for('use_moose')) {
die sprintf "You must install the following CPAN modules to enable the use_moose option: %s.\n",
sub _validate_class_args {
my $self = shift;
- my $args = shift;
foreach my $k (@CLASS_ARGS) {
next unless $self->$k;
my @classes = ref $self->$k eq 'ARRAY' ? @{ $self->$k } : $self->$k;
- foreach my $c (@classes) {
- # components default to being under the DBIx::Class namespace unless they
- # are preceeded with a '+'
- if ( $k =~ m/components$/ && $c !~ s/^\+// ) {
- $c = 'DBIx::Class::' . $c;
- }
+ $self->_validate_classes($k, \@classes);
+ }
+}
- # 1 == installed, 0 == not installed, undef == invalid classname
- my $installed = Class::Inspector->installed($c);
- if ( defined($installed) ) {
- if ( $installed == 0 ) {
- croak qq/$c, as specified in the loader option "$k", is not installed/;
- }
- } else {
- croak qq/$c, as specified in the loader option "$k", is an invalid class name/;
+sub _validate_result_component_map {
+ my $self = shift;
+
+ my $map = $self->result_component_map;
+ return unless $map && ref $map eq 'HASH';
+
+ foreach my $classes (values %$map) {
+ $self->_validate_classes('result_component_map', [@$classes]);
+ }
+}
+
+sub _validate_classes {
+ my $self = shift;
+ my $key = shift;
+ my $classes = shift;
+
+ foreach my $c (@$classes) {
+ # components default to being under the DBIx::Class namespace unless they
+ # are preceeded with a '+'
+ if ( $key =~ m/component/ && $c !~ s/^\+// ) {
+ $c = 'DBIx::Class::' . $c;
+ }
+
+ # 1 == installed, 0 == not installed, undef == invalid classname
+ my $installed = Class::Inspector->installed($c);
+ if ( defined($installed) ) {
+ if ( $installed == 0 ) {
+ croak qq/$c, as specified in the loader option "$key", is not installed/;
}
+ } else {
+ croak qq/$c, as specified in the loader option "$key", is an invalid class name/;
}
}
}
+
sub _find_file_in_inc {
my ($self, $file) = @_;
->{ $self->naming->{relationships}};
my $relbuilder_class = 'DBIx::Class::Schema::Loader::RelBuilder'.$relbuilder_suff;
- eval "require $relbuilder_class"; die $@ if $@;
+ $self->ensure_class_loaded($relbuilder_class);
$relbuilder_class->new( $self );
};
eval_without_redefine_warnings ("require $class");
}
catch {
- die "Failed to reload class $class: $_";
+ my $source = slurp $self->_get_dump_filename($class);
+ die "Failed to reload class $class: $_.\n\nCLASS SOURCE:\n\n$source";
};
}
. qq|# DO NOT MODIFY THE FIRST PART OF THIS FILE\n\n|;
if ($self->use_moose) {
- $schema_text.= qq|use Moose;\nuse MooseX::NonMoose;\nuse namespace::autoclean;\nextends '$schema_base_class';\n\n|;
+ $schema_text.= qq|use Moose;\nuse namespace::autoclean;\nextends '$schema_base_class';\n\n|;
}
else {
$schema_text .= qq|use strict;\nuse warnings;\n\nuse base '$schema_base_class';\n\n|;
}
}
- $custom_content ||= $self->_default_custom_content;
+ $custom_content ||= $self->_default_custom_content($is_schema);
# If upgrading to use_moose=1 replace default custom content with default Moose custom content.
# If there is already custom content, which does not have the Moose content, add it.
};
if ($custom_content eq $non_moose_custom_content) {
- $custom_content = $self->_default_custom_content;
+ $custom_content = $self->_default_custom_content($is_schema);
}
- elsif ($custom_content !~ /\Q@{[$self->_default_moose_custom_content]}\E/) {
- $custom_content .= $self->_default_custom_content;
+ elsif ($custom_content !~ /\Q@{[$self->_default_moose_custom_content($is_schema)]}\E/) {
+ $custom_content .= $self->_default_custom_content($is_schema);
}
}
elsif (defined $self->use_moose && $old_gen) {
}
sub _default_moose_custom_content {
- return qq|\n__PACKAGE__->meta->make_immutable;|;
+ my ($self, $is_schema) = @_;
+
+ if (not $is_schema) {
+ return qq|\n__PACKAGE__->meta->make_immutable;|;
+ }
+
+ return qq|\n__PACKAGE__->meta->make_immutable(inline_constructor => 0);|;
}
sub _default_custom_content {
- my $self = shift;
+ my ($self, $is_schema) = @_;
my $default = qq|\n\n# You can replace this text with custom|
. qq| code or comments, and it will be preserved on regeneration|;
if ($self->use_moose) {
- $default .= $self->_default_moose_custom_content;
+ $default .= $self->_default_moose_custom_content($is_schema);
}
$default .= qq|\n1;\n|;
return $default;
$self->_use ($table_class, @{$self->additional_classes});
$self->_inject($table_class, @{$self->left_base_classes});
- if (my @components = @{ $self->components }) {
- $self->_dbic_stmt($table_class, 'load_components', @components);
- }
+ my @components = @{ $self->components || [] };
+
+ push @components, @{ $self->result_component_map->{$table_moniker} }
+ if exists $self->result_component_map->{$table_moniker};
+
+ $self->_dbic_stmt($table_class, 'load_components', @components) if @components;
$self->_inject($table_class, @{$self->additional_base_classes});
}
-sub _resolve_col_accessor_collisions {
- my ($self, $table, $col_info) = @_;
+sub _is_result_class_method {
+ my ($self, $name, $table_name) = @_;
- my $base = $self->result_base_class || 'DBIx::Class::Core';
- my @components = map "DBIx::Class::$_", @{ $self->components || [] };
+ my $table_moniker = $table_name ? $self->_table2moniker($table_name) : '';
- my $table_name = ref $table ? $$table : $table;
+ if (not $self->_result_class_methods) {
+ my (@methods, %methods);
+ my $base = $self->result_base_class || 'DBIx::Class::Core';
+
+ my @components = @{ $self->components || [] };
+
+ push @components, @{ $self->result_component_map->{$table_moniker} }
+ if exists $self->result_component_map->{$table_moniker};
+
+ for my $c (@components) {
+ $c = $c =~ /^\+/ ? substr($c,1) : "DBIx::Class::$c";
+ }
- my @methods;
+ for my $class ($base, @components, $self->use_moose ? 'Moose::Object' : ()) {
+ $self->ensure_class_loaded($class);
- for my $class ($base, @components, $self->use_moose ? 'Moose::Object' : ()) {
- eval "require ${class};";
- die $@ if $@;
+ push @methods, @{ Class::Inspector->methods($class) || [] };
+ }
+
+ push @methods, @{ Class::Inspector->methods('UNIVERSAL') };
+
+ @methods{@methods} = ();
- push @methods, @{ Class::Inspector->methods($class) || [] };
- push @methods, @{ Class::Inspector->methods('UNIVERSAL') || [] };
+ $self->_result_class_methods(\%methods);
}
+ my $result_methods = $self->_result_class_methods;
- my %methods;
- @methods{@methods} = ();
+ return exists $result_methods->{$name};
+}
+
+sub _resolve_col_accessor_collisions {
+ my ($self, $table, $col_info) = @_;
- # futureproof meta
- $methods{meta} = undef;
+ my $table_name = ref $table ? $$table : $table;
while (my ($col, $info) = each %$col_info) {
my $accessor = $info->{accessor} || $col;
next if $accessor eq 'id'; # special case (very common column)
- if (exists $methods{$accessor}) {
+ if ($self->_is_result_class_method($accessor, $table_name)) {
my $mapped = 0;
if (my $map = $self->col_collision_map) {
if (not $mapped) {
warn <<"EOF";
-Column $col in table $table_name collides with an inherited method.
+Column '$col' in table '$table_name' collides with an inherited method.
See "COLUMN ACCESSOR COLLISIONS" in perldoc DBIx::Class::Schema::Loader::Base .
EOF
$info->{accessor} = undef;
}
}
-sub _make_column_accessor_name {
- my ($self, $column_name) = @_;
+# use the same logic to run moniker_map, col_accessor_map, and
+# relationship_name_map
+sub _run_user_map {
+ my ( $self, $map, $default_code, $ident, @extra ) = @_;
+
+ my $default_ident = $default_code->( $ident, @extra );
+ my $new_ident;
+ if( $map && ref $map eq 'HASH' ) {
+ $new_ident = $map->{ $ident };
+ }
+ elsif( $map && ref $map eq 'CODE' ) {
+ $new_ident = $map->( $ident, $default_ident, @extra );
+ }
+
+ $new_ident ||= $default_ident;
+
+ return $new_ident;
+}
+
+sub _default_column_accessor_name {
+ my ( $self, $column_name ) = @_;
+
+ my $accessor_name = $column_name;
+ $accessor_name =~ s/\W+/_/g;
+
+ if ((($self->naming->{column_accessors}||'') =~ /(\d+)/ && $1 < 7) || (not $self->preserve_case)) {
+ # older naming just lc'd the col accessor and that's all.
+ return lc $accessor_name;
+ }
return join '_', map lc, split_name $column_name;
+
+}
+
+sub _make_column_accessor_name {
+ my ($self, $column_name, $column_context_info ) = @_;
+
+ my $accessor = $self->_run_user_map(
+ $self->col_accessor_map,
+ sub { $self->_default_column_accessor_name( shift ) },
+ $column_name,
+ $column_context_info,
+ );
+
+ return $accessor;
}
# Set up metadata (cols, pks, etc)
$self->_dbic_stmt($table_class, 'table', $full_table_name);
- my $cols = $self->_table_columns($table);
+ my $cols = $self->_table_columns($table);
my $col_info = $self->__columns_info_for($table);
+ ### generate all the column accessor names
while (my ($col, $info) = each %$col_info) {
- if ($col =~ /\W/) {
- ($info->{accessor} = $col) =~ s/\W+/_/g;
- }
- }
+ # hashref of other info that could be used by
+ # user-defined accessor map functions
+ my $context = {
+ table_class => $table_class,
+ table_moniker => $table_moniker,
+ table_name => $table_name,
+ full_table_name => $full_table_name,
+ schema_class => $schema_class,
+ column_info => $info,
+ };
- if ($self->preserve_case) {
- while (my ($col, $info) = each %$col_info) {
- if ($col ne lc($col)) {
- if ((not exists $self->naming->{column_accessors}) || (($self->naming->{column_accessors} =~ /(\d+)/)[0] >= 7)) {
- $info->{accessor} = $self->_make_column_accessor_name($info->{accessor} || $col);
- }
- else {
- $info->{accessor} = lc($info->{accessor} || $col);
- }
- }
- }
- }
- else {
- # XXX this needs to go away
- $col_info = { map { lc($_), $col_info->{$_} } keys %$col_info };
+ $info->{accessor} = $self->_make_column_accessor_name( $col, $context );
}
$self->_resolve_col_accessor_collisions($full_table_name, $col_info);
+ # prune any redundant accessor names
+ while (my ($col, $info) = each %$col_info) {
+ no warnings 'uninitialized';
+ delete $info->{accessor} if $info->{accessor} eq $col;
+ }
+
my $fks = $self->_table_fk_info($table);
foreach my $fkdef (@$fks) {
sub _table2moniker {
my ( $self, $table ) = @_;
- my $moniker;
-
- if( ref $self->moniker_map eq 'HASH' ) {
- $moniker = $self->moniker_map->{$table};
- }
- elsif( ref $self->moniker_map eq 'CODE' ) {
- $moniker = $self->moniker_map->($table);
- }
-
- $moniker ||= $self->_default_table2moniker($table);
-
- return $moniker;
+ $self->_run_user_map(
+ $self->moniker_map,
+ sub { $self->_default_table2moniker( shift ) },
+ $table
+ );
}
sub _load_relationships {
Another option is to use the L</col_collision_map> option.
+=head1 RELATIONSHIP NAME COLLISIONS
+
+In very rare cases, you may get a collision between a generated relationship
+name and a method in your Result class, for example if you have a foreign key
+called C<belongs_to>.
+
+This is a problem because relationship names are also relationship accessor
+methods in L<DBIx::Class>.
+
+The default behavior is to append C<_rel> to the relationship name and print
+out a warning that refers to this text.
+
+You can also control the renaming with the L</rel_collision_map> option.
+
=head1 SEE ALSO
L<DBIx::Class::Schema::Loader>
projects / dbsrgits/DBIx-Class-Schema-Loader.git / blobdiff