default_resultset_class
schema_base_class
result_base_class
+ result_roles
use_moose
overwrite_modifications
col_collision_map
rel_collision_map
real_dump_directory
- result_component_map
+ result_components_map
+ result_roles_map
datetime_undef_if_invalid
_result_class_methods
/);
classes. A good example would be
L<InflateColumn::DateTime|DBIx::Class::InflateColumn::DateTime>
-=head2 result_component_map
+=head2 result_components_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:
+A hashref of moniker keys and component values. Unlike C<components>, which
+loads the given components into every Result class, this option allows you to
+load certain components for specified Result classes. For example:
- result_component_map => {
+ result_components_map => {
StationVisited => '+YourApp::Schema::Component::StationVisited',
RouteChange => [
'+YourApp::Schema::Component::RouteChange',
You may use this in conjunction with C<components>.
+=head2 result_roles
+
+List of L<Moose> roles to be applied to all of your Result classes.
+
+=head2 result_roles_map
+
+A hashref of moniker keys and role values. Unlike C<result_roles>, which
+applies the given roles to every Result class, this option allows you to apply
+certain roles for specified Result classes. For example:
+
+ result_roles_map => {
+ StationVisited => [
+ 'YourApp::Role::Building',
+ 'YourApp::Role::Destination',
+ ],
+ RouteChange => 'YourApp::Role::TripEvent',
+ }
+
+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
my @CLASS_ARGS = qw(
schema_base_class result_base_class additional_base_classes
- left_base_classes additional_classes components
+ left_base_classes additional_classes components result_roles
);
# ensure that a peice of object data is a valid arrayref, creating
}
}
+ $self->result_components_map($self->{result_component_map})
+ if defined $self->{result_component_map};
+
+ $self->result_roles_map($self->{result_role_map})
+ if defined $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))
+ && ((defined $self->result_roles) || (defined $self->result_roles_map));
+
$self->_ensure_arrayref(qw/additional_classes
additional_base_classes
left_base_classes
components
+ result_roles
/);
$self->_validate_class_args;
- if ($self->result_component_map) {
- my %rc_map = %{ $self->result_component_map };
+ croak "result_components_map must be a hash"
+ if defined $self->result_components_map
+ && ref $self->result_components_map ne 'HASH';
+
+ if ($self->result_components_map) {
+ my %rc_map = %{ $self->result_components_map };
foreach my $moniker (keys %rc_map) {
$rc_map{$moniker} = [ $rc_map{$moniker} ] unless ref $rc_map{$moniker};
}
- $self->result_component_map(\%rc_map);
+ $self->result_components_map(\%rc_map);
}
else {
- $self->result_component_map({});
+ $self->result_components_map({});
}
- $self->_validate_result_component_map;
+ $self->_validate_result_components_map;
+
+ croak "result_roles_map must be a hash"
+ if defined $self->result_roles_map
+ && ref $self->result_roles_map ne 'HASH';
+
+ if ($self->result_roles_map) {
+ my %rr_map = %{ $self->result_roles_map };
+ foreach my $moniker (keys %rr_map) {
+ $rr_map{$moniker} = [ $rr_map{$moniker} ] unless ref $rr_map{$moniker};
+ }
+ $self->result_roles_map(\%rr_map);
+ } else {
+ $self->result_roles_map({});
+ }
+ $self->_validate_result_roles_map;
if ($self->use_moose) {
if (not DBIx::Class::Schema::Loader::Optional::Dependencies->req_ok_for('use_moose')) {
}
}
-sub _validate_result_component_map {
+sub _validate_result_components_map {
my $self = shift;
- my $map = $self->result_component_map;
- return unless $map && ref $map eq 'HASH';
+ foreach my $classes (values %{ $self->result_components_map }) {
+ $self->_validate_classes('result_components_map', $classes);
+ }
+}
+
+sub _validate_result_roles_map {
+ my $self = shift;
- foreach my $classes (values %$map) {
- $self->_validate_classes('result_component_map', [@$classes]);
+ foreach my $classes (values %{ $self->result_roles_map }) {
+ $self->_validate_classes('result_roles_map', $classes);
}
}
my $key = shift;
my $classes = shift;
- foreach my $c (@$classes) {
+ # make a copy to not destroy original
+ my @classes = @$classes;
+
+ 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/^\+// ) {
$self->_raw_stmt($target, "use base qw/$blist/;");
}
+sub _with {
+ my $self = shift;
+ my $target = shift;
+
+ my $rlist = join(q{, }, map { qq{'$_'} } @_);
+
+ return unless $rlist;
+
+ warn "$target: with $rlist;" if $self->debug;
+ $self->_raw_stmt($target, "\nwith $rlist;");
+}
+
sub _result_namespace {
my ($self, $schema_class, $ns) = @_;
my @result_namespace;
unless $table_class eq $old_class;
}
-# this was a bad idea, should be ok now without it
-# my $table_normalized = lc $table;
-# $self->classes->{$table_normalized} = $table_class;
-# $self->monikers->{$table_normalized} = $table_moniker;
-
- $self->classes->{$table} = $table_class;
+ $self->classes->{$table} = $table_class;
$self->monikers->{$table} = $table_moniker;
$self->_use ($table_class, @{$self->additional_classes});
my @components = @{ $self->components || [] };
- push @components, @{ $self->result_component_map->{$table_moniker} }
- if exists $self->result_component_map->{$table_moniker};
+ push @components, @{ $self->result_components_map->{$table_moniker} }
+ if exists $self->result_components_map->{$table_moniker};
$self->_dbic_stmt($table_class, 'load_components', @components) if @components;
$self->_inject($table_class, @{$self->additional_base_classes});
+
+ my @roles = @{ $self->result_roles || [] };
+ push @roles, @{ $self->result_roles_map->{$table_moniker} }
+ if exists $self->result_roles_map->{$table_moniker};
+
+ $self->_with($table_class, @roles) if @roles;
}
sub _is_result_class_method {
my $table_moniker = $table_name ? $self->_table2moniker($table_name) : '';
- if (not $self->_result_class_methods) {
+ $self->_result_class_methods({})
+ if not defined $self->_result_class_methods;
+
+ if (not exists $self->_result_class_methods->{$table_moniker}) {
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};
+ push @components, @{ $self->result_components_map->{$table_moniker} }
+ if exists $self->result_components_map->{$table_moniker};
for my $c (@components) {
$c = $c =~ /^\+/ ? substr($c,1) : "DBIx::Class::$c";
}
- for my $class ($base, @components, $self->use_moose ? 'Moose::Object' : ()) {
+ my @roles = @{ $self->result_roles || [] };
+
+ push @roles, @{ $self->result_roles_map->{$table_moniker} }
+ if exists $self->result_roles_map->{$table_moniker};
+
+ for my $class ($base, @components,
+ ($self->use_moose ? 'Moose::Object' : ()), @roles) {
$self->ensure_class_loaded($class);
push @methods, @{ Class::Inspector->methods($class) || [] };
@methods{@methods} = ();
- $self->_result_class_methods(\%methods);
+ $self->_result_class_methods->{$table_moniker} = \%methods;
}
- my $result_methods = $self->_result_class_methods;
+ my $result_methods = $self->_result_class_methods->{$table_moniker};
return exists $result_methods->{$name};
}
$num_rescans++ if $self->{vendor} eq 'Firebird';
plan tests => @connect_info *
- (194 + $num_rescans * $col_accessor_map_tests + $extra_count + ($self->{data_type_tests}{test_count} || 0));
+ (199 + $num_rescans * $col_accessor_map_tests + $extra_count + ($self->{data_type_tests}{test_count} || 0));
foreach my $info_idx (0..$#connect_info) {
my $info = $connect_info[$info_idx];
my $debug = ($self->{verbose} > 1) ? 1 : 0;
- if (
- $ENV{SCHEMA_LOADER_TESTS_USE_MOOSE}
- &&
- ! DBIx::Class::Schema::Loader::Optional::Dependencies->req_ok_for('use_moose')
- ) {
- die sprintf ("Missing dependencies for SCHEMA_LOADER_TESTS_USE_MOOSE: %s\n",
- DBIx::Class::Schema::Loader::Optional::Dependencies->req_missing_for('use_moose')
- );
+ if ($ENV{SCHEMA_LOADER_TESTS_USE_MOOSE}) {
+ if (not DBIx::Class::Schema::Loader::Optional::Dependencies->req_ok_for('use_moose')) {
+ die sprintf ("Missing dependencies for SCHEMA_LOADER_TESTS_USE_MOOSE: %s\n",
+ DBIx::Class::Schema::Loader::Optional::Dependencies->req_missing_for('use_moose'));
+ }
+
+ $self->{use_moose} = 1;
}
my %loader_opts = (
dump_directory => $DUMP_DIR,
datetime_timezone => 'Europe/Berlin',
datetime_locale => 'de_DE',
- use_moose => $ENV{SCHEMA_LOADER_TESTS_USE_MOOSE},
+ $self->{use_moose} ? (
+ use_moose => 1,
+ result_roles => 'TestRole',
+ result_roles_map => { LoaderTest2X => 'TestRoleForMap' },
+ ) : (),
col_collision_map => { '^(can)\z' => 'caught_collision_%s' },
rel_collision_map => { '^(set_primary_key)\z' => 'caught_rel_collision_%s' },
col_accessor_map => \&test_col_accessor_map,
- result_component_map => { LoaderTest2X => 'TestComponentForMap', LoaderTest1 => '+TestComponentForMapFQN' },
+ result_components_map => { LoaderTest2X => 'TestComponentForMap', LoaderTest1 => '+TestComponentForMapFQN' },
%{ $self->{loader_options} || {} },
);
isa_ok( $rsobj35, "DBIx::Class::ResultSet" );
my @columns_lt2 = $class2->columns;
- is_deeply( \@columns_lt2, [ qw/id dat dat2 set_primary_key can dbix_class_testcomponent testcomponent_fqn meta/ ], "Column Ordering" );
+ is_deeply( \@columns_lt2, [ qw/id dat dat2 set_primary_key can dbix_class_testcomponent dbix_class_testcomponentformap testcomponent_fqn meta test_role_method test_role_for_map_method/ ], "Column Ordering" );
is $class2->column_info('can')->{accessor}, 'caught_collision_can',
'accessor for column name that conflicts with a UNIVERSAL method renamed based on col_collision_map';
- is $class2->column_info('set_primary_key')->{accessor}, undef,
- 'accessor for column name that conflicts with a result base class method removed';
+ ok (exists $class2->column_info('set_primary_key')->{accessor}
+ && (not defined $class2->column_info('set_primary_key')->{accessor}),
+ 'accessor for column name that conflicts with a result base class method removed');
+
+ ok (exists $class2->column_info('dbix_class_testcomponent')->{accessor}
+ && (not defined $class2->column_info('dbix_class_testcomponent')->{accessor}),
+ 'accessor for column name that conflicts with a component class method removed');
- is $class2->column_info('dbix_class_testcomponent')->{accessor}, undef,
- 'accessor for column name that conflicts with a component class method removed';
+ ok (exists $class2->column_info('dbix_class_testcomponentformap')->{accessor}
+ && (not defined $class2->column_info('dbix_class_testcomponentformap')->{accessor}),
+ 'accessor for column name that conflicts with a component class method removed');
- is $class2->column_info('testcomponent_fqn')->{accessor}, undef,
- 'accessor for column name that conflicts with a fully qualified component class method removed';
+ ok (exists $class2->column_info('testcomponent_fqn')->{accessor}
+ && (not defined $class2->column_info('testcomponent_fqn')->{accessor}),
+ 'accessor for column name that conflicts with a fully qualified component class method removed');
- if ($conn->_loader->use_moose) {
- is $class2->column_info('meta')->{accessor}, undef,
- 'accessor for column name that conflicts with Moose removed';
+ if ($self->{use_moose}) {
+ ok (exists $class2->column_info('meta')->{accessor}
+ && (not defined $class2->column_info('meta')->{accessor}),
+ 'accessor for column name that conflicts with Moose removed');
+
+ ok (exists $class2->column_info('test_role_for_map_method')->{accessor}
+ && (not defined $class2->column_info('test_role_for_map_method')->{accessor}),
+ 'accessor for column name that conflicts with a Result role removed');
+
+ ok (exists $class2->column_info('test_role_method')->{accessor}
+ && (not defined $class2->column_info('test_role_method')->{accessor}),
+ 'accessor for column name that conflicts with a Result role removed');
}
else {
- pass "not removing 'meta' accessor with use_moose disabled";
+ ok ((not exists $class2->column_info('meta')->{accessor}),
+ "not removing 'meta' accessor with use_moose disabled");
+
+ ok ((not exists $class2->column_info('test_role_for_map_method')->{accessor}),
+ 'no role method conflicts with use_moose disabled');
+
+ ok ((not exists $class2->column_info('test_role_method')->{accessor}),
+ 'no role method conflicts with use_moose disabled');
}
my %uniq1 = $class1->unique_constraints;
'fully qualified component class from result_component_map not added to not mapped Result';
SKIP: {
+ skip 'not testing role methods with use_moose disabled', 2
+ unless $self->{use_moose};
+
+ is try { $class1->test_role_method }, 'test_role_method works',
+ 'role from result_roles applied';
+
+ is try { $class2->test_role_for_map_method },
+ 'test_role_for_map_method works',
+ 'role from result_roles_map applied';
+ }
+
+ SKIP: {
can_ok( $class1, 'loader_test1_classmeth' )
or skip "Pre-requisite test failed", 1;
is( $class1->loader_test1_classmeth, 'all is well', 'Class method' );
set_primary_key INTEGER $self->{null},
can INTEGER $self->{null},
dbix_class_testcomponent INTEGER $self->{null},
+ dbix_class_testcomponentformap INTEGER $self->{null},
testcomponent_fqn INTEGER $self->{null},
meta INTEGER $self->{null},
+ test_role_method INTEGER $self->{null},
+ test_role_for_map_method INTEGER $self->{null},
UNIQUE (dat2, dat)
) $self->{innodb}
},
projects / dbsrgits/DBIx-Class-Schema-Loader.git / commitdiff