view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

0.003       2014-12-31 00:39:04-0600
    - add a role for Rlike data frames
          * support for methods: head(), tail(), subset()
    - use MooX::Traits to support loading roles easily
    - fix: select_rows() with no arguments should return an empty Data::Frame
    - bump PDL version to use its `unpdl()` method
    - Column::Helper now uses AUTOLOAD to make accessing columns easier in `subset()`

0.002       2014-12-25 03:34:04-0600
    - fix stringifiable length test

 view release on metacpan or  search on metacpan

inc/TestML/Runtime.pm  view on Meta::CPAN

    }
}

sub run_statement {
    my ($self, $statement) = @_;
    my $blocks = $self->select_blocks($statement->points || []);
    for my $block (@$blocks) {
        $self->function->setvar('Block', $block) if $block != 1;
        my $result = $self->run_expression($statement->expr);
        if (my $assert = $statement->assert) {
            $self->run_assertion($result, $assert);

inc/TestML/Runtime.pm  view on Meta::CPAN

    }
    $value =~ s/^\\//gm;
    return TestML::Str->new(value => $value);
}

sub select_blocks {
    my ($self, $wanted) = @_;
    return [1] unless @$wanted;
    my $selected = [];

    OUTER: for my $block (@{$self->function->data}) {
        my %points = %{$block->points};
        next if exists $points{SKIP};
        if (exists $points{ONLY}) {
            for my $point (@$wanted) {
                return [] unless exists $points{$point};
            }
            $selected = [$block];
            last;
        }
        for my $point (@$wanted) {
            next OUTER unless exists $points{$point};
        }
        push @$selected, $block;
        last if exists $points{LAST};
    }
    return $selected;
}

sub compile_testml {
    my ($self) = @_;

 view release on metacpan or  search on metacpan

inc/Capture/Tiny.pm  view on Meta::CPAN

  my ($which, $stash) = @_; # $which is "stdout" or "stderr"
  # setup pipes
  $stash->{$_}{$which} = IO::Handle->new for qw/tee reader/;
  pipe $stash->{reader}{$which}, $stash->{tee}{$which};
  # _debug( "# pipe for $which\: " .  _name($stash->{tee}{$which}) . " " . fileno( $stash->{tee}{$which} ) . " => " . _name($stash->{reader}{$which}) . " " . fileno( $stash->{reader}{$which}) . "\n" );
  select((select($stash->{tee}{$which}), $|=1)[0]); # autoflush
  # setup desired redirection for parent and child
  $stash->{new}{$which} = $stash->{tee}{$which};
  $stash->{child}{$which} = {
    stdin   => $stash->{reader}{$which},
    stdout  => $stash->{old}{$which},

 view release on metacpan or  search on metacpan

lib/NewRelic/Agent/FFI/Procedural.pm  view on Meta::CPAN

 my $seg = newrelic_segment_datastore_begin $tx, $parent_seg, $table, $operation, $sql, $sql_trace_rollup_name;
 my $seg = newrelic_segment_datastore_begin $tx, $parent_seg, $table, $operation, $sql, $sql_trace_rollup_name, $sql_obfuscator;

Begins a new datastore segment.  C<$parent_seg> is a parent segment id (C<undef> no parent).  C<$operation> should be
one of C<select>, C<insert>, C<update> or C<delete>.

If you want to provide your own obfuscator, you need to pass in the address of a C function.  To do that from Perl you can
create a closure with L<FFI::Platypus>, like so:

 use 5.010;

 view release on metacpan or  search on metacpan

lib/Sex.pm  view on Meta::CPAN

    }

    while( my($chromo, $rna) = each %zygote ) {
        $call_sym_table->{$chromo} = $rna->[rand @$rna];
        print $Grunts[rand @Grunts], "\n";
        #select(undef, undef, undef, 0.45);
    }

    # push @{$caller.'::ISA'}, @modules;

    print "\n";

 view release on metacpan or  search on metacpan

t/Test/Builder.pm  view on Meta::CPAN

}


sub _autoflush {
    my($fh) = shift;
    my $old_fh = select $fh;
    $| = 1;
    select $old_fh;
}


sub _dup_stdhandles {
    my $self = shift;

 view release on metacpan or  search on metacpan

lib/Tickit/Widget/CheckButton.pm  view on Meta::CPAN

 Tickit->new( root => $vbox )->run;

=head1 DESCRIPTION

This class provides a widget which allows a true/false selection. It displays
a clickable indication of status and a caption. Clicking on the status or
caption inverts the status of the widget.

This widget is part of an experiment in evolving the design of the
L<Tickit::Style> widget integration code, and such is subject to change of

 view release on metacpan or  search on metacpan

ppport.h  view on Meta::CPAN

ck_retarget|||
ck_return|||
ck_rfun|||
ck_rvconst|||
ck_sassign|||
ck_select|||
ck_shift|||
ck_sort|||
ck_spair|||
ck_split|||
ck_subr|||

 view release on metacpan or  search on metacpan

bin/linkBags  view on Meta::CPAN

my $SORTCODE = "LC_ALL=en_US.UTF-8; export LC_ALL;" ;

############ END CONFIGURATION ######################

#  autoflush
select((select(STDERR), $| = 1)[0]);

# encoding pragmas follow any includes like "use"
use encoding 'utf8';
use open ':utf8';
binmode STDIN, ":utf8";

bin/linkBags  view on Meta::CPAN

close(IN); 
close(OUT); 
#  we want to write to the front of the file,
#  without destroying rest of contents, this open does it
sysopen(OUT, $tfile, O_RDWR) or die "Cannot reopen $tfile: $!";
my $oldfh = select(OUT); $| = 1; select($oldfh);
#  now, rewrite header
print OUT sprintf("%8d\n%8d\n", $doccount, $featcount);
close(OUT); 

print STDERR "\nNow build the document bags with mpdata\n";

 view release on metacpan or  search on metacpan

lib/Alvis/Buffer.pm  view on Meta::CPAN

    #  start new one
    if ( ! open(ABUF,">>$BUFFER") ) {
      print STDERR "Cannot open $BUFFER: $!\n";
      return 0;
    }
    select((select(ABUF), $| = 1)[0]);
    print ABUF $HEADER;
  } else {
    #  check old one first
    if ( ! open(ABUF,"<$BUFFER") ) {
      print STDERR "Cannot open $BUFFER: $!\n";

lib/Alvis/Buffer.pm  view on Meta::CPAN

    # now open for append
    if ( ! open(ABUF,">>$BUFFER") ) {
      print STDERR "Cannot open $BUFFER: $!\n";
      return 0;
    }
    select((select(ABUF), $| = 1)[0]);
  }
  1;
}

############################################

 view release on metacpan or  search on metacpan

lib/Alvis/NLPPlatform/NLPWrappers.pm  view on Meta::CPAN

    my %corpus;
    my %lc_corpus;
    my $sent_id;
    my $command_line;
    my %corpus_index;
    my %idtrm_select;
    my @tab_results;
    my $semtag;

    my $token_start;
    my $token_end;

lib/Alvis/NLPPlatform/NLPWrappers.pm  view on Meta::CPAN

	if (scalar(@term_list_FR) == 0) {
	    Alvis::TermTagger::load_TermList($h_config->{'NLP_misc'}->{'TERM_LIST_FR'},\@term_list_FR);
	      Alvis::TermTagger::get_Regex_TermList(\@term_list_FR, \@regex_term_list_FR);
	  }
	Alvis::TermTagger::corpus_Indexing(\%lc_corpus, \%corpus_index);
	Alvis::TermTagger::term_Selection(\%corpus_index, \@term_list_FR, \%idtrm_select);
	Alvis::TermTagger::term_tagging_offset_tab(\@term_list_FR, \@regex_term_list_FR, \%idtrm_select, \%corpus, \%tabh_sent_terms);
    } else {
	if (scalar(@term_list_EN) == 0) {
	    Alvis::TermTagger::load_TermList($h_config->{'NLP_misc'}->{'TERM_LIST_EN'},\@term_list_EN);
	      Alvis::TermTagger::get_Regex_TermList(\@term_list_EN, \@regex_term_list_EN);
	  }
	Alvis::TermTagger::corpus_Indexing(\%lc_corpus, \%corpus_index);
	Alvis::TermTagger::term_Selection(\%corpus_index, \@term_list_EN, \%idtrm_select);
	Alvis::TermTagger::term_tagging_offset_tab(\@term_list_EN, \@regex_term_list_EN, \%idtrm_select, \%corpus, \%tabh_sent_terms);
      }
    %lc_corpus = ();
    %corpus_index = ();
    %idtrm_select = ();
    %corpus = ();

