view release on metacpan or  search on metacpan

lib/Class/DBI/ConceptSearch.pm  view on Meta::CPAN

			|| $class->_croak("$col is not a column of $class");
                push @cols, $y ? "$x$col$z" : $col;
		push @vals, $class->_deflated_column($column, $val);
	}

	my $frag = join " AND ",
		map defined($vals[$_]) ? "$cols[$_] $search_type ?" : "$cols[$_] IS NULL",
		0 .. $#cols;
	$frag .= " ORDER BY $search_opts->{order_by}"
		if $search_opts->{order_by};
	return $class->sth_to_objects($class->sql_Retrieve($frag),
		[ grep defined, @vals ]);
  };

  return 1;
}

lib/Class/DBI/ConceptSearch.pm  view on Meta::CPAN

              ? $source_match->$t_sourcefield->id
              : scalar($source_match->$t_sourcefield);

            warn $v if DEBUG;

            # this call is fragile, handle it with care
            #
            # it would add power to allow search_like, search_ilike, or fuzzy searches (eg soundex) here
            # but requires extension of the xml format and *a lot* more code
            my @u = $t_targetclass->search( $t_targetfield => $v );
            push @t, @u;

 view release on metacpan or  search on metacpan

lib/Class/DBI/Factory.pm  view on Meta::CPAN

  
=item L<Class::DBI::Factory::Handler>

A fairly comprehensive base class for mod_perl handlers, providing standard ways of retrieving and displaying one or many cdbi objects. It's biased towards the Template Toolkit but you can easily replace that with your preferred templating system. Se...

There is also a rather experimental Class::DBI::Factory::Handler2 that should provide mod_perl 2 compatibility with little or no rewriting. It's in a fragile state at the moment because of fluctuations in the mod_perl and libapreq2 APIs, but later th...

=item L<Class::DBI::Factory::Exception>

Pervasive but fairly simple exception-handling routines for CDF-based applications based on Apache return codes. CDF::Handler uses try/catch for everything, and most of the other classes here will throw a CDF::Exception on error. See C<fail()>, below...
  

 view release on metacpan or  search on metacpan

lib/Class/DBI/Frozen/301.pm  view on Meta::CPAN

			|| $class->_croak("$col is not a column of $class");
		push @cols, $column;
		push @vals, $class->_deflated_column($column, $val);
	}

	my $frag = join " AND ",
		map defined($vals[$_]) ? "$cols[$_] $search_type ?" : "$cols[$_] IS NULL",
		0 .. $#cols;
	$frag .= " ORDER BY $search_opts->{order_by}"
		if $search_opts->{order_by};
	return $class->sth_to_objects($class->sql_Retrieve($frag),
		[ grep defined, @vals ]);

}

#----------------------------------------------------------------------
# CONSTRUCTORS
#----------------------------------------------------------------------

sub add_constructor {
	my ($class, $method, $fragment) = @_;
	return $class->_croak("constructors needs a name") unless $method;
	no strict 'refs';
	my $meth = "$class\::$method";
	return $class->_carp("$method already exists in $class")
		if *$meth{CODE};
	*$meth = sub {
		my $self = shift;
		$self->sth_to_objects($self->sql_Retrieve($fragment), \@_);
	};
}

sub sth_to_objects {
	my ($class, $sth, $args) = @_;

 view release on metacpan or  search on metacpan

lib/Class/DBI/Plugin/Backtickify.pm  view on Meta::CPAN

{
    my ( $self, $sql, @args ) = @_;
    
    #warn "TRANSFORM_SQL: SQL IN:  $sql - @args\n";
    
    # Each entry in @args is a SQL fragment. This will bugger with fragments that 
    # contain strings that match column names but are not supposed to be column names. 
    my $backtickify_arg = sub { $_[0] =~ s/\b$_\b/`$_`/g for $self->all_columns };
    $backtickify_arg->( $_ ) for @args;
    
    # -------------------

 view release on metacpan or  search on metacpan

lib/Class/DBI/Plugin/CountSearch.pm  view on Meta::CPAN

				|| $class->_croak("$col is not a column of $class");
			push @cols, $column;
			push @vals, $class->_deflated_column($column, $val);
		}
	
		my $frag = join " AND ",
			map defined($vals[$_]) ? "$cols[$_] $search_type ?" : "$cols[$_] IS NULL",
			0 .. $#cols;

		defined($frag) && $frag ne '' and
			$frag = " WHERE $frag";

		return $class->sql_count_search($frag)->select_val(@vals);
	};
	
}

