X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FSchema%2FLoader%2FBase.pm;h=eddf6f38233591e7b6d715e9319689032aa3b511;hb=846901b7d8b638e6f900aaf62bcbd207466025b3;hp=3ff501a714387b171ae79b07e21a0534193fb94b;hpb=ca1389c8998c1646875df6f64494f5ff49153420;p=dbsrgits%2FDBIx-Class-Schema-Loader.git diff --git a/lib/DBIx/Class/Schema/Loader/Base.pm b/lib/DBIx/Class/Schema/Loader/Base.pm index 3ff501a..eddf6f3 100644 --- a/lib/DBIx/Class/Schema/Loader/Base.pm +++ b/lib/DBIx/Class/Schema/Loader/Base.pm @@ -30,7 +30,7 @@ use List::Util qw/all any none/; use File::Temp 'tempfile'; use namespace::clean; -our $VERSION = '0.07046'; +our $VERSION = '0.07047'; __PACKAGE__->mk_group_ro_accessors('simple', qw/ schema @@ -60,6 +60,7 @@ __PACKAGE__->mk_group_ro_accessors('simple', qw/ result_base_class result_roles use_moose + use_moo only_autoclean overwrite_modifications dry_run @@ -412,15 +413,15 @@ L relationships, they default to off. Can also be a coderef, for more precise control, in which case the coderef gets -this hash of parameters (as a list:) +this hash of parameters (as a list): rel_name # the name of the relationship rel_type # the type of the relationship: 'belongs_to', 'has_many' or 'might_have' local_source # the DBIx::Class::ResultSource object for the source the rel is *from* remote_source # the DBIx::Class::ResultSource object for the source the rel is *to* - local_table # a DBIx::Class::Schema::Loader::Table object for the table of the source the rel is from + local_table # the DBIx::Class::Schema::Loader::Table object for the table of the source the rel is from local_cols # an arrayref of column names of columns used in the rel in the source it is from - remote_table # a DBIx::Class::Schema::Loader::Table object for the table of the source the rel is to + remote_table # the DBIx::Class::Schema::Loader::Table object for the table of the source the rel is to remote_cols # an arrayref of column names of columns used in the rel in the source it is to attrs # the attributes that would be set @@ -613,14 +614,27 @@ a hashref of unqualified table name keys and moniker values =item * -a coderef for a translator function taking a L argument (which stringifies to the -unqualified table name) and returning a scalar moniker +a coderef that returns the moniker, which is called with the following +arguments: -The function is also passed a coderef that can be called with either -of the hashref forms to get the moniker mapped accordingly. This is -useful if you need to handle some monikers specially, but want to use -the hashref form for the rest. +=over + +=item * + +the L object for the table + +=item * + +the default moniker that DBIC would ordinarily give this table + +=item * + +a coderef that can be called with either of the hashref forms to get +the moniker mapped accordingly. This is useful if you need to handle +some monikers specially, but want to use the hashref form for the +rest. + +=back =back @@ -643,7 +657,7 @@ together. Examples: Map for overriding the monikerization of individual L. The keys are the moniker part to override, the value is either a -hashref of coderef for mapping the corresponding part of the +hashref or coderef for mapping the corresponding part of the moniker. If a coderef is used, it gets called with the moniker part and the hash key the code ref was found under. @@ -664,23 +678,36 @@ L takes precedence over this. Same as moniker_map, but for column accessor names. The nested hashref form is traversed according to L, with an extra level at the bottom for the column name. If a coderef is -passed, the code is called with arguments of +passed, the code is called with the following arguments: + +=over + +=item * + +the L object for the column + +=item * + +the default accessor name that DBICSL would ordinarily give this column + +=item * + +a hashref of this form: - the DBIx::Class::Schema::Loader::Column object for the column, - 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 => table object of interface DBIx::Class::Schema::Loader::Table, + table => the DBIx::Class::Schema::Loader::Table object for the 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), } - coderef ref that can be called with a hashref map -The L and -L objects stringify to their -unqualified names. +=item * + +a coderef that can be called with a hashref map + +=back =head2 rel_name_map @@ -716,9 +743,9 @@ If it is a coderef, it will be passed a hashref of this form: remote_moniker => moniker of the DBIC class we are related to, remote_columns => columns in the other table in the relationship, # for type => "many_to_many" only: - link_class => name of the DBIC class for the link table - link_moniker => moniker of the DBIC class for the link table - link_rel_name => name of the relationship to the link table + link_class => name of the DBIC class for the link table, + link_moniker => moniker of the DBIC class for the link table, + link_rel_name => name of the relationship to the link table, } In addition it is passed a coderef that can be called with a hashref map. @@ -885,8 +912,8 @@ L for a column. Must be a coderef that returns a hashref with the extra attributes. -Receives the L
(which -stringifies to the unqualified table name), column name and column_info. +Receives the L object, column name +and column_info. For example: @@ -954,6 +981,13 @@ content after the md5 sum also makes the classes immutable. It is safe to upgrade your existing Schema to this option. +=head2 use_moo + +Creates Schema and Result classes that use L and +L. + +It is safe to upgrade your existing Schema to this option. + =head2 only_autoclean By default, we use L to remove imported functions from @@ -1108,8 +1142,11 @@ sub new { $self->result_roles_map($self->{result_role_map}) } - croak "the result_roles and result_roles_map options may only be used in conjunction with use_moose=1" - if ((not defined $self->use_moose) || (not $self->use_moose)) + croak "Specify only one of use_moose or use_moo" + if $self->use_moose and $self->use_moo; + + croak "the result_roles and result_roles_map options may only be used in conjunction with use_moose=1 or use_moo=1" + if ((not $self->use_moose) && (not $self->use_moo)) && ((defined $self->result_roles) || (defined $self->result_roles_map)); $self->_ensure_arrayref(qw/schema_components @@ -1153,10 +1190,12 @@ sub new { } $self->_validate_result_roles_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", - DBIx::Class::Schema::Loader::Optional::Dependencies->req_missing_for('use_moose'); + for my $use_oo (qw(use_moose use_moo)) { + if ($self->$use_oo) { + if (not DBIx::Class::Schema::Loader::Optional::Dependencies->req_ok_for($use_oo)) { + die sprintf "You must install the following CPAN modules to enable the $use_oo option: %s.\n", + DBIx::Class::Schema::Loader::Optional::Dependencies->req_missing_for($use_oo); + } } } @@ -1363,9 +1402,12 @@ EOF return unless $old_ver; - # determine if the existing schema was dumped with use_moose => 1 - if (! defined $self->use_moose) { - $self->{use_moose} = 1 if $old_gen =~ /^ (?!\s*\#) use \s+ Moose/xm; + # determine if the existing schema was dumped with use_moo(se) => 1 + for my $oo (qw(Moose Moo)) { + my $use_oo = "use_".lc($oo); + if (! defined $self->$use_oo) { + $self->{$use_oo} = 1 if $old_gen =~ /^ (?!\s*\#) use \s+ \Q$oo\E\b/xm; + } } my $load_classes = ($old_gen =~ /^__PACKAGE__->load_classes;/m) ? 1 : 0; @@ -1966,9 +2008,11 @@ sub _dump_to_dir { ; if ($self->use_moose) { - $schema_text.= qq|use Moose;\nuse $autoclean;\nextends '$schema_base_class';\n\n|; } + elsif ($self->use_moo) { + $schema_text .= qq|use Moo;\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|; } @@ -2025,8 +2069,11 @@ sub _dump_to_dir { $src_text .= $self->_base_class_pod($result_base_class) unless $result_base_class eq 'DBIx::Class::Core'; - if ($self->use_moose) { - $src_text.= qq|use Moose;\nuse MooseX::NonMoose;\nuse $autoclean;|; + if ($self->use_moose || $self->use_moo) { + $src_text.= $self->use_moose + ? qq|use Moose;\nuse MooseX::NonMoose;\nuse $autoclean;| + : qq|use Moo;\nuse namespace::autoclean;| + ; # these options 'use base' which is compile time if (@{ $self->left_base_classes } || @{ $self->additional_base_classes }) { @@ -2449,6 +2496,7 @@ sub _is_result_class_method { for my $class ( $base, @components, @roles, ($self->use_moose ? 'Moose::Object' : ()), + ($self->use_moo ? 'Moo::Object' : ()), ) { $self->ensure_class_loaded($class); @@ -2879,7 +2927,8 @@ sub _load_roles { if exists $self->result_roles_map->{$table_moniker}; if (@roles) { - $self->_pod_class_list($table_class, 'L ROLES APPLIED', @roles); + my $class = $self->use_moose ? 'Moose' : 'Moo'; + $self->_pod_class_list($table_class, "L<$class> ROLES APPLIED", @roles); $self->_with($table_class, @roles); }