use strict;
use warnings;
use base qw/Class::Accessor::Grouped Class::C3::Componentised/;
-use namespace::autoclean;
-use Class::C3;
+use mro 'c3';
use Carp::Clan qw/^DBIx::Class/;
use DBIx::Class::Schema::Loader::RelBuilder;
use Data::Dump qw/ dump /;
use File::Temp qw//;
use Class::Unload;
use Class::Inspector ();
-use Data::Dumper::Concise;
use Scalar::Util 'looks_like_number';
use File::Slurp 'slurp';
-require DBIx::Class;
+use DBIx::Class::Schema::Loader::Utils qw/split_name dumper_squashed/;
+use DBIx::Class::Schema::Loader::Optional::Dependencies ();
+use Try::Tiny;
+use DBIx::Class ();
+use namespace::clean;
-our $VERSION = '0.07000';
+our $VERSION = '0.07001';
__PACKAGE__->mk_group_ro_accessors('simple', qw/
schema
default_resultset_class
schema_base_class
result_base_class
+ use_moose
overwrite_modifications
relationship_attrs
datetime_locale
config_file
loader_class
+ qualify_objects
/);
generate_pod
pod_comment_mode
pod_comment_spillover_length
+ preserve_case
/);
=head1 NAME
The option also takes a hashref:
- naming => { relationships => 'v6', monikers => 'v6' }
+ naming => { relationships => 'v7', monikers => 'v7' }
The keys are:
How to name Result classes.
+=item column_accessors
+
+How to name column accessors in Result classes.
+
=back
The values can be:
=item v6
-All monikers and relationships inflected using L<Lingua::EN::Inflect::Phrase>,
-more aggressive C<_id> stripping from relationships.
+All monikers and relationships are inflected using
+L<Lingua::EN::Inflect::Phrase>, and there is more aggressive C<_id> stripping
+from relationship names.
In general, there is very little difference between v5 and v6 schemas.
This mode is identical to C<v6> mode, except that monikerization of CamelCase
table names is also done correctly.
-If you don't have any CamelCase table names, you can upgrade without breaking
-any of your code.
+CamelCase column names in case-preserving mode will also be handled correctly
+for relationship name inflection. See L</preserve_case>.
+
+In this mode, CamelCase L</column_accessors> are normalized based on case
+transition instead of just being lowercased, so C<FooId> becomes C<foo_id>.
+
+If you don't have any CamelCase table or column names, you can upgrade without
+breaking any of your code.
=back
__PACKAGE__->naming('current');
-Or if you prefer to use 0.05XXX features but insure that nothing breaks in the
+Or if you prefer to use 0.07XXX features but insure that nothing breaks in the
next major version upgrade:
- __PACKAGE__->naming('v5');
+ __PACKAGE__->naming('v7');
=head2 generate_pod
For example:
relationship_attrs => {
- all => { cascade_delete => 0 },
- has_many => { cascade_delete => 1 },
+ belongs_to => { is_deferrable => 0 },
},
-will set the C<cascade_delete> option to 0 for all generated relationships,
-except for C<has_many>, which will have cascade_delete as 1.
-
-NOTE: this option is not supported if v4 backward-compatible naming is
-set either globally (naming => 'v4') or just for relationships.
+use this to turn off DEFERRABLE on your foreign key constraints.
=head2 debug
=head2 components
List of additional components to be loaded into all of your table
-classes. A good example would be C<ResultSetManager>.
+classes. A good example would be
+L<InflateColumn::DateTime|DBIx::Class::InflateColumn::DateTime>
=head2 resultset_components
Sets the locale attribute for L<DBIx::Class::InflateColumn::DateTime> for all
columns with the DATE/DATETIME/TIMESTAMP data_types.
-=head1 config_file
+=head2 config_file
File in Perl format, which should return a HASH reference, from which to read
loader options.
+=head2 preserve_case
+
+Usually column names are lowercased, to make them easier to work with in
+L<DBIx::Class>. This option lets you turn this behavior off, if the driver
+supports it.
+
+Drivers for case sensitive databases like Sybase ASE or MSSQL with a
+case-sensitive collation will turn this option on unconditionally.
+
+Currently the drivers for SQLite, mysql, MSSQL and Firebird/InterBase support
+setting this option.
+
+=head2 qualify_objects
+
+Set to true to prepend the L</db_schema> to table names for C<<
+__PACKAGE__->table >> calls, and to some other things like Oracle sequences.
+
+=head2 use_moose
+
+Creates Schema and Result classes that use L<Moose>, L<MooseX::NonMoose> and
+L<namespace::autoclean>. The default content after the md5 sum also makes the
+classes immutable.
+
+It is safe to upgrade your existing Schema to this option.
+
=head1 METHODS
None of these methods are intended for direct invocation by regular
$self->_validate_class_args;
+ 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.\nYou are missing: %s.\n",
+ "Moose, MooseX::NonMoose and namespace::autoclean",
+ DBIx::Class::Schema::Loader::Optional::Dependencies->req_missing_for('use_moose');
+ }
+ }
+
push(@{$self->{components}}, 'ResultSetManager')
if @{$self->{resultset_components}};
$self->{naming} = {
relationships => $naming_ver,
monikers => $naming_ver,
+ column_accessors => $naming_ver,
};
}
last;
}
- $self->naming->{relationships} ||= $v;
- $self->naming->{monikers} ||= $v;
+ $self->naming->{relationships} ||= $v;
+ $self->naming->{monikers} ||= $v;
+ $self->naming->{column_accessors} ||= $v;
$self->schema_version_to_dump($real_ver);
}
if ($old_real_inc_path) {
- open(my $fh, '<', $old_real_inc_path)
- or croak "Failed to open '$old_real_inc_path' for reading: $!";
+ my $code = slurp $old_real_inc_path;
+
$self->_ext_stmt($class, <<"EOF");
# These lines were loaded from '$old_real_inc_path',
-# based on the Result class name that would have been created by an 0.04006
+# based on the Result class name that would have been created by an older
# version of the Loader. For a static schema, this happens only once during
# upgrade. See skip_load_external to disable this feature.
EOF
- my $code = slurp $old_real_inc_path;
$code = $self->_rewrite_old_classnames($code);
if ($self->dynamic) {
warn <<"EOF";
Detected external content in '$old_real_inc_path', a class name that would have
-been used by an 0.04006 version of the Loader.
+been used by an older version of the Loader.
* PLEASE RENAME THIS CLASS: from '$old_class' to '$class', as that is the
new name of the Result.
Arguments: schema
-Rescan the database for newly added tables. Does
-not process drops or changes. Returns a list of
-the newly added table monikers.
+Rescan the database for changes. Returns a list of the newly added table
+monikers.
-The schema argument should be the schema class
-or object to be affected. It should probably
-be derived from the original schema_class used
-during L</load>.
+The schema argument should be the schema class or object to be affected. It
+should probably be derived from the original schema_class used during L</load>.
=cut
my @created;
my @current = $self->_tables_list({ constraint => $self->constraint, exclude => $self->exclude });
+
foreach my $table (@current) {
if(!exists $self->{_tables}->{$table}) {
push(@created, $table);
}
}
- my $loaded = $self->_load_tables(@created);
+ my %current;
+ @current{@current} = ();
+ foreach my $table (keys %{ $self->{_tables} }) {
+ if (not exists $current{$table}) {
+ $self->_unregister_source_for_table($table);
+ }
+ }
+
+ delete $self->{_dump_storage};
+ delete $self->{_relations_started};
- return map { $self->monikers->{$_} } @$loaded;
+ my $loaded = $self->_load_tables(@current);
+
+ return map { $self->monikers->{$_} } @created;
}
sub _relbuilder {
- no warnings 'uninitialized';
my ($self) = @_;
return if $self->{skip_relationships};
- if ($self->naming->{relationships} eq 'v4') {
- require DBIx::Class::Schema::Loader::RelBuilder::Compat::v0_040;
- return $self->{relbuilder} ||=
- DBIx::Class::Schema::Loader::RelBuilder::Compat::v0_040->new(
- $self->schema, $self->inflect_plural, $self->inflect_singular
- );
- }
- elsif ($self->naming->{relationships} eq 'v5') {
- require DBIx::Class::Schema::Loader::RelBuilder::Compat::v0_05;
- return $self->{relbuilder} ||= DBIx::Class::Schema::Loader::RelBuilder::Compat::v0_05->new (
- $self->schema,
- $self->inflect_plural,
- $self->inflect_singular,
- $self->relationship_attrs,
- );
- }
+ return $self->{relbuilder} ||= do {
- return $self->{relbuilder} ||= DBIx::Class::Schema::Loader::RelBuilder->new (
- $self->schema,
- $self->inflect_plural,
- $self->inflect_singular,
- $self->relationship_attrs,
- );
+ no warnings 'uninitialized';
+ my $relbuilder_suff =
+ {qw{
+ v4 ::Compat::v0_040
+ v5 ::Compat::v0_05
+ v6 ::Compat::v0_06
+ }}
+ ->{ $self->naming->{relationships}};
+
+ my $relbuilder_class = 'DBIx::Class::Schema::Loader::RelBuilder'.$relbuilder_suff;
+ eval "require $relbuilder_class"; die $@ if $@;
+ $relbuilder_class->new( $self );
+
+ };
}
sub _load_tables {
{
no warnings 'redefine';
- local *Class::C3::reinitialize = sub {};
+ local *Class::C3::reinitialize = sub {}; # to speed things up, reinitialized below
use warnings;
+ if (my $mc = $self->_moose_metaclass($class)) {
+ $mc->make_mutable;
+ }
Class::Unload->unload($class) if $unload;
my ($source, $resultset_class);
if (
&& ($resultset_class ne 'DBIx::Class::ResultSet')
) {
my $has_file = Class::Inspector->loaded_filename($resultset_class);
+ if (my $mc = $self->_moose_metaclass($resultset_class)) {
+ $mc->make_mutable;
+ }
Class::Unload->unload($resultset_class) if $unload;
$self->_reload_class($resultset_class) if $has_file;
}
}
}
+sub _moose_metaclass {
+ return undef unless $INC{'Class/MOP.pm'}; # if CMOP is not loaded the class could not have loaded in the 1st place
+
+ my $mc = Class::MOP::class_of($_[1])
+ or return undef;
+
+ return $mc->isa('Moose::Meta::Class') ? $mc : undef;
+}
+
# We use this instead of ensure_class_loaded when there are package symbols we
# want to preserve.
sub _reload_class {
unless $_[0] =~ /^Subroutine \S+ redefined/;
};
eval "require $class;";
+ die "Failed to reload class $class: $@" if $@;
}
sub _get_dump_filename {
qq|package $schema_class;\n\n|
. qq|# Created by DBIx::Class::Schema::Loader\n|
. qq|# DO NOT MODIFY THE FIRST PART OF THIS FILE\n\n|
- . qq|use strict;\nuse warnings;\n\n|
- . qq|use base '$schema_base_class';\n\n|;
+ . qq|use strict;\nuse warnings;\n\n|;
+ if ($self->use_moose) {
+ $schema_text.= qq|use Moose;\nuse MooseX::NonMoose;\nuse namespace::autoclean;\nextends '$schema_base_class';\n\n|;
+ }
+ else {
+ $schema_text .= qq|use base '$schema_base_class';\n\n|;
+ }
if ($self->use_namespaces) {
$schema_text .= qq|__PACKAGE__->load_namespaces|;
qq|package $src_class;\n\n|
. qq|# Created by DBIx::Class::Schema::Loader\n|
. qq|# DO NOT MODIFY THE FIRST PART OF THIS FILE\n\n|
- . qq|use strict;\nuse warnings;\n\n|
- . qq|use base '$result_base_class';\n\n|;
+ . qq|use strict;\nuse warnings;\n\n|;
+ if ($self->use_moose) {
+ $src_text.= qq|use Moose;\nuse MooseX::NonMoose;\nuse namespace::autoclean;|;
+ # these options 'use base' which is compile time
+ if (@{ $self->left_base_classes } || @{ $self->additional_base_classes }) {
+ $src_text .= qq|\nBEGIN { extends '$result_base_class' }\n\n|;
+ }
+ else {
+ $src_text .= qq|\nextends '$result_base_class';\n\n|;
+ }
+ }
+ else {
+ $src_text .= qq|use base '$result_base_class';\n\n|;
+ }
$self->_write_classfile($src_class, $src_text);
}
my ($custom_content, $old_md5, $old_ver, $old_ts) = $self->_get_custom_content($class, $filename);
+ # 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 ($self->use_moose) {
+ local $self->{use_moose} = 0;
+
+ if ($custom_content eq $self->_default_custom_content) {
+ local $self->{use_moose} = 1;
+
+ $custom_content = $self->_default_custom_content;
+ }
+ else {
+ local $self->{use_moose} = 1;
+
+ if ($custom_content !~ /\Q@{[$self->_default_moose_custom_content]}\E/) {
+ $custom_content .= $self->_default_custom_content;
+ }
+ }
+ }
+
if (my $old_class = $self->_upgrading_classes->{$class}) {
my $old_filename = $self->_get_dump_filename($old_class);
or croak "Error closing '$filename': $!";
}
+sub _default_moose_custom_content {
+ return qq|\n__PACKAGE__->meta->make_immutable;|;
+}
+
sub _default_custom_content {
- return qq|\n\n# You can replace this text with custom|
- . qq| content, and it will be preserved on regeneration|
- . qq|\n1;\n|;
+ my $self = shift;
+ my $default = qq|\n\n# You can replace this text with custom|
+ . qq| content, and it will be preserved on regeneration|;
+ if ($self->use_moose) {
+ $default .= $self->_default_moose_custom_content;
+ }
+ $default .= qq|\n1;\n|;
+ return $default;
}
sub _get_custom_content {
sub _inject {
my $self = shift;
my $target = shift;
- my $schema_class = $self->schema_class;
my $blist = join(q{ }, @_);
- warn "$target: use base qw/ $blist /;" if $self->debug && @_;
- $self->_raw_stmt($target, "use base qw/ $blist /;") if @_;
+
+ return unless $blist;
+
+ warn "$target: use base qw/$blist/;" if $self->debug;
+ $self->_raw_stmt($target, "use base qw/$blist/;");
}
sub _result_namespace {
my @methods;
- for my $class ($base, @components) {
+ for my $class ($base, @components, $self->use_moose ? 'Moose::Object' : ()) {
eval "require ${class};";
die $@ if $@;
my %methods;
@methods{@methods} = ();
+ # futureproof meta
+ $methods{meta} = undef;
+
while (my ($col, $info) = each %$col_info) {
my $accessor = $info->{accessor} || $col;
}
}
+sub _make_column_accessor_name {
+ my ($self, $column_name) = @_;
+
+ return join '_', map lc, split_name $column_name;
+}
+
# Set up metadata (cols, pks, etc)
sub _setup_src_meta {
my ($self, $table) = @_;
$table_name = \ $self->_quote_table_name($table_name);
}
- $self->_dbic_stmt($table_class,'table',$table_name);
+ my $full_table_name = ($self->qualify_objects ? ($self->db_schema . '.') : '') . (ref $table_name ? $$table_name : $table_name);
+
+ # be careful to not create refs Data::Dump can "optimize"
+ $full_table_name = \do {"".$full_table_name} if ref $table_name;
+
+ $self->_dbic_stmt($table_class, 'table', $full_table_name);
my $cols = $self->_table_columns($table);
my $col_info = $self->__columns_info_for($table);
- if ($self->_is_case_sensitive) {
- for my $col (keys %$col_info) {
- $col_info->{$col}{accessor} = lc $col
- if $col ne lc($col);
+
+ while (my ($col, $info) = each %$col_info) {
+ if ($col =~ /\W/) {
+ ($info->{accessor} = $col) =~ s/\W+/_/g;
+ }
+ }
+
+ 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 {
my $fks = $self->_table_fk_info($table);
- for my $fkdef (@$fks) {
+ foreach my $fkdef (@$fks) {
for my $col (@{ $fkdef->{local_columns} }) {
$col_info->{$col}{is_foreign_key} = 1;
}
}
+
+ my $pks = $self->_table_pk_info($table) || [];
+
+ foreach my $pkcol (@$pks) {
+ $col_info->{$pkcol}{is_nullable} = 0;
+ }
+
$self->_dbic_stmt(
$table_class,
'add_columns',
my %uniq_tag; # used to eliminate duplicate uniqs
- my $pks = $self->_table_pk_info($table) || [];
@$pks ? $self->_dbic_stmt($table_class,'set_primary_key',@$pks)
: carp("$table has no primary key");
$uniq_tag{ join("\0", @$pks) }++ if @$pks; # pk is a uniq
return join '', map ucfirst, split /\W+/, $inflected;
}
- my @words = map lc, split /(?<=[[:lower:]])[\W_]*(?=[[:upper:]])|[\W_]+/, $table;
+ my @words = map lc, split_name $table;
my $as_phrase = join ' ', @words;
my $inflected = Lingua::EN::Inflect::Phrase::to_S($as_phrase);
my ($table) = @_;
my $pcm = $self->pod_comment_mode;
my ($comment, $comment_overflows, $comment_in_name, $comment_in_desc);
- if ( $self->can('_table_comment') ) {
- $comment = $self->_table_comment($table);
- $comment_overflows = ($comment and length $comment > $self->pod_comment_spillover_length);
- $comment_in_name = ($pcm eq 'name' or ($pcm eq 'auto' and !$comment_overflows));
- $comment_in_desc = ($pcm eq 'description' or ($pcm eq 'auto' and $comment_overflows));
- }
+ $comment = $self->__table_comment($table);
+ $comment_overflows = ($comment and length $comment > $self->pod_comment_spillover_length);
+ $comment_in_name = ($pcm eq 'name' or ($pcm eq 'auto' and !$comment_overflows));
+ $comment_in_desc = ($pcm eq 'description' or ($pcm eq 'auto' and $comment_overflows));
$self->_pod( $class, "=head1 NAME" );
my $table_descr = $class;
$table_descr .= " - " . $comment if $comment and $comment_in_name;
$s = !defined $s ? 'undef' :
length($s) == 0 ? '(empty string)' :
ref($s) eq 'SCALAR' ? $$s :
- ref($s) ? do {
- my $dd = Dumper;
- $dd->Indent(0);
- $dd->Values([$s]);
- $dd->Dump;
- } :
+ ref($s) ? dumper_squashed $s :
looks_like_number($s) ? $s :
qq{'$s'}
;
} sort keys %$attrs,
);
- if( $self->can('_column_comment')
- and my $comment = $self->_column_comment( $self->{_class2table}{$class}, $col_counter)
- ) {
+ if (my $comment = $self->__column_comment($self->{_class2table}{$class}, $col_counter)) {
$self->_pod( $class, $comment );
}
}
}
}
+sub _filter_comment {
+ my ($self, $txt) = @_;
+
+ $txt = '' if not defined $txt;
+
+ $txt =~ s/(?:\015?\012|\015\012?)/\n/g;
+
+ return $txt;
+}
+
+sub __table_comment {
+ my $self = shift;
+
+ if (my $code = $self->can('_table_comment')) {
+ return $self->_filter_comment($self->$code(@_));
+ }
+
+ return '';
+}
+
+sub __column_comment {
+ my $self = shift;
+
+ if (my $code = $self->can('_column_comment')) {
+ return $self->_filter_comment($self->$code(@_));
+ }
+
+ return '';
+}
+
# Stores a POD documentation
sub _pod {
my ($self, $class, $stmt) = @_;
return $qt . $table . $qt;
}
-sub _is_case_sensitive { 0 }
-
sub _custom_column_info {
my ( $self, $table_name, $column_name, $column_info ) = @_;
return $result;
}
+sub _lc {
+ my ($self, $name) = @_;
+
+ return $self->preserve_case ? $name : lc($name);
+}
+
+sub _uc {
+ my ($self, $name) = @_;
+
+ return $self->preserve_case ? $name : uc($name);
+}
+
+sub _unregister_source_for_table {
+ my ($self, $table) = @_;
+
+ eval {
+ local $@;
+ my $schema = $self->schema;
+ # in older DBIC it's a private method
+ my $unregister = $schema->can('unregister_source') || $schema->can('_unregister_source');
+ $schema->$unregister($self->_table2moniker($table));
+ delete $self->monikers->{$table};
+ delete $self->classes->{$table};
+ delete $self->_upgrading_classes->{$table};
+ delete $self->{_tables}{$table};
+ };
+}
+
# remove the dump dir from @INC on destruction
sub DESTROY {
my $self = shift;