Free finds software for linux

MP3::Find is a Perl module to search and sort MP3 files based on their ID3 tags.

SYNOPSIS

# select with backend you want
use MP3::Find qw(Filesystem);

print "$_n" foreach find_mp3s(
dir => /home/peter/cds,
query => {
artist => ilyaimy,
title => deep in the am,
},
ignore_case => 1,
exact_match => 1,
sort => [qw(year album tracknum)],
printf => %2n. %a - %t (%b: %y),
);

This module allows you to search for MP3 files by their ID3 tags. You can ask for the results to be sorted by one or more of those tags, and return either the list of filenames (the deault), a printf-style formatted string for each file using its ID3 tags, or the actual Perl data structure representing the results.

There are currently two backends to this module: MP3::Find::Filesystem and MP3::Find::DB. You choose which one you want by passing its name as the argument to you use statement; MP3::Find will look for a MP3::Find::$BACKEND module. If no backend name is given, it will default to using MP3::Find::Filesystem.
Note: Im still working out some kinks in the DB backend, so it is currently not as stable as the Filesystem backend.

Note the second: This whole project is still in the alpha stage, so I can make no guarentees that there wont be significant interface changes in the next few versions or so. Also, comments about what about the API rocks (or sucks!) are appreciated.

FindEmAll is another graphical find-and-grep tool.
Find Em All is inspired by XFCE-3s XFglob and Efinder which is part of the Equinox desktop environment.
Unfortunately XFglob is no longer included in XFCE and Efinder does not seem to work (at least for me), because it uses XFCEs glob command which is no longer available.
Main features:
- optional Perl-style regular expression syntax (grep -P)
- search for files owned by non-system user / group (find -nouser -nogroup)
- search files where the search pattern does not match
- exclude binary files from search
Files may be opened in your favorite editor by a double-click on an entry in the list of results. Right-clicking a file opens a context menu that allows to choose an arbitrary application to open this file.

File::Find is a Perl module to traverse a directory tree.

SYNOPSIS

use File::Find;
find(&wanted, @directories_to_search);
sub wanted { ... }

use File::Find;
finddepth(&wanted, @directories_to_search);
sub wanted { ... }

use File::Find;
find({ wanted => &process, follow => 1 }, .);

These are functions for searching through directory trees doing work on each file found similar to the Unix find command. File::Find exports two functions, find and finddepth. They work similarly but have subtle differences.

find

find(&wanted, @directories);
find(%options, @directories);

find() does a depth-first search over the given @directories in the order they are given. For each file or directory found, it calls the &wanted subroutine. (See below for details on how to use the &wanted function). Additionally, for each directory found, it will chdir() into that directory and continue the search, invoking the &wanted function on each file or subdirectory in the directory.

finddepth

finddepth(&wanted, @directories);
finddepth(%options, @directories);

finddepth() works just like find() except that is invokes the &wanted function for a directory after invoking it for the directorys contents. It does a postorder traversal instead of a preorder traversal, working from the bottom of the directory tree up where find() works from the top of the tree down.

FSlint project is a toolkit to find redundant/questionable disk usage. The FSlint command invokes the GUI interface. There is also a command line interface to each tool which can be accessed from the /usr/share/FSlint/fslint directory usually.
The command fslint is a wrapper for the various tools which can be called individually. All the tools (including fslint) have the same interface, which is basically:
command [-r] [-f] [path1 [path2]...]
where the paths are files &/or directories If no paths are specified then the current directory is assumed.
-r means do NOT recurse the specified director{y,ies}
-f means output full paths even if only 1 path specified
some tools have their own options. To get help on each tool do:
command --help
Any extra commands are passed to find, so any of filtering commands will work, for e.g the following means process the whole system but do not traverse onto any other mounted filesystems:
fslint / -xdev
Installation
RPM only. The only difference between the RPM and the source tarball is that the tarball has some extra test directories (fslint/tstlnt). To create the RPM just: rpmbuild -ta FSlint-x.xx.tar.gz
Enhancements:
- Added Spanish translation.
- Added a whitespace indenting checker/fixer.
- Added file rename functionality.
- Fixed multibyte encoding issues.
- Fixed rare issue where files could be deleted in error when merging duplicate files.

Penguin Cards project is a card game.
PenguinCards is a two-player card game. The aim is to find the pairs of cards on the board. The one who finds out more card pairs is the winner.
PenguinCards is a java-based game.
If you are unhappy with images on the cards, then simply copy your cards into images/pictures/penguins directory. That is it!
Enhancements:
- Initial release

Devel::FindGlobals is a Perl module to find global variables and their size.

SYNOPSIS

use Devel::FindGlobals;
print print_globals_sizes();

This module just runs around and over the symbol table, finds global variables, gets their sizes with Devel::Size, and then prints them out.

find_globals() just finds the globals (and returns a hashref), and find_globals_sizes() returns the globals and the sizes in a hashref. print_globals_sizes() prints out that data in a pretty table.

find_globals() hashref is of the form $hash->{TYPE}{NAME}, where TYPE is SCALAR, ARRAY, HASH (types stored in @Devel::FindGlobals::TYPES).

find_globals_sizes() hashref is the same, except that the value of the record is not 1 but an arrayref of size and total_size (size is the size of the variable itself, and total_size counts up all the other members of the variable, for arrayrefs and hashrefs).

print_globals_sizes() accepts an OPTIONS hash. Currently recognized options are:

ignore_files

Ignore file globals (like $main::_
ignore_undef_scalars

Ignore scalars that exist, but are not defined. Default value is true.

exclude_match

An arrayref of strings to match; e.g., [^VERSION$, ^Debug]. Will not print variables matching any of the expressions.

include_match

Same as exclude_match, except for variables to exclusively include, instead of strings to exclude.

lexicals

A hashref of name = reference> for lexical variables to include in the report.

File::Find::Closures is a Perl module with functions you can use with File::Find.

SYNOPSIS

use File::Find;
use File::Find::Closures qw(:all);

my( $wanted, $list_reporter ) = find_by_name( qw(README) );

File::Find::find( $wanted, @directories );
File::Find::find( { wanted => $wanted, ... }, @directories );

my @readmes = $list_reporter->();

SOME PARTS ARE NOT IMPLEMENTED YET! THIS IS ALPHA ALPHA SOFTWARE: A MERE SHELL OF AN IDEA.

I wrote this module as an example of both using closures and using File::Find. Students are always asking me what closures are good for, and heres some examples. The functions mostly stand alone (i.e. they dont need the rest of the module), so rather than creating a dependency in your code, just lift the parts you want).

When I use File::Find, I have two headaches---coming up with the &wanted function to pass to find(), and acculumating the files.

This module provides the &wanted functions as a closures that I can pass directly to find(). Actually, for each pre-made closure, I provide a closure to access the list of files too, so I dont have to create a new array to hold the results.

The filenames are the full path to the file as reported by File::Find.
Unless otherwise noted, the reporter closure returns a list of the filenames in list context and an anonymous array that is a copy (not a reference) of the original list. The filenames have been normalized by File::Spec::canonfile unless otherwise noted. The list of files has been processed by File::Spec::no_upwards so that "." and ".." (or their equivalents) do not show up in the list.

SYNOPSIS

use File::Find::Rule;
# find all the subdirectories of a given directory
my @subdirs = File::Find::Rule->directory->in( $directory );

# find all the .pm files in @INC
my @files = File::Find::Rule->file()
->name( *.pm )
->in( @INC );

# as above, but without method chaining
my $rule = File::Find::Rule->new;
$rule->file;
$rule->name( *.pm );
my @files = $rule->in( @INC );