DBIx-Mojo-Template

 view release on metacpan or  search on metacpan

lib/DBIx/Mojo/Model.pm  view on Meta::CPAN

package DBIx::Mojo::Model;
use Mojo::Base -base;
use Carp 'croak';
use DBIx::Mojo::Template;
use Hash::Merge qw( merge );
use Scalar::Util 'weaken';

my %DICT_CACHE = ();# для каждого пакета/модуля

has [qw(dbh dict)], undef, weak=>1;
has [qw(template_vars mt)];

has dbi_cache_st => 1; # 1 - use DBI caching and 0 overvise this module caching

has debug => $ENV{DEBUG_DBIx_Mojo_Model} || 0;
my $PKG = __PACKAGE__;

lib/DBIx/Mojo/Model.pm  view on Meta::CPAN

  state $singleton = shift->SUPER::new(@_);
}

# child model
sub new {
  my $self = ref $_[0] ? shift : shift->SUPER::new(@_);
  my $singleton = $self->singleton;
  
  $self->dbh($singleton->dbh)
    unless $self->dbh;
  #~ weaken $self->{dbh};
    
  $self->template_vars(merge($self->template_vars || {}, $singleton->template_vars))
    #~ and weaken $self->{template_vars}
    if $singleton->template_vars && %{$singleton->template_vars};
  
  $self->mt(merge($self->mt || {}, $singleton->mt))
    #~ and weaken $self->{mt}
    if $singleton->mt && %{$singleton->mt};
  
  my $class = ref $self;
  
  # pass extra class files (inside the class): our $DATA=['foo.txt', 'bar.txt'];
  my $data_files = do {   no strict 'refs'; ${"$class\::DATA"} };
  
  $self->dict( $DICT_CACHE{$class} ||= DBIx::Mojo::Template->new($class, mt => $self->mt, vars => $self->template_vars, $data_files ? (data => $data_files) : (), ) )
    unless $self->dict;
  #~ weaken $self->{dict};
  
  $self->debug
    && say STDERR "[DEBUG $PKG new] parsed dict keys [@{[keys %{$self->dict}]}] for class [$class]";
  
  $self;
}

sub sth {
  my $self = shift;
  my $name = shift;

lib/DBIx/Mojo/Template.pm  view on Meta::CPAN

package DBIx::Mojo::Template;
use Mojo::Base -base;
use Mojo::Loader qw(data_section);
use Mojo::Template;
use Mojo::URL;
use Mojo::Util qw(url_unescape b64_decode class_to_path);#
use Mojo::File;
use Scalar::Util 'weaken';

#~ has debug => $ENV{DEBUG_DBIx_Mojo_Template} || 0;
#~ my $pkg = __PACKAGE__;

sub new {
  my ($class) = shift;
  bless $class->data(@_);
}

sub singleton {

lib/DBIx/Mojo/Template.pm  view on Meta::CPAN

  #~ @$data{keys %$extra} = values %$extra
    #~ if ref($extra) eq 'HASH';
  #prio: near over far
  @$extra{keys %$data} = values %$data;
  
  while ( my ($k, $t) = each %$extra)  {
    my $url = Mojo::URL->new($k);
    my ($name, $param) = (url_unescape($url->path), $url->query->to_hash);
    utf8::decode($name);
    $dict->{$name} = DBIx::Mojo::Statement->new(dict=>$dict, name=>$name, raw=>$t, param=>$param, mt=>_mt(%{$arg{mt} || {}}), vars=>$arg{vars} || {});
    #~ weaken $dict->{$name}->{dict};
  }
  die "None DATA dict in package [$pkg]"
    unless %$dict;
  return $dict;
}

sub _mt {
  Mojo::Template->new(vars => 1, prepend=>'no strict qw(vars); no warnings qw(uninitialized);', @_);# line_start=>'$$',
}

lib/DBIx/Mojo/Template.pm  view on Meta::CPAN

  return $dict;
}

our $VERSION = '0.061';

#=============================================
package DBIx::Mojo::Statement;
#=============================================
use Mojo::Base -base;
use Hash::Merge qw(merge);
use Scalar::Util 'weaken';

has [qw(dict sth)], undef, weak=>1;
has [qw(name raw param mt vars )];

# sth - attr for save cached dbi statement

use overload '""' => sub { shift->raw };

sub template { shift->render(@_) }

sub render {
  my $self = shift;
  my $vars =ref $_[0] ? shift : { @_ };
  my $merge = merge($vars, $self->vars);
  $merge->{dict} ||= $self->dict;
  $merge->{DICT} = $self->dict;
  $merge->{st} = $self;
  weaken $merge->{st};
  
  $self->mt->render($self->raw, $merge);#%$vars ? %{$self->vars} ? merge($vars, $self->vars) : $vars : $self->vars
  
}

=pod

=encoding utf8

Доброго всем