view release on metacpan or  search on metacpan

lib/Template/Plugin/Qgoda.pm  view on Meta::CPAN

                $b =~ s/(["&])/&$escapes{$1};/og;
                $a, qq{"$b"}
            } %{$_[0]}
        };
    };

    $context->define_vmethod(list => sortBy => $sort_by);
    $context->define_vmethod(list => nsortBy => $nsort_by);
    $context->define_vmethod(list => vmap => $vmap);
    $context->define_vmethod(scalar => slugify => \&Qgoda::Util::slugify);
    $context->define_vmethod(scalar => unmarkup => \&Qgoda::Util::unmarkup);
    $context->define_vmethod(hash => kebapSnake => $kebap_snake);
    $context->define_vmethod(hash => kebapCamel => $kebap_camel);
    $context->define_vmethod(hash => quoteValues => $quote_values);
	$context->define_vmethod(hash => vmap => $vmap);

    my $self = {
        __context => $context
    };
    bless $self, $class;
}

sub __getContext {
    shift->{__context};
}

sub __getStash {
    shift->{__context}->stash;
}

sub __getAsset {
    shift->{__context}->stash->{asset};
}

sub __getConfig {
    shift->{__context}->stash->{config};
}

sub bust_cache {
    my ($self, $uri) = @_;

    return $uri if $uri !~ m{^/};

    my($scheme, $authority, $path, $query, $fragment) =
        $uri =~ m|(?:([^:/?#]+):)?(?://([^/?#]*))?([^?#]*)(?:\?([^#]*))?(?:#(.*))?|o;
    return if !defined $path;

    require Qgoda;
    my $srcdir = Qgoda->new->config->{srcdir};
    my $fullpath = File::Spec->canonpath(File::Spec->catfile($srcdir, $path));

    my @stat = stat $fullpath or return $uri;
    if (defined $query) {
        return "$uri&$stat[9]"
    } else {
        return "$uri?$stat[9]"
    }
}

sub include {
    my ($self, $path, $overlay, $extra) = @_;

    die "usage: include(PATH, OVERLAY, KEY = VALUE, ...\n"
        if empty $path || empty $overlay;
    $overlay = $self->__sanitizeHashref($overlay, 'include');
    $extra = $self->__sanitizeHashref($extra, 'include', 1);

    my $asset = $self->__include($path, $overlay, $extra);

    return $asset->{content};
}

sub __include {
    my ($self, $_path, $overlay, $extra) = @_;

    require Qgoda;
    my $q = Qgoda->new;
    my $srcdir = $q->config->{srcdir};

    my $path = Cwd::abs_path($_path);
    if (!defined $path) {
        die __x("error including '{path}': {error}.\n",
                path => $_path, error => $!);
    }

    my $relpath = File::Spec->abs2rel($path, $srcdir);
    my $asset = Qgoda::Asset->new($path, $relpath);

    if ($overlay) {
        my %overlay = %$overlay;
        delete $overlay{path};
        delete $overlay{relpath};
        delete $overlay{reldir};
        delete $overlay{view};
        delete $overlay{chain};
        delete $overlay{wrapper};
        merge_data $asset, \%overlay;
    }

    $q->analyzeAssets([$asset], $extra);
    $q->locateAsset($asset);

    my $builders = $q->getBuilders;
    my $site = $q->getSite;
    foreach my $builder (@{$builders}) {
        $builder->processAsset($asset, $site);
        $builder->wrapAsset($asset, $site);
    }

    return $asset;
}

sub __sanitizeFilters {
    my ($self, $filters) = @_;

    return {} if empty $filters;
    if (!ref $filters) {
        die __x("invalid filters '{filters}' (use named arguments!)\n",
                filters => $filters);
    }

    my $reftype = reftype $filters;
    if ('ARRAY' eq $reftype) {
        my $json = encode_json($filters);
        $json =~ s{.(.*).}{$1};
        die __x("invalid filters '{filters}' (use named arguments!)\n",
                 filters => $json);
    } elsif ('HASH' ne $reftype) {
        die __x("invalid filters '{filters}' (use named arguments!)\n",
                 filters => $filters);
    }

    # The caller may want to add default filters.  Make sure that the original
    # reference is kept untouched.
    return {%$filters};
}

sub __sanitizeHashref {
    my ($self, $hashref, $method, $optional) = @_;

    if (empty $hashref) {
        if ($optional) {
            return {};
        } else {
            die __x("named arguments for '{method}()' are mandatory\n",
                    method => $method);
        }
    }

    if (!ref $hashref) {
        die __x("method '{method}' requires named arguments, not '{args}'",
                method => $method, args => $hashref);
    }

    my $reftype = reftype $hashref;
    if ('ARRAY' eq $reftype) {
        my $json = encode_json($hashref);

lib/Template/Plugin/Qgoda.pm  view on Meta::CPAN

    my ($self, @args) = @_;

    local $SIG{__WARN__} = sub {};

    return $self->lxref(@args);
}

sub anchor {
    my ($self, $filters) = @_;

    my $href = escape_link $self->link($filters);
    my $title = html_escape $self->xref(title => $filters);

    return qq{<a href="$href">$title</a>};
}

sub lanchor {
    my ($self, $filters) = @_;

    my $href = escape_link $self->llink($filters);
    my $title = html_escape $self->lxref(title => $filters);

    return qq{<a href="$href">$title</a>};
}

sub linkPost {
    my ($self, $filters) = @_;

    $filters = $self->__sanitizeFilters($filters);
    $filters->{type} = 'post';

    return $self->link($filters);
}

sub existsLinkPost {
    my ($self, @args) = @_;

    local $SIG{__WARN__} = sub {};

    return $self->linkPost(@args);
}

sub llinkPost {
    my ($self, $filters) = @_;

    $filters = $self->__sanitizeFilters($filters);
    $filters->{lingua} = $self->__getAsset->{lingua};

    return $self->linkPost($filters);
}

sub lexistsLinkPost {
    my ($self, @args) = @_;

    local $SIG{__WARN__} = sub {};

    return $self->llinkPost(@args);
}

sub writeAsset {
    my ($self, $path, $overlay, $extra) = @_;

    die "usage: writeAsset(PATH, OVERLAY, KEY = VALUE, ...\n"
        if empty $path || empty $overlay;
    $overlay = $self->__sanitizeHashref($overlay, 'include');
    $extra = $self->__sanitizeHashref($extra, 'include', 1);

    my $asset = $self->__include($path, $overlay, $extra);

    my $q = Qgoda->new;
    my $logger = $q->logger('template');
    my $builder = Qgoda::Builder->new;
    my $site = $q->getSite;

    $builder->saveArtefact($asset, $site, $asset->{location});
    $logger->debug(__x("successfully built '{location}'",
                       location => $asset->{location}));

    return '';
}

sub clone {
    my ($self, $extra) = @_;

    $extra = $self->__sanitizeHashref($extra, 'clone', 1);
    die __"the argument 'location' is mandatory for clone()\n"
        if empty $extra->{location};

    my $asset = $self->__getAsset;
    my $parent = $asset->{parent} ? $asset->{parent} : {
        location => $asset->{location},
    };

    # Force these values.
    $extra->{relpath} = $asset->getRelpath;
    $extra->{path} = $asset->getPath;
    $extra->{parent} = $parent;
    return $self->writeAsset($asset->getRelpath, $asset, $extra);
}

sub strftime {
    my ($self, $format, $date, $lingua, $markup) = @_;

    my $time = $date =~ /^[-+]?[1-9][0-9]*$/ ? "$date" : str2time $date;
    $time = $date if !defined $time;

    $format = '%c' if empty $format;

    my $saved_locale;    
    if (!empty $lingua) {
        $saved_locale = POSIX::setlocale(LC_ALL);
        web_set_locale($lingua, 'utf-8');
    }

    $markup = "sup" if !defined $markup;
    my $formatted_date = qstrftime $format, $time, $lingua, $markup;

    POSIX::setlocale(LC_ALL, $saved_locale) if defined $saved_locale;

    Encode::_utf8_on($formatted_date);

    return $formatted_date;
}

sub try {
    require Carp;
    Carp::croak("q.try is now invalid");
}