=head1 AUTHOR

 view release on metacpan or  search on metacpan

lib/Class/DBI/Plugin/DeepAbstractSearch.pm  view on Meta::CPAN

=head2 get_deep_where

    my ($what, $from, $where, $bind) = $class->get_deep_where($where, $attr);

This method will be exported into the calling class, and allows for retrieving
SQL fragments used for creating queries.  The parameters are the same as to
deep_search_where.

=head1 AUTHOR

Stepan Riha, C<sriha@cpan.org>

 view release on metacpan or  search on metacpan

lib/Class/DBI/SQL/Transformer/Quotify.pm  view on Meta::CPAN

	my $me     = shift;
	my $sql    = $me->{_sql};
	my @args   = @{ $me->{_args} };
	my $caller = $me->{_caller};

	# Each entry in @args is a SQL fragment. This will bugger with fragments that
	# contain strings that match column names but are not supposed to be column names.
	$me->_backtickify_arg($_) for @args;

	$sql =~ s/__TABLE(?:\((.+?)\))?__/$me->_expand_table($1)/eg;
	$sql =~ s/__JOIN\((.+?)\)__/$me->_expand_join($1)/eg;

 view release on metacpan or  search on metacpan

lib/Class/DBI/Search/Count.pm  view on Meta::CPAN

	my $self = shift;
	my $class = $self->class;
	$class->set_sql(plugged_count => qq{
		SELECT COUNT(*) FROM __TABLE__ WHERE %s
	}) unless $class->can('sql_plugged_count');
	return $class->sql_plugged_count($self->fragment);
}

sub run_search {
	my $self = shift;
	return $self->sql->select_val(@{ $self->bind });

 view release on metacpan or  search on metacpan

lib/Class/DBI/Search/LIMITed.pm  view on Meta::CPAN

use strict;
use warnings;

use base 'Class::DBI::Search::Basic';

sub fragment {
  my $self = shift;
  my $frag = $self->SUPER::fragment;
  if (defined(my $limit = $self->opt('limit'))) {
    $frag .= " LIMIT $limit";
  }
  return $frag;
}

1;

__END__

lib/Class/DBI/Search/LIMITed.pm  view on Meta::CPAN

As with all Search plugins you can choose the method name for the search
that it generates. You can either make a distinct limit-ed search method
(e.g. search_limited()), or just make it your default search() method.

=head2 fragment

This overrides the default 'fragment' method in Class::DBI::Search::Basic
to add any 'limit' option passed in your search query.

=head1 CAVEATS

This is only useful for databases which support a LIMIT modifier, such

 view release on metacpan or  search on metacpan

lib/Class/DBI/Sweet.pm  view on Meta::CPAN

the COUNT(*) might be as expensive as just running the full query and just slicing
the iterator).

=item sql_method

This sets the name of the sql fragment to use as previously set by a
C<set_sql> call.  The default name is "Join_Retrieve" and the associated
default sql fragment set in this class is:

    __PACKAGE__->set_sql( Join_Retrieve => <<'SQL' );
    SELECT __ESSENTIAL(me)__%s
    FROM   %s
    WHERE  %s
    SQL

You may override this in your table or base class using the same name and CDBI::Sweet
will use your custom fragment, instead.

If you need to use more than one sql fragment in a given class you may create a new
sql fragment and then specify its name using the C<sql_method> attribute.

The %s strings are replaced by sql parts as described in L<Ima::DBI>.  See
"statement_order" for the sql part that replaces each instance of %s.

In addition, the associated statment for COUNT(*) statement has "_Count"
appended to the sql_method name.  Only "from" and "where" are passed to the sprintf
function.

The default sql fragment used for "Join_Retrieve" is:

    __PACKAGE__->set_sql( Join_Retrieve_Count => <<'SQL' );
    SELECT COUNT(*)
    FROM   %s
    WHERE  %s
    SQL

