Blob Blame History Raw
#!perl -w
use strict;
use File::Find::Object::Rule;
use File::Spec::Functions qw(catdir);

# bootstrap extensions
for (@INC) {
    my $dir = catdir($_, qw( File Find Rule ) );
    next unless -d $dir;
    my @pm = find( name => '*.pm', maxdepth => 1,
                   exec => sub { my $name = $_[0]; $name =~ s/\.pm$//;
                                 eval "require File::Find::Object::Rule::$name"; },
                   in => $dir );

# what directories are we searching in?
my @where;
while (@ARGV) {
    local $_ = shift @ARGV;
    if (/^-/) {
        unshift @ARGV, $_;
    push @where, $_;

# parse arguments, build a rule object
my $rule = new File::Find::Object::Rule;
while (@ARGV) {
    my $clause = shift @ARGV;

    unless ( $clause =~ s/^-// && $rule->can( $clause ) ) {
        # not a known rule - complain about this
        die "unknown option '$clause'\n"

    # it was the last switch
    unless (@ARGV) {

    # consume the parameters
    my $param = shift @ARGV;

    if ($param =~ /^-/) {
        # it's the next switch - put it back, and add one with no params
        unshift @ARGV, $param;

    if ($param eq '(') {
        # multiple values - just look for the closing parenthesis
        my @p;
        while (@ARGV) {
            my $val = shift @ARGV;
            last if $val eq ')';
            push @p, $val;
        $rule->$clause( @p );

    # a single argument
    $rule->$clause( $param );

# add a print rule so things happen faster
$rule->exec( sub { print "$_[2]\n"; return; } );

# profit
$rule->in( @where ? @where : '.' );
exit 0;


=head1 NAME

findorule - command line wrapper to File::Find::Object::Rule

=head1 USAGE

  findorule [path...] [expression]


C<findorule> mostly borrows the interface from GNU find(1) to provide a
command-line interface onto the File::Find::Object::Rule heirarchy of modules.

The syntax for expressions is the rule name, preceded by a dash,
followed by an optional argument.  If the argument is an opening
parenthesis it is taken as a list of arguments, terminated by a
closing parenthesis.

Some examples:

 find -file -name ( foo bar )

files named C<foo> or C<bar>, below the current directory.

 find -file -name foo -bar

files named C<foo>, that have pubs (for this is what our ficticious
C<bar> clause specifies), below the current directory.

 find -file -name ( -bar )

files named C<-bar>, below the current directory.  In this case if
we'd have omitted the parenthesis it would have parsed as a call to
name with no arguments, followed by a call to -bar.

=head2 Supported switches

I'm very slack.  Please consult the File::Find::Object::Rule manpage for now,
and prepend - to the commands that you want.

=head2 Extra bonus switches

findorule automatically loads all of your installed File::Find::Object::Rule::*
extension modules, so check the documentation to see what those would be.

=head1 AUTHOR

Richard Clamp <> from a suggestion by Tatsuhiko Miyagawa

Adapted to L<File::Find::Object::Rule> by Shlomi Fish (all copyrights


Copyright (C) 2002 Richard Clamp.  All Rights Reserved.

This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.

=head1 SEE ALSO