# TODO : taking into account the case where terms appear at least twice in a sentence

    $i=0;

 view release on metacpan or  search on metacpan

lib/Alvis/Treetagger.pm  view on Meta::CPAN

  }
  sleep(1);
  
  if ( $verbose ) { print STDERR "Starting fifo input $FIFO.in\n"; }
  open(FI,">$FIFO.in");
  select((select(FI), $| = 1)[0]);

  #  send some stuff down the pipe to warm it up;
  #  note we add to extra "\n." two evey message
  #  to force TreeTagger to run the buffer
  print FI "Start\nup\nnow\n.\n.\n.\n";

 view release on metacpan or  search on metacpan

bin/TermTagger-brat.pl  view on Meta::CPAN

TermTagger-brat.pl -- A Perl script for tagging text with terms (Brat format output)

=head1 SYNOPSIS

TermTagger.pl [options] corpus termlist selected_term_list lemmatised_corpus

=head1 OPTIONS

=over 4

bin/TermTagger-brat.pl  view on Meta::CPAN

This script tags a corpus with terms and provide a output compatible with Brat (<http://brat.nlplab.org/>). Corpus (C<corpus>) is a file
with one sentence per line. Term list (C<termlist>) is a file
containing one term per line. For each term, additionnal information
(as canonical form) can be given after a column. Each line of the
output file (C<selected_term_list>) contains the sentence number, the
term, additional information, all separated by a tabulation character.

==hea1 EXAMPLES

Tag the textual corpus in C<corpus-test.txt> with terms in the file

 view release on metacpan or  search on metacpan

Build.PL  view on Meta::CPAN

    my $default = $config->{mason_web_dir};
    $default =~ s,/alzabo\Z,, if $default;

    do
    {
	print "\n *** The directory you selected does not exist ***\n"
            if defined $config->{mason_web_dir} && ! -d $config->{mason_web_dir};

	print <<'EOF';

Where would you like to install the mason components for this

 view release on metacpan or  search on metacpan

lib/Alzabo/Driver.pm  view on Meta::CPAN

Returns an array of array references containing the data requested.

=head2 rows_hashref

Returns an array of hash references containing the data requested.
The hash reference keys are the columns being selected.  All the key
names are in uppercase.

=head2 one_row

Returns an array or scalar containing the data returned, depending on
context.

=head2 one_row_hash

Returns a hash containing the data requested.  The hash keys are the
columns being selected.  All the key names are in uppercase.

=head2 column

Returns an array containing the values for the first column of each
row returned.

lib/Alzabo/Driver.pm  view on Meta::CPAN

Throws: L<C<Alzabo::Exception::Driver>|Alzabo::Exceptions>

=head2 all_rows

If the select for which this statement is cursor was for a single
column (or aggregate value), then this method returns an array
containing each B<remaining> value from the database.

Otherwise, it returns an array of array references, each one
containing a returned row from the database.

 view release on metacpan or  search on metacpan

lib/Amazon/Dash/Button.pm  view on Meta::CPAN

The first thing to do once you have received your button is to set it and discover it.
Here is the basic setting process:

=over 4

=item use your phone or table to perform the basic setting, but do not complete it, stop when asking to select to link a product with the button.

=item  in the mobile app you would find a menu "Your Dash Button" -> "Settings" then "Set up a new device".

=item  choose your dash device, then follow the instructions: long press on the button until it discovery mode (blue light)

=item  provide the wifi password of your network

=item  but do not select the exact product linked to your button exit from there !

=back

=head2 Detecting the button

 view release on metacpan or  search on metacpan

lib/Amazon/DynamoDB/Simple.pm  view on Meta::CPAN

    $table->keys();

    # delete $old_key, create $new_key
    $table->rename($old_key, $new_key);

    # sync data between AWS regions using the 'last_updated' field to select
    # the newest data.  This method will permanently delete any items marked as
    # 'deleted'.
    $table->sync_regions();

    # This sets the value of the hosts attribute.  The value shown is the

 view release on metacpan or  search on metacpan

lib/Amazon/DynamoDB/LWP.pm  view on Meta::CPAN

sub delay {
    my $self = shift;
    my $amount = shift;

    Future->call(sub {
                     # Sleep could be less than one second, so use select.
                     if ($amount > 0) {
                         select(undef, undef, undef, $amount);
                     }
                     Future->new->done();
                 });
}

 view release on metacpan or  search on metacpan

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

}


=item force

Same as above, but only for the selected items. An arrayref is
expected here with the B<skus>.

=cut

has force => (is => 'ro',

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

has existing_products => (is => 'lazy');

sub _build_existing_products {
    my $self = shift;
    my $sth = $self->_exe_query($self->sqla->select(amazon_mws_products => [qw/sku
                                                                               timestamp_string
                                                                               status
                                                                               listed
                                                                               error_code
                                                                              /],

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

                    status => 'pending',
                    warnings => '', # clear out
                    timestamp_string => $p->timestamp_string,
                   );
        my $check = $self
          ->_exe_query($self->sqla->select(amazon_mws_products => [qw/sku/],  { %identifier }));
        my $existing = $check->fetchrow_hashref;
        $check->finish;
        if ($existing) {
            $self->_exe_query($self->sqla->update(amazon_mws_products => \%data, \%identifier));
        }

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

        }
    }
    if (@named_jobs) {
        $additional{amws_job_id} = { -in => \@named_jobs };
    }
    my ($stmt, @bind) = $self->sqla->select(amazon_mws_jobs => '*',
                                            {
                                             %additional,
                                             aborted => 0,
                                             success => 0,
                                             shop_id => $self->_unique_shop_id,

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

    # upload the feeds one by one and stop if something is blocking
    my $job_id = $row->{amws_job_id};
    print "Processing job $job_id\n";

    # query the feeds table for this job
    my ($stmt, @bind) = $self->sqla->select(amazon_mws_feeds => '*',
                                            {
                                             amws_job_id => $job_id,
                                             aborted => 0,
                                             success => 0,
                                             shop_id => $self->_unique_shop_id,

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

    while (my $feed = $sth->fetchrow_hashref) {
        last unless $self->upload_feed($feed);
    }
    $sth->finish;

    ($stmt, @bind) = $self->sqla->select(amazon_mws_feeds => '*',
                                         {
                                          shop_id => $self->_unique_shop_id,
                                          amws_job_id => $job_id,
                                         });

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

=cut

sub order_already_registered {
    my ($self, $order) = @_;
    die "Bad usage, missing order" unless $order;
    my $sth = $self->_exe_query($self->sqla->select(amazon_mws_orders => '*',
                                                    {
                                                     amazon_order_id => $order->amazon_order_number,
                                                     shop_id => $self->_unique_shop_id,
                                                    }));
    if (my $exists = $sth->fetchrow_hashref) {

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

    print "Trying to purge missing items " . join(" ", @skus) . "\n";

    # delete only products which are not in pending status
    my $check = $self
      ->_exe_query($self->sqla
                   ->select('amazon_mws_products', [qw/sku status/],
                            {
                             sku => { -in => \@skus },
                             shop_id => $self->_unique_shop_id,
                            }));
    my %our_skus;

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

    }
    else {
        warn "register_order_ack_errors couldn't parse " . Dumper($result);
    }
    # then get the amazon order number and recheck
    my $sth = $self->_exe_query($self->sqla->select('amazon_mws_orders',
                                                    [qw/amazon_order_id
                                                        shop_order_id
                                                       /],
                                                    {
                                                     amws_job_id => $job_id,

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

=cut

sub skus_in_job {
    my ($self, $job_id) = @_;
    my $sth = $self->_exe_query($self->sqla->select('amazon_mws_products',
                                                    [qw/sku/],
                                                    {
                                                     amws_job_id => $job_id,
                                                     shop_id => $self->_unique_shop_id,
                                                    }));

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

=cut

sub order_already_shipped {
    my ($self, $order) = @_;
    my $condition = $self->_condition_for_shipped_orders($order);
    my $sth = $self->_exe_query($self->sqla->select(amazon_mws_orders => '*', $condition));
    if (my $row = $sth->fetchrow_hashref) {
        die "Multiple results found in amazon_mws_orders for " . Dumper($condition)
          if $sth->fetchrow_hashref;
        return $row;
    }

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

=cut

sub orders_waiting_for_shipping {
    my $self = shift;
    my $sth = $self->_exe_query($self->sqla->select('amazon_mws_orders',
                                                    [qw/amazon_order_id
                                                        shop_order_id/],
                                                    {
                                                     shop_id => $self->_unique_shop_id,
                                                     shipping_confirmation_job_id => undef,

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

=cut

sub orders_in_shipping_job {
    my ($self, $job_id) = @_;
    die unless $job_id;
    my $sth = $self->_exe_query($self->sqla->select(amazon_mws_orders => [qw/amazon_order_id/],
                                                    {
                                                     shipping_confirmation_job_id => $job_id,
                                                     shop_id => $self->_unique_shop_id,
                                                    }));
    my @orders;

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

                 );


    # check if we have it
    my $sth = $self->_exe_query($self->sqla
                                ->select('amazon_mws_products',
                                         [qw/sku/],  { %identifier }));
    if ($sth->fetchrow_hashref) {
        $sth->finish;
        print "Updating $product{sku} with error $product{error_msg}\n";
        $self->_exe_query($self->sqla->update('amazon_mws_products',

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

sub cancel_feed {
    my ($self, $feed) = @_;
    die "Missing feed id argument" unless $feed;
    # do the api call
    my $sth = $self->_exe_query($self->sqla
                                ->select(amazon_mws_feeds => [qw/amws_job_id/],
                                         {
                                          shop_id => $self->_unique_shop_id,
                                          feed_id => $feed,
                                          aborted => 0,
                                          success => 0,

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

sub update_amw_order_status {
    my ($self, $order) = @_;
    # first, check if it exists
    return unless $order;
    my $sth = $self->_exe_query($self->sqla->select('amazon_mws_orders',
                                                    '*',
                                                    {
                                                     amazon_order_id => $order,
                                                     shop_id => $self->_unique_shop_id,
                                                    }));

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

    my $where = { '>' => 0 };
    if (@errcodes) {
        $where = { -in => \@errcodes };
    }
    my $sth = $self->_exe_query($self->sqla
                                ->select('amazon_mws_products', '*',
                                         {
                                          status => { '!=' => 'deleted' },
                                          shop_id => $self->_unique_shop_id,
                                          error_code => $where,
                                         },

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

}

sub get_products_with_warnings {
    my $self = shift;
    my $sth = $self->_exe_query($self->sqla
                                ->select('amazon_mws_products', '*',
                                         {
                                          status => 'ok',
                                          shop_id => $self->_unique_shop_id,
                                          warnings => { '!=' => '' },
                                         },

lib/Amazon/MWS/Uploader.pm  view on Meta::CPAN

    if (my $shop_id = $self->shop_id) {
        push @and, shop_id => $shop_id;
    }

    my $sth = $self->_exe_query($self->sqla
                                ->select(amazon_mws_jobs => [qw/amws_job_id shop_id/],
                                         [ -and => \@and ] ));
    my @purge_jobs;
    my $count = 0;
    while (my $where = $sth->fetchrow_hashref) {
        if ($limit) {

 view release on metacpan or  search on metacpan

lib/Amazon/S3/Thin.pm  view on Meta::CPAN

 of your credentials.

=item * C<version> (B<OPTIONAL [provider: metadata]>) - version of metadata service to use, either 1 or 2.
L<read more|https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html>

=item * C<role> (B<OPTIONAL [provider: metadata]>) - IAM instance role to use, otherwise the first is selected

=item * C<secure> - whether to use https or not. Default is 0 (http).

=item * C<ua> - a user agent object, compatible with LWP::UserAgent.
Default is an instance of L<LWP::UserAgent>.

 view release on metacpan or  search on metacpan

lib/Amazon/S3.pm  view on Meta::CPAN

=head2 list_object_versions

 list_object_versions( args ) 

Returns metadata about all versions of the objects in a bucket. You
can also use request parameters as selection criteria to return
metadata about a subset of all the object versions.

This method will only return the raw result set and does not perform
pagination or unravel common prefixes as do other methods like
C<list_bucket>. This may change in the future.

lib/Amazon/S3.pm  view on Meta::CPAN

default: 1000

=item prefix            

Use this parameter to select only those keys that begin with the
specified prefix. You can use prefixes to separate a bucket into
different groupings of keys. (You can think of using prefix to make
groups in the same way that you'd use a folder in a file system.) You
can use prefix with delimiter to roll up numerous objects into a
single result under CommonPrefixes.

 view release on metacpan or  search on metacpan

lib/Ambrosia/DataProvider/BaseDriver.pm  view on Meta::CPAN

sub ON()       { 11 }
sub UNIQ()     { 12 }
sub UNION()    { 13 }
#####################
sub get_what      { $_[0]->_cql_query->[&WHAT] }
sub get_select    { $_[0]->_cql_query->[&SELECT] }
sub get_insert    { $_[0]->_cql_query->[&INSERT] }
sub get_update    { $_[0]->_cql_query->[&UPDATE] }
sub get_delete    { $_[0]->_cql_query->[&DELETE] }
sub get_source    { $_[0]->_cql_query->[&SOURCE] }
sub get_predicate { $_[0]->_cql_query->[&PREDICATE] }

lib/Ambrosia/DataProvider/BaseDriver.pm  view on Meta::CPAN

    my $self = shift;
    $self->_cql_query->[&WHAT] = [@_];
    return $self;
}

sub select
{
    return $_[0];
}

sub insert

 view release on metacpan or  search on metacpan

Amethyst/Brain/Infobot/Module/Zippy.pm  view on Meta::CPAN

Being a BALD HERO is almost as FESTIVE as a TATTOOED KNOCKWURST.
BELA LUGOSI is my co-pilot ...
BI-BI-BI-BI-BI-BI-BI-BI-BI-BI-BI-BI-BI-BI-BI-BI-BI-BI-BI-BI-BI-BI-BI-BI- ... bleakness ... desolation ... plastic forks ...
Bo Derek ruined my life!
Boy, am I glad it's only 1971...
Boys, you have ALL been selected to LEAVE th' PLANET in 15 minutes!!
But they went to MARS around 1953!!
But was he mature enough last night at the lesbian masquerade?
Can I have an IMPULSE ITEM instead?
Can you MAIL a BEAN CAKE?
Catsup and Mustard all over the place!  It's the Human Hamburger!

Amethyst/Brain/Infobot/Module/Zippy.pm  view on Meta::CPAN

I own seven-eighths of all the artists in downtown Burbank!
I put aside my copy of "BOWLING WORLD" and think about GUN CONTROL legislation...
I represent a sardine!!
I request a weekend in Havana with Phil Silvers!
... I see TOILET SEATS ...
I selected E5 ... but I didn't hear "Sam the Sham and the Pharoahs"!
I smell a RANCID CORN DOG!
I smell like a wet reducing clinic on Columbus Day!
I think I am an overnight sensation right now!!
... I think I'd better go back to my DESK and toy with a few common MISAPPREHENSIONS ...
I think I'll KILL myself by leaping out of this 14th STORY WINDOW while reading ERICA JONG'S poetry!!

Amethyst/Brain/Infobot/Module/Zippy.pm  view on Meta::CPAN

On SECOND thought, maybe I'll heat up some BAKED BEANS and watch REGIS PHILBIN ...  It's GREAT to be ALIVE!!
On the other hand, life can be an endless parade of TRANSSEXUAL
QUILTING BEES aboard a cruise ship to DISNEYWORLD if only we let it!!
On the road, ZIPPY is a pinhead without a purpose, but never without a POINT.
Once upon a time, four AMPHIBIOUS HOG CALLERS attacked a family of DEFENSELESS, SENSITIVE COIN COLLECTORS and brought DOWN their PROPERTY VALUES!!
Once, there was NO fun ... This was before MENU planning, FASHION statements or NAUTILUS equipment ... Then, in 1985 ... FUN was completely encoded in this tiny MICROCHIP ... It contain 14,768 vaguely amusing SIT-COM pilots!!  We had to wait FOUR BIL...
One FISHWICH coming up!!
ONE LIFE TO LIVE for ALL MY CHILDREN in ANOTHER WORLD all THE DAYS OF OUR LIVES.
ONE: I will donate my entire "BABY HUEY" comic book collection to the downtown PLASMA CENTER ... TWO: I won't START a BAND called "KHADAFY & THE HIT SQUAD" ... THREE: I won't ever TUMBLE DRY my FOX TERRIER again!! 
... or were you driving the PONTIAC that HONKED at me in MIAMI last Tuesday?
Our father who art in heaven ... I sincerely pray that SOMEBODY at this table will PAY for my SHREDDED WHAT and ENGLISH MUFFIN ... and also leave a GENEROUS TIP .... 

 view release on metacpan or  search on metacpan

lib/Amibroker/OLE/APXCreator.pm  view on Meta::CPAN

=item * Open Amibroker -> Analysis window -> Settings

=item * Edit settings as per your requirement

=item * Menu-> File-> Save_AS -> select (.apx extenstion)

=back

For more infor on apx file, check this forum : L<http://amibrokerforum.proboards.com/thread/57/analysis-project-files-apx>

 view release on metacpan or  search on metacpan

t/01_simple.t  view on Meta::CPAN

my $dbh = Amon2::DBI->connect('dbi:SQLite::memory:', '', '');
$dbh->do(q{CREATE TABLE foo (e)});
$dbh->insert('foo', {e => 3});
$dbh->do_i('INSERT INTO foo ', {e => 4});
is join(',', map { @$_ } @{$dbh->selectall_arrayref('SELECT * FROM foo ORDER BY e')}), '3,4';

subtest 'utf8' => sub {
    use utf8;
    $dbh->do(q{CREATE TABLE bar (x)});
    $dbh->insert(bar => { x => "こんにちは" });
    my ($x) = $dbh->selectrow_array(q{SELECT x FROM bar});
    is $x, "こんにちは";
};

eval {
    $dbh->insert('bar', {e => 3});

 view release on metacpan or  search on metacpan

inc/Module/Install/ReadmeFromPod.pm  view on Meta::CPAN

  eval { require App::pod2pdf; }
    or die "Could not generate $out_file because pod2pdf could not be found\n";
  my $parser = App::pod2pdf->new( @$options );
  $parser->parse_from_file($in_file);
  open my $out_fh, '>', $out_file or die "Could not write file $out_file:\n$!\n";
  select $out_fh;
  $parser->output;
  select STDOUT;
  close $out_fh;
  return $out_file;
}

 view release on metacpan or  search on metacpan

lib/Amon2/Setup/Asset/Blueprint.pm  view on Meta::CPAN

legend {font-weight:bold;font-size:1.2em;margin-top:-0.2em;margin-bottom:1em;}
fieldset, #IE8#HACK {padding-top:1.4em;}
legend, #IE8#HACK {margin-top:0;margin-bottom:0;}
input[type=text], input[type=password], input[type=url], input[type=email], input.text, input.title, textarea {background-color:#fff;border:1px solid #bbb;color:#000;}
input[type=text]:focus, input[type=password]:focus, input[type=url]:focus, input[type=email]:focus, input.text:focus, input.title:focus, textarea:focus {border-color:#666;}
select {background-color:#fff;border-width:1px;border-style:solid;}
input[type=text], input[type=password], input[type=url], input[type=email], input.text, input.title, textarea, select {margin:0.5em 0;}
input.text, input.title {width:300px;padding:5px;}
input.title {font-size:1.5em;}
textarea {width:390px;height:250px;padding:5px;}
form.inline {line-height:3;}
form.inline p {margin-bottom:0;}

lib/Amon2/Setup/Asset/Blueprint.pm  view on Meta::CPAN

legend {margin-top:-0.2em;margin-bottom:1em;margin-left:-0.5em;}
textarea {overflow:auto;}
label {vertical-align:middle;position:relative;top:-0.25em;}
input.text, input.title, textarea {background-color:#fff;border:1px solid #bbb;}
input.text:focus, input.title:focus {border-color:#666;}
input.text, input.title, textarea, select {margin:0.5em 0;}
input.checkbox, input.radio {position:relative;top:.25em;}
form.inline div, form.inline p {vertical-align:middle;}
form.inline input.checkbox, form.inline input.radio, form.inline input.button, form.inline button {margin:0.5em 0;}
button, input.button {position:relative;top:0.25em;}'

 view release on metacpan or  search on metacpan

lib/Analizo/Batch/Output/DB.pm  view on Meta::CPAN

sub _find_row_id($$@) {
  my ($self, $sql, @data) = @_;
  my $statement_id = 'st_find_' . sha1_hex($sql); # is this SHA1 needed at all?

  $self->{$statement_id} ||= $self->{dbh}->prepare($sql);
  my $list = $self->{dbh}->selectall_arrayref($self->{$statement_id}, {}, @data);
  if (scalar(@$list) == 0) {
    return undef;
  } else {
    return $list->[0]->[0];
  }

 view release on metacpan or  search on metacpan

SqlLink.pm  view on Meta::CPAN

	eval { $self->{pre}->finish };

	# Apaga variaveis indesejadas
	undef $q; undef $t;

	# Retorna os resultados do select
	return @array;
}

# executa funcao 'do'
sub do {

SqlLink.pm  view on Meta::CPAN

		'passwd'    => '',
	});

=head2 $c->return(type,query)
	
	only for select

=head3 scalar type

	@r = $c->return($q,'scalar');
	foreach $i (@r) {

 view release on metacpan or  search on metacpan

lib/Anansi/ComponentManager.pm  view on Meta::CPAN

Creates a new component object and stores the object for indirect interaction by
the implementer of the component manager.  A unique identifier for the object
may either be supplied or automatically generated and is returned as a means of
referencing the object.

Note: The process of selecting the component to use requires each component to
validate it's own appropriateness.  Therefore this process makes use of a
VALIDATE_AS_APPROPRIATE component channel which is expected to return either a
B<1> I<(one)> or a B<0> I<(zero)> representing B<appropriate> or
B<inappropriate>.  If this component channel does not exist it is assumed that
the component is not designed to be implemented in this way.  A component may