If you create a custom sql method (and set the C<sql_method> attribute) then
you will likely need to also create an associated _Count fragment.  If you do
not have an associated _Count, and wish to call the C<page> method,  then set
C<disable_sql_paging> to true and your result set from the select will be spliced
to return the page you request.

Here's an example.

lib/Class/DBI/Sweet.pm  view on Meta::CPAN

        } );


=item statement_order

Specifies a list reference of SQL parts that are replaced in the SQL fragment (which
is defined with "sql_method" above).  The available SQL parts are:

    prefetch_cols from where order_by limit sql prefetch_names

The "sql" part is shortcut notation for these three combined:

 view release on metacpan or  search on metacpan

FreeTDS.pm  view on Meta::CPAN

        my $class = ref $proto || $proto;

        @args = %{ $args[0] } if ref $args[0] eq "HASH";
        my (@cols, @vals);
        my $search_opts = @args % 2 ? pop @args : {};
	my @frag = ();

        while (my ($col, $val) = splice @args, 0, 2) {
		$col = $class->find_column($col) or $class->croak("$col is not a column of $class");
                $val = $class->_deflated_column($col, $val) || next;

		push @frag, "$col $search_type $val";
        }

	my $frag = join(' AND ', @frag);
        $frag .= " ORDER BY $search_opts->{order_by}" if $search_opts->{order_by};

        return $class->sth_to_objects($class->sql_Retrieve($frag));
}

1;

__END__

 view release on metacpan or  search on metacpan

contrib/vim/taglist.vim  view on Meta::CPAN

" awk language
let s:tlist_def_awk_settings = 'awk;f:function'

" beta language
let s:tlist_def_beta_settings = 'beta;f:fragment;s:slot;v:pattern'

" c language
let s:tlist_def_c_settings = 'c;d:macro;g:enum;s:struct;u:union;t:typedef;' .
                           \ 'v:variable;f:function'

 view release on metacpan or  search on metacpan

lib/Class/GAPI.pm  view on Meta::CPAN

Which will then allow you to do this: 

	my $pet = Guppy->new()      ; 
	my $SwimTowardstheLight = $pet->CGI->param("fishhook") ; # Extract CGI parameter "fishhook" 
 
Class::GAPI will always use the right-most namespace fragment as the option in the option => value pair. (This may 
cause a namespace conflict from time to time, in those cases just use the third stage _init instead.) So for example: 

	package SpyGuppy	   ; 
	use Crypt::CBC             ; # block handler
	use Crypt::DES             ; # Encryption Algorythm. 

 view release on metacpan or  search on metacpan

lib/Class/Generate.pm  view on Meta::CPAN

        undef $private_class_methods_regexp;
    }
}

