X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FCatalyst%2FModel%2FDBIC%2FSchema.pm;h=6c1c67a1e79a36de23444c2d8956d5725c703e72;hb=788c27bea203bf41a44c35c7b2d584b27d86b199;hp=dc4dc2ee93021a1c359fecea1f959b0d528df2a8;hpb=6dec11b72b27109b91fbdb4932e5f10bec183e6c;p=catagits%2FCatalyst-Model-DBIC-Schema.git diff --git a/lib/Catalyst/Model/DBIC/Schema.pm b/lib/Catalyst/Model/DBIC/Schema.pm index dc4dc2e..6c1c67a 100644 --- a/lib/Catalyst/Model/DBIC/Schema.pm +++ b/lib/Catalyst/Model/DBIC/Schema.pm @@ -1,19 +1,22 @@ package Catalyst::Model::DBIC::Schema; -use strict; -use warnings; +use Moose; +use mro 'c3'; +extends 'Catalyst::Model'; +with 'CatalystX::Component::Traits'; -our $VERSION = '0.22'; +our $VERSION = '0.28'; +$VERSION = eval $VERSION; -use base qw/Catalyst::Model Class::Accessor::Fast Class::Data::Accessor/; -use NEXT; -use UNIVERSAL::require; -use Carp; +use namespace::autoclean; +use Carp::Clan '^Catalyst::Model::DBIC::Schema'; use Data::Dumper; -require DBIx::Class; +use DBIx::Class (); -__PACKAGE__->mk_classaccessor('composed_schema'); -__PACKAGE__->mk_accessors('schema'); +use Catalyst::Model::DBIC::Schema::Types + qw/ConnectInfo LoadedClass/; + +use MooseX::Types::Moose qw/ArrayRef Str ClassName Undef/; =head1 NAME @@ -70,12 +73,11 @@ MyApp/Model/FilmDB.pm: __PACKAGE__->config( schema_class => 'MyApp::Schema::FilmDB', - connect_info => [ - "DBI:...", - "username", - "password", - {AutoCommit => 1} - ] + connect_info => { + dsn => "DBI:...", + user => "username", + password => "password", + } ); See below for a full list of the possible config parameters. @@ -88,19 +90,34 @@ be used/accessed in the normal Catalyst manner, via $c->model(): my $actor = $c->model('FilmDB::Actor')->find(1); You can also use it to set up DBIC authentication with -Authentication::Store::DBIC in MyApp.pm: +L in MyApp.pm: package MyApp; - use Catalyst qw/... Authentication::Store::DBIC/; + use Catalyst qw/... Authentication .../; ... - __PACKAGE__->config->{authentication}{dbic} = { - user_class => 'FilmDB::Actor', - user_field => 'name', - password_field => 'password' - } + __PACKAGE__->config->{authentication} = + { + default_realm => 'members', + realms => { + members => { + credential => { + class => 'Password', + password_field => 'password', + password_type => 'hashed' + password_hash_type => 'SHA-256' + }, + store => { + class => 'DBIx::Class', + user_model => 'DB::User', + role_relation => 'roles', + role_field => 'rolename', + } + } + } + }; C<< $c->model('Schema::Source') >> returns a L for the source name parameter passed. To find out more about which methods can @@ -182,15 +199,15 @@ for more info. =head1 CONFIG PARAMETERS -=over 4 +Any options in your config not listed here are passed to your schema. -=item schema_class +=head2 schema_class This is the classname of your L Schema. It needs to be findable in C<@INC>, but it does not need to be inside the C namespace. This parameter is required. -=item connect_info +=head2 connect_info This is an arrayref of connection parameters, which are specific to your C (see your storage type documentation for more details). @@ -209,42 +226,45 @@ of the arguments supported. Examples: - connect_info => [ 'dbi:Pg:dbname=mypgdb', 'postgres', '' ], + connect_info => { + dsn => 'dbi:Pg:dbname=mypgdb', + user => 'postgres', + password => '' + } - connect_info => [ - 'dbi:SQLite:dbname=foo.db', - { - on_connect_do => [ - 'PRAGMA synchronous = OFF', - ], - } - ], + connect_info => { + dsn => 'dbi:SQLite:dbname=foo.db', + on_connect_do => [ + 'PRAGMA synchronous = OFF', + ] + } - connect_info => [ - 'dbi:Pg:dbname=mypgdb', - 'postgres', - '', - { AutoCommit => 0 }, - { - on_connect_do => [ - 'some SQL statement', - 'another SQL statement', - ], - } - ], + connect_info => { + dsn => 'dbi:Pg:dbname=mypgdb', + user => 'postgres', + password => '', + pg_enable_utf8 => 1, + on_connect_do => [ + 'some SQL statement', + 'another SQL statement', + ], + } Or using L: schema_class MyApp::Schema::FilmDB - connect_info dbi:Pg:dbname=mypgdb - connect_info postgres - connect_info + traits Caching - AutoCommit 0 + dsn dbi:Pg:dbname=mypgdb + user postgres + password "" + auto_savepoint 1 + quote_char """ on_connect_do some SQL statement on_connect_do another SQL statement + user_defined_schema_accessor foo or @@ -254,125 +274,371 @@ or connect_info dbi:SQLite:dbname=foo.db +Or using L: + + Model::MyDB: + schema_class: MyDB + traits: Caching + connect_info: + dsn: dbi:Oracle:mydb + user: mtfnpy + password: mypass + LongReadLen: 1000000 + LongTruncOk: 1 + on_connect_call: 'datetime_setup' + quote_char: '"' + +The old arrayref style with hashrefs for L then L options is also +supported: + + connect_info => [ + 'dbi:Pg:dbname=mypgdb', + 'postgres', + '', + { + pg_enable_utf8 => 1, + }, + { + auto_savepoint => 1, + on_connect_do => [ + 'some SQL statement', + 'another SQL statement', + ], + } + ] + +=head2 traits + +Array of Traits to apply to the instance. Traits are Ls. + +They are relative to the C<< MyApp::TraitFor::Model::DBIC::Schema:: >>, then the C<< +Catalyst::TraitFor::Model::DBIC::Schema:: >> namespaces, unless prefixed with C<+> +in which case they are taken to be a fully qualified name. E.g.: + + traits Caching + traits +MyApp::TraitFor::Model::Foo + +A new instance is created at application time, so any consumed required +attributes, coercions and modifiers will work. + +Traits are applied at L time using +L. + +C will be an anon class if any traits are applied, C<< +$self->_original_class_name >> will be the original class. + +When writing a Trait, interesting points to modify are C, L and +L. + +Traits that come with the distribution: + +=over 4 + +=item L + +=item L + +=back -=item storage_type +=head2 storage_type Allows the use of a different C than what is set in your C (which in turn defaults to C<::DBI> if not set in current L). Completely optional, and probably unnecessary for most people until other storage backends become available for L. -=back +=head1 ATTRIBUTES + +The keys you pass in the model configuration are available as attributes. + +Other attributes available: + +=head2 connect_info + +Your connect_info args normalized to hashref form (with dsn/user/password.) See +L for more info on the hashref form of +L. + +=head2 model_name + +The model name L uses to resolve this model, the part after +C<::Model::> or C<::M::> in your class name. E.g. if your class name is +C the L will be C. + +=head2 _default_cursor_class + +What to reset your L to if a custom one +doesn't work out. Defaults to L. + +=head1 ATTRIBUTES FROM L + +=head2 _original_class_name + +The class name of your model before any L are applied. E.g. +C. + +=head2 _traits + +Unresolved arrayref of traits passed in the config. + +=head2 _resolved_traits + +Traits you used resolved to full class names. =head1 METHODS -=over 4 +Methods not listed here are delegated to the connected schema used by the model +instance, so the following are equivalent: + + $c->model('DB')->schema->my_accessor('foo'); + # or + $c->model('DB')->my_accessor('foo'); -=item new +Methods on the model take precedence over schema methods. + +=head2 new Instantiates the Model based on the above-documented ->config parameters. The only required parameter is C. C is required in the case that C does not already have connection information defined for it. -=item schema +=head2 schema Accessor which returns the connected schema being used by the this model. There are direct shortcuts on the model class itself for schema->resultset, schema->source, and schema->class. -=item composed_schema +=head2 composed_schema Accessor which returns the composed schema, which has no connection info, which was used in constructing the C above. Useful for creating new connections based on the same schema/model. There are direct shortcuts from the model object for composed_schema->clone and composed_schema->connect -=item clone +=head2 clone Shortcut for ->composed_schema->clone -=item connect +=head2 connect Shortcut for ->composed_schema->connect -=item source +=head2 source Shortcut for ->schema->source -=item class +=head2 class Shortcut for ->schema->class -=item resultset +=head2 resultset Shortcut for ->schema->resultset -=item storage +=head2 storage Provides an accessor for the connected schema's storage object. Used often for debugging and controlling transactions. -=back - =cut -sub new { - my $self = shift->NEXT::new(@_); - - my $class = ref($self); - my $model_name = $class; - $model_name =~ s/^[\w:]+::(?:Model|M):://; - - croak "->config->{schema_class} must be defined for this model" - unless $self->{schema_class}; - - my $schema_class = $self->{schema_class}; - - $schema_class->require - or croak "Cannot load schema class '$schema_class': $@"; - - if( !$self->{connect_info} ) { +has schema_class => ( + is => 'ro', + isa => LoadedClass, + coerce => 1, + required => 1 +); + +has storage_type => (is => 'rw', isa => Str); + +has connect_info => (is => 'rw', isa => ConnectInfo, coerce => 1); + +has model_name => ( + is => 'ro', + isa => Str, + required => 1, + lazy_build => 1, +); + +has _default_cursor_class => ( + is => 'ro', + isa => LoadedClass, + default => 'DBIx::Class::Storage::DBI::Cursor', + coerce => 1 +); + +sub BUILD { + my ($self, $args) = @_; + my $class = $self->_original_class_name; + my $schema_class = $self->schema_class; + + if( !$self->connect_info ) { if($schema_class->storage && $schema_class->storage->connect_info) { - $self->{connect_info} = $schema_class->storage->connect_info; + $self->connect_info($schema_class->storage->connect_info); } else { - croak "Either ->config->{connect_info} must be defined for $class" + die "Either ->config->{connect_info} must be defined for $class" . " or $schema_class must have connect info defined on it." . " Here's what we got:\n" . Dumper($self); } } + if (exists $self->connect_info->{cursor_class}) { + eval { Class::MOP::load_class($self->connect_info->{cursor_class}) } + or croak "invalid connect_info: Cannot load your cursor_class" + . " ".$self->connect_info->{cursor_class}.": $@"; + } + + $self->setup; + $self->composed_schema($schema_class->compose_namespace($class)); + + $self->meta->make_mutable; + $self->meta->add_attribute('schema', + is => 'rw', + isa => 'DBIx::Class::Schema', + handles => $self->_delegates + ); + $self->meta->make_immutable; + $self->schema($self->composed_schema->clone); - $self->schema->storage_type($self->{storage_type}) - if $self->{storage_type}; + $self->_pass_options_to_schema($args); + + $self->schema->storage_type($self->storage_type) + if $self->storage_type; + + $self->schema->connection($self->connect_info); + + $self->_install_rs_models; +} + +sub clone { shift->composed_schema->clone(@_); } + +sub connect { shift->composed_schema->connect(@_); } + +=head2 setup + +Called at C time before configuration, but after L is +set. To do something after configuuration use C<< after BUILD => >>. + +=cut + +sub setup { 1 } + +=head2 ACCEPT_CONTEXT + +Point of extension for doing things at C<< $c->model >> time with context, +returns the model instance, see L for +more information. + +=cut + +sub ACCEPT_CONTEXT { shift } + +sub _install_rs_models { + my $self = shift; + my $class = $self->_original_class_name; - $self->schema->connection( - ref $self->{connect_info} eq 'ARRAY' ? - @{$self->{connect_info}} : - $self->{connect_info} - ); - no strict 'refs'; - foreach my $moniker ($self->schema->sources) { + + my @sources = $self->schema->sources; + + die "No sources found (did you forget to define your tables?)" + unless @sources; + + foreach my $moniker (@sources) { my $classname = "${class}::$moniker"; *{"${classname}::ACCEPT_CONTEXT"} = sub { shift; - shift->model($model_name)->resultset($moniker); + shift->model($self->model_name)->resultset($moniker); } } +} + +sub _reset_cursor_class { + my $self = shift; - return $self; + if ($self->storage->can('cursor_class')) { + $self->storage->cursor_class($self->_default_cursor_class) + if $self->storage->cursor_class ne $self->_default_cursor_class; + } } -sub clone { shift->composed_schema->clone(@_); } +{ + my %COMPOSED_CACHE; -sub connect { shift->composed_schema->connect(@_); } + sub composed_schema { + my $self = shift; + my $class = $self->_original_class_name; + my $store = \$COMPOSED_CACHE{$class}{$self->schema_class}; -sub storage { shift->schema->storage(@_); } + $$store = shift if @_; + + return $$store + } +} + +sub _build_model_name { + my $self = shift; + my $class = $self->_original_class_name; + (my $model_name = $class) =~ s/^[\w:]+::(?:Model|M):://; + + return $model_name; +} + +sub _delegates { + my $self = shift; + + my $schema_meta = Class::MOP::Class->initialize($self->schema_class); + my @schema_methods = $schema_meta->get_all_method_names; + +# combine with any already added by other schemas + my @handles = eval { + @{ $self->meta->find_attribute_by_name('schema')->handles } + }; + +# now kill the attribute, otherwise add_attribute in BUILD will not do the right +# thing (it clears the handles for some reason.) May be a Moose bug. + eval { $self->meta->remove_attribute('schema') }; + + my %schema_methods; + @schema_methods{ @schema_methods, @handles } = (); + @schema_methods = keys %schema_methods; + + my @my_methods = $self->meta->get_all_method_names; + my %my_methods; + @my_methods{@my_methods} = (); + + my @delegates; + for my $method (@schema_methods) { + push @delegates, $method unless exists $my_methods{$method}; + } + + return \@delegates; +} + +sub _pass_options_to_schema { + my ($self, $args) = @_; + + my @attributes = map { + $_->init_arg || () + } $self->meta->get_all_attributes; + + my %attributes; + @attributes{@attributes} = (); + + for my $opt (keys %$args) { + if (not exists $attributes{$opt}) { + next unless $self->schema->can($opt); + $self->schema->$opt($self->{$opt}); + } + } +} + +__PACKAGE__->meta->make_immutable; =head1 SEE ALSO @@ -384,17 +650,30 @@ L, L, L, Stuff related to DBIC and this Model style: L, L, -L, L +L, L, +L, L + +Traits: + +L, +L =head1 AUTHOR -Brandon L Black, C +Brandon L Black C + +=head1 CONTRIBUTORS + +caelum: Rafael Kitover C + +Dan Dascalescu C =head1 COPYRIGHT -This program is free software, you can redistribute it and/or modify it +This program is free software. You can redistribute it and/or modify it under the same terms as Perl itself. =cut 1; +# vim:sts=4 sw=4 et: