Free search tools keywords 0.06 software for linux

Search::Tools::Keywords is a Perl module to extract keywords from a search query.

SYNOPSIS

use Search::Tools::Keywords;
use Search::Tools::RegExp;

my $query = the quick fox color:brown and "lazy dog" not jumped;

my $kw = Search::Tools::Keywords->new(
stopwords => the,
and_word => and,
or_word => or,
not_word => not,
stemmer => &your_stemmer_here,
ignore_first_char => +-,
ignore_last_char => ,
word_characters => $Search::Tools::RegExp::WordChar,
debug => 0,
phrase_delim => ",
charset => iso-8859-1,
lang => en_US,
locale => en_US.iso-8859-1
);

my @words = $kw->extract( $query );
# returns:
# quick
# fox
# brown
# lazy dog

Do not confuse this class with Search::Tools::RegExp::Keywords.

Search::Tools::Keywords extracts the meaningful words from a search query. Since many search engines support a syntax that includes special characters, boolean words, stopwords, and fields, search queries can become complicated. In order to separate the wheat from the chafe, the supporting words and symbols are removed and just the actual search terms (keywords) are returned.

This class is used internally by Search::Tools::RegExp. You probably dont need to use it directly. But if you do, read on.

Search::Tools::RegExp::Keyword is a Perl module to access regular expressions for a keyword.

SYNOPSIS

my $regexp = Search::Tools::RegExp->new();

my $kw = $regexp->build(the quick brown fox);

for my $w ($kw->keywords)
{
my $re = $kw->re( $w ); # $re is S::T::R::Keyword object

# each of these are regular expressions ... suitable for framing
my $h = $re->html;
my $p = $re->plain;
unless ( $re->word =~ m/^$h$/ )
{
die "something terribly wrong with the html regexp: $h";
}
unless ( $re->word =~ m/^$p$/ )
{
die "something terribly wrong with the plain regexp: $p";
}
}

Search::Tools::RegExp::Keyword provides access to the regular expressions for a query keyword.

Search::Tools::HiLiter is a Perl module to extract and highlight search results in original text.

SYNOPSIS

use Search::Tools::HiLiter;

my $re = Search::Tools::RegExp->new;
my $rekw = $re->build(the quick brown fox);

my $hiliter = Search::Tools::HiLiter->new( rekw => $rekw );

for my $text (@texts)
{
print $hiliter->light( $text );
}

Search::Tools::HiLiter uses HTML tags to highlight text just like a felt-tip HiLiter. S::T::H can handle both plain and marked up text (HTML and XML). Nested entities and tags within keywords are supported.

You create a HiLiter object with either a string, an array of strings, or a Search::Tools::RegExp::Keywords object, and then feed the HiLiter text to highlight. You can control the style and color of the highlight tags.

Some caveats if you are highlighting HTML or XML: Unlike its more powerful cousin HTML::HiLiter, S::T::H knows nothing about context. This can give unexpected results when your keywords appear in the HTML or across block tag boundaries. Use HTML::HiLiter if you need a real HTML parser. It uses the same regular expressions as S::T::H but is designed for full HTML documents rather than smaller fragments.

Search::Tools::Snipper is a Perl module to extract keywords in context.

SYNOPSIS

my $query = [ qw/ quick dog / ];
my $text = the quick brown fox jumped over the lazy dog;

my $s = Search::Tools::Snipper->new(
occur => 3,
context => 8,
word_len => 5,
max_chars => 300,
query => $query
);

print $s->snip( $text );

Search::Tools::Snipper extracts keywords and their context from a larger block of text. The larger block may be plain text or HTML/XML.

B::Keywords is a Perl module that contains lists of reserved barewords and symbol names.

SYNOPSIS

use B::Keywords qw( @Symbols Barewords );
print join "n", @Symbols,
@Barewords;

B::Keywords supplies seven arrays of keywords: @Scalars, @Arrays, @Hashes, @Filehandles, @Symbols, @Functions, and @Barewords. The @Symbols array includes the contents of each of @Scalars, @Arrays, @Hashes, and @Filehandles. Similarly, @Barewords adds a few non-function keywords and operators to the @Functions array.

All additions and modifications are welcome.

DATA

@Scalars

@Arrays

@Hashes

@Filehandles

@Functions

The above are lists of variables, special file handles, and built in functions.

@Symbols

This is just the combination of all of the above: variables, file handles, and functions.

@Barewords

This is a list of other special keywords in perl including operators and all the control structures.

Web search is provided with Yahoo! Search Web Services. Okapibar consists of a keyword input, search engine buttons, and function buttons. The search engine button selects YahooCPM or Yahoo. The function buttons are a highlight button to change the background color of words same as the key words, a compact button to change between one line and two-line layout, and a script button to show that Javascript is disable during the search in CPM.

mod_choke is a module for Apache that limits usage by greedy clients. Its two main functions are to limit the number of concurrent connections per IP, and to limit the rate at which apache sends data to the client.

It includes detection of users behind proxy servers (using the X-Referred-By header). It includes limiting the speed at which files are sent to a configurable rate, with the option of allowing a burst at full speed for the first chunk of a file.

Object::AutoAccessor is an accessor class by using AUTOLOAD.

SYNOPSIS

use Object::AutoAccessor;

my $struct = {
foo => {
bar => {
baz => BUILD OK,
},
},
};

# Now lets easily accomplish it.
my $obj = Object::AutoAccessor->build($struct);

print $obj->foo->bar->baz; # prints BUILD OK

# OK, now reverse it!
$obj->foo->bar->baz(TO HASHREF);
my $hashref = $obj->as_hashref;
print $hashref->{foo}->{bar}->{baz}; # prints TO HASHREF;

# Of course, new() can be used.
$obj = Object::AutoAccessor->new();

# setter methods
$obj->foo(bar);
$obj->set_foo(bar);
$obj->param(foo => bar);

# getter methods
$obj->foo();
$obj->get_foo();
$obj->param(foo);

# $obj->param() is compatible with HTML::Template->param()
my @keywords = $obj->param();
my $val = $obj->param(hash);
$obj->param(key => val);

my $tmpl = HTML::Template->new(..., associate => [$obj], ...);

Object::AutoAccessor is a Accessor class to get/set values by AUTOLOADed method automatically. Moreover, param() is compatible with HTML::Template module, so you can use Object::AutoAccessor object for HTML::Templates associate option.