sub substituted($)
{    # Within a code fragment, replace
    my $code = $_[0];    # member names and accessors with the
                         # appropriate forms.
    $code =~ s/$member_regexp/member_invocation($1, $&)/eg
        if defined $member_regexp;
    $code =~ s/$accessor_regexp/accessor_invocation($1, $+, $&)/eg

lib/Class/Generate.pm  view on Meta::CPAN

my $package_decl;
my $member_error_message = '%s, member "%s": In "%s" code: %s';
my $method_error_message = '%s, method "%s": %s';

sub create_code_checking_package($);
sub fragment_as_sub($$\@;\@);
sub collect_code_problems($$$$@);

# Check each user-defined code fragment in $class for errors. This includes
# pre, post, and assert code, as well as user-defined methods.  Set
# $errors_found according to whether errors (not warnings) were found.
sub check_user_defined_code($$$$)
{
    my ( $class, $class_name_label, $warnings, $errors ) = @_;

lib/Class/Generate.pm  view on Meta::CPAN

    for my $member ( $class->constructor, @members )
    {
        if ( defined( $code = $member->pre ) )
        {
            $code = fragment_as_sub $code, $instance_var, @class_vars,
                @valid_variables;
            collect_code_problems $code,
                $warnings, $errors,
                $member_error_message, $class_name_label, $member->name, 'pre';
            $problems_in_pre = @$warnings || $$errors;

lib/Class/Generate.pm  view on Meta::CPAN

            if ( defined $pre && !$problems_in_pre )
            {    # Don't report errors
                $pre =~ s/\n+/ /g;    # in pre again.
                $code = $pre . $code;
            }
            $code = fragment_as_sub $code, $instance_var, @class_vars,
                @valid_variables;
            collect_code_problems $code,
                $warnings, $errors,
                $member_error_message, $class_name_label, $member->name, 'post';
        }
        if ( defined( $code = $member->assert ) )
        {
            $code = fragment_as_sub "unless($code){die}", $instance_var,
                @class_vars, @valid_variables;
            collect_code_problems $code,
                $warnings, $errors,
                $member_error_message, $class_name_label, $member->name,
                'assert';

lib/Class/Generate.pm  view on Meta::CPAN

    }
    for my $method ( $class->user_defined_methods_values )
    {
        if ( $method->isa('Class::Generate::Class_Method') )
        {
            $code = fragment_as_sub $method->body, $class->class_var,
                @class_vars;
        }
        else
        {
            $code = fragment_as_sub $method->body, $instance_var, @class_vars,
                @valid_variables;
        }
        collect_code_problems $code, $warnings, $errors, $method_error_message,
            $class_name_label, $method->name;
    }

lib/Class/Generate.pm  view on Meta::CPAN

    $packages .= join( '', map( 'use ' . $_ . ';', $class->use_packages ) );
    $packages .= 'use vars qw(@ISA);' if $class->parents;
    eval $package_decl . $packages;
}

# Evaluate a code fragment, passing on
sub collect_code_problems($$$$@)
{    # warnings and errors.
    my ( $code_form, $warnings, $errors, $error_message, @params ) = @_;
    my @warnings;
    local $SIG{__WARN__} = sub { push @warnings, $_[0] };

lib/Class/Generate.pm  view on Meta::CPAN

    my ( $message, $error, @params ) = @_;          # a little by removing the
    $error =~ s/\(eval \d+\) //g;                   # "(eval N)" forms that perl
    return sprintf( $message, @params, $error );    # inserts.
}

sub fragment_as_sub($$\@;\@)
{
    my ( $code, $id_var, $class_vars, $valid_vars ) = @_;
    my $form;
    $form = "sub{my $id_var;";
    if ( $#$class_vars >= 0 )

lib/Class/Generate.pm  view on Meta::CPAN

    Class class_name, method "name":

where C<E<lt>xE<gt>> is one of C<pre>, C<post>, or C<assert>.
See L<perldiag> for an explanation of such messages.
The message will include a line number that is relative to the
lines in the erroneous code fragment,
as well as the line number on which the class begins.
For instance, suppose the file C<stacks.pl> contains the following code:

    #! /bin/perl
    use warnings;

 view release on metacpan or  search on metacpan

MakeMethods.pm  view on Meta::CPAN

subroutines; if the method you need isn't included, you can extend
existing methods by re-defining just the snippet of code that's
different.

Class::MakeMethods::Template extends MakeMethods with a text
templating system that can assemble Perl code fragments into a
desired subroutine. The code for generated methods is eval'd once
for each type, and then repeatedly bound as closures to method-specific
data for better performance.

Templates for dozens of types of constructor, accessor, and mutator

 view release on metacpan or  search on metacpan

lib/Class/Maker/Basic/Constructor.pm  view on Meta::CPAN

	#     my $meth = $class . "::_init";
	#     $self->$meth(@_) if $class->can("_init");
	# }

	# This calls a parent method with our object/package.
	# "This is very fragile code" as stated in the cookbook
	# recipe 13.10, which breaks into unusability when we
	# have following scenario:
	#
	# The "_init" method of the parent class contains method calls
	# of his own class and this method is overriden in this class.

 view release on metacpan or  search on metacpan

inc/Spiffy.pm  view on Meta::CPAN

          ? '{}'
          : default_as_code($default);

    my $code = $code{sub_start};
    if ($args->{-init}) {
        my $fragment = $args->{-weak} ? $code{weak_init} : $code{init};
        $code .= sprintf $fragment, $field, $args->{-init}, ($field) x 4;
    }
    $code .= sprintf $code{set_default}, $field, $default_string, $field
      if defined $default;
    $code .= sprintf $code{return_if_get}, $field;
    $code .= sprintf $code{set}, $field;

 view release on metacpan or  search on metacpan

inc/Module/AutoInstall.pm  view on Meta::CPAN

    return 1;
}

sub postamble {
    $PostambleUsed = 1;
    my $fragment;

    $fragment .= <<"AUTO_INSTALL" if !$InstallDepsTarget;

config :: installdeps
\t\$(NOECHO) \$(NOOP)
AUTO_INSTALL

    $fragment .= <<"END_MAKE";

checkdeps ::
\t\$(PERL) $0 --checkdeps

installdeps ::

inc/Module/AutoInstall.pm  view on Meta::CPAN

listalldeps ::
\t$PostambleActionsListAllDeps

END_MAKE

    return $fragment;
}

1;

__END__

 view release on metacpan or  search on metacpan

lib/Class/Refresh.pm  view on Meta::CPAN

C<require> (since the hook is global).

=back

This module has several limitations, due to reloading modules in this way being
an inherently fragile operation. Therefore, this module is recommended for use
only in development environments - it should not be used for reloading things
in production.

It makes several assumptions about how code is structured that simplify the
logic involved quite a bit, and make it more reliable when those assumptions

 view release on metacpan or  search on metacpan

lib/Class/Spiffy.pm  view on Meta::CPAN

          ? '{}'
          : default_as_code($default);

    my $code = $code{sub_start};
    if ($args->{-init}) {
        my $fragment = $args->{-weak} ? $code{weak_init} : $code{init};
        $code .= sprintf $fragment, $field, $args->{-init}, ($field) x 4;
    }
    $code .= sprintf $code{set_default}, $field, $default_string, $field
      if defined $default;
    $code .= sprintf $code{return_if_get}, $field;
    $code .= sprintf $code{set}, $field;

 view release on metacpan or  search on metacpan

XPath.pm  view on Meta::CPAN

our $VERSION = '1.4';
use Carp qw(croak);
use constant DEBUG => 0;

# regex fragment for names in XPath expressions
our $NAME = qr/[\w:]+/;

# declare prototypes
sub foreach_node (&@);

 view release on metacpan or  search on metacpan

lib/Claude/Agent/Code/Review/Filter.pm  view on Meta::CPAN

    # Filter out complaints about "no critic" directives - these are intentional suppressions
    if ($desc =~ /no.critic.*(?:directive|issue|apply|not.*needed)|directive.*no.critic/i) {
        return 1;
    }

    # Filter out "fragile" position comparison complaints when using valid length-based comparisons
    # Comparing length of captured prefix content is a valid way to compare positions
    if ($desc =~ /position.*(?:fragile|incorrect)|(?:fragile|incorrect).*position|length\(\).*position/i) {
        if ($context =~ /length\(\$\w+\)\s*<\s*length\(\$\w+\)/i) {
            return 1;
        }
    }

 view release on metacpan or  search on metacpan

lib/Clean/Eval.pm  view on Meta::CPAN

if no failure has been recorded yet. Successful calls do B<not> reset this
slot. Useful for code paths that discarded the result object or want to
inspect a previous failure after the fact.

B<Caveat:> C<last_error> is a global slot and is subject to the same class
of bug that makes raw C<$@> fragile. If a C<DESTROY> method (or anything
else running during stack unwind) calls C<clean_eval> or
C<clean_string_eval> and that inner call fails, it will overwrite the
global and the error you actually cared about will be lost. C<last_error>
is a convenience, not a guarantee - the only robust way to inspect a
particular failure is to capture the result object of

lib/Clean/Eval.pm  view on Meta::CPAN

        my $err = $@;
        ...
    }

This is correct but verbose, and the C<; 1> trailer is easy to forget. The
C<$@> variable is also famously fragile: destructors that run during stack
unwind can call C<eval> themselves and reset it before you read it. Localizing
C<$@> the way C<Clean::Eval> does avoids that class of bug entirely.

=head1 PITFALLS

 view release on metacpan or  search on metacpan

MGi.pm  view on Meta::CPAN

Adds a B<-expand> flag, which "flattens out" the config spec by
inlining the contents of any include files.

Add support for incremental label type families, via an
I<##:IncrementalLabels:> attribute in the config spec: generate a
config spec fragment equivalent to the type specified, and include it.
An optional clause of C<-nocheckout> will be propagated to the
generated rules.

=cut

MGi.pm  view on Meta::CPAN

  die Msg('E', 'Cannot get view info for current view: not a ClearCase object.')
    unless $tag;
  my ($vws) = reverse split '\s+', $ct->lsview($tag)->qx;
  open $fh, '>', "$vws/$lbtype"
    or die Msg('E',
	       qq(Failed to write config spec fragment "$vws/$lbtype": $!\n));
  print $fh qq(element * "{lbtype($_)&&!attr_sub($rmat,<=,$nr)}$noco"\n)
    for @eqlst;
  close $fh;
  $cs .= $$;
  open $fh, '>', $cs or die Msg('E', qq(Could not write "$cs": $!));

MGi.pm  view on Meta::CPAN

    }
    @cs2 = grep $trim->(), <$fh> if $incfam;
    close $fh;
    if ($incfam) {
      open $fh, '>', $f
	or die Msg('E', qq(Failed to write config spec fragment "$f": $!));
      print $fh qq(element * "{lbtype($_)&&!attr_sub($rmat,<=,$nr)}$noco"\n)
	for @eqlst;
      close $fh;
    } else {
      warn Msg('W', qq(No rule based on "$l" was found in "$cs".\n));

 view release on metacpan or  search on metacpan

MANIFEST  view on Meta::CPAN

t/data/rendered/derived_list.html
t/data/rendered/derived_list.js
t/data/rendered/derived_list.xml
t/data/rendered/derived_list_overridden.ajax
t/data/rendered/derived_update.html
t/data/rendered/footer-1.frag
t/data/rendered/header-1.frag
t/data/rendered/view-error-read-tt.html
t/data/rendered/view-error-read.html
t/data/rendered/view-error-read.xml
t/data/templates/actions.tt2
t/data/templates/cache.tt2

 view release on metacpan or  search on metacpan

t/helpers.t  view on Meta::CPAN

    like($err, qr/needs rows/, 'rows is required');
}

# for_query: with via=>'client', we can't fake clickhouse-client; just
# verify the dispatch builds the same describe call as for_table for
# its own SQL fragment. We exercise the private _for_describe helper
# only indirectly. If clickhouse-client isn't installed, this branch
# dies before opening the pipe -- catch and skip.
SKIP: {
    # Cheap smoke: confirm for_query is dispatchable and routes through
    # the same plumbing. Don't require a running server.

 view release on metacpan or  search on metacpan

examples/jquery-1.6.2.min.js  view on Meta::CPAN

 * Copyright 2011, The Dojo Foundation
 * Released under the MIT, BSD, and GPL Licenses.
 *
 * Date: Thu Jun 30 14:16:56 2011 -0400
 */
(function(a,b){function cv(a){return f.isWindow(a)?a:a.nodeType===9?a.defaultView||a.parentWindow:!1}function cs(a){if(!cg[a]){var b=c.body,d=f("<"+a+">").appendTo(b),e=d.css("display");d.remove();if(e==="none"||e===""){ch||(ch=c.createElement("ifram...
shift(),i.sort());if(!!e&&!f.event.customEvent[h]||!!f.event.global[h]){c=typeof c=="object"?c[f.expando]?c:new f.Event(h,c):new f.Event(h),c.type=h,c.exclusive=j,c.namespace=i.join("."),c.namespace_re=new RegExp("(^|\\.)"+i.join("\\.(?:.*\\.)?")+"(\...
)}return this.pushStack(d,a,e.selector)}}),f.extend({clone:function(a,b,c){var d=a.cloneNode(!0),e,g,h;if((!f.support.noCloneEvent||!f.support.noCloneChecked)&&(a.nodeType===1||a.nodeType===11)&&!f.isXMLDoc(a)){bi(a,d),e=bj(a),g=bj(d);for(h=0;e[h];++...

 view release on metacpan or  search on metacpan

charmonizer.c  view on Meta::CPAN

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* Source fragment for the Clownfish compiler's charmonizer.c.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

 view release on metacpan or  search on metacpan

charmonizer.c  view on Meta::CPAN

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* Source fragment for the Clownfish runtime's charmonizer.c.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>