File Coverage

blib/lib/File/chmod/Recursive.pm

Criterion	Covered	Total	%
statement	24	96	25.0
branch	0	54	0.0
condition	0	27	0.0
subroutine	8	12	66.6
pod	3	3	100.0
total	35	192	18.2

package File::chmod::Recursive;

#######################
# LOAD MODULES
#######################
use strict;
use warnings;
use Carp qw(croak carp);

use Cwd qw(abs_path);
use File::Find qw(find);
use File::chmod qw(chmod);

#######################
# VERSION
#######################
our $VERSION = '1.0.3';

#######################
# EXPORT
#######################
use base qw(Exporter);
our ( @EXPORT, @EXPORT_OK );

@EXPORT    = qw(chmod_recursive);
@EXPORT_OK = qw(chmod_recursive rchmod chmodr);

#######################
# CHMOD RECURSIVE
#######################
sub chmod_recursive {

    # Read Input
    my @in = @_;

    # Default mode
    my $mode = {
        files       => q(),
        dirs        => q(),
        match_dirs  => {},
        match_files => {},
        match       => {},
    };

    # Default _find_ settings
    my %find_settings = (
        follow   => 0,  # Do not Follow symlinks
        no_chdir => 1,  # Do not chdir
    );

    # Verbose mode
    my $verbose = 0;

    # Check Input
    my $dir;
    if ( ref $in[0] eq 'HASH' ) {

        # Usage chmod_recursive({}, $dir);

        # Get modes
        $mode->{files}       = $in[0]->{files}       || q();
        $mode->{dirs}        = $in[0]->{dirs}        || q();
        $mode->{match_files} = $in[0]->{match_files} || {};
        $mode->{match_dirs}  = $in[0]->{match_dirs}  || {};
        $mode->{match}       = $in[0]->{match}       || {};

        # Check for _find_ settings
        if ( $in[0]->{follow_symlinks} ) {
            $find_settings{follow}      = 1;  # Follow Symlinks
            $find_settings{follow_skip} = 2;  # Skip duplicates
        } ## end if ( $in[0]->{follow_symlinks...})
        if ( $in[0]->{depth_first} ) {
            $find_settings{bydepth} = 1;
        }

        # Verbose on/off
        $verbose = $in[0]->{verbose} || 0;

    } ## end if ( ref $in[0] eq 'HASH')

    else {

        # Usage chmod_recursive($mode, $dir);

        # Set modes
        $mode->{files} = $in[0];
        $mode->{dirs}  = $in[0];
    } ## end else [ if ( ref $in[0] eq 'HASH')]

    # Get directory
    $dir = $in[1] || croak "Directory not provided";
    $dir = abs_path($dir);
    croak "$dir is not a directory" unless -d $dir;

    # Run chmod
    my @updated;
    {

        # Turn off warnings for file find
        no warnings 'File::Find';

        # Turn off UMASK for File::chmod
        # See: https://github.com/xenoterracide/File-chmod/issues/5
        local $File::chmod::UMASK = 0;

        find(
            {
                %find_settings,
                wanted => sub {

                    # The main stuff

                    # Get full path
                    my $path = $File::Find::name;

                    if ( not -l $path ) { # Do not set permissions on symlinks

                        # Process files
                        if ( -f $path ) {

                            my $file_isa_match = 0;

                            # Process file Matches
                            foreach
                              my $match_re ( keys %{ $mode->{match_files} } )
                            {
                              next if $file_isa_match;
                              next unless ( $path =~ m{$match_re} );
                                $file_isa_match = 1;  # Done matching
                                if (
                                    chmod(
                                        $mode->{match_files}->{$match_re},
                                        $path
                                    )
                                  )
                                {
                                    push @updated, $path;
                                    warn "chmod_recursive: $path -> "
                                      . (
                                        sprintf "%#o",
                                        $mode->{match_files}->{$match_re}
                                      )
                                      . "\n"
                                      if $verbose;
                                } ## end if ( chmod( $mode->{match_files...}))
                            } ## end foreach my $match_re ( keys...)

                            # Process generic matches
                            foreach my $match_re ( keys %{ $mode->{match} } )
                            {
                              next if $file_isa_match;
                              next unless ( $path =~ m{$match_re} );
                                $file_isa_match = 1;
                                if (
                                    chmod(
                                        $mode->{match}->{$match_re},
                                        $path
                                    )
                                  )
                                {
                                    push @updated, $path;
                                    warn "chmod_recursive: $path -> "
                                      . (
                                        sprintf "%#o",
                                        $mode->{match}->{$match_re}
                                      )
                                      . "\n"
                                      if $verbose;
                                } ## end if ( chmod( $mode->{match...}))
                            } ## end foreach my $match_re ( keys...)

                            # Process non-matches
                            if (

                                # Skip processed
                                ( not $file_isa_match )

                                # And we're updating files
                                and ( $mode->{files} )

                                # And succesfully updated
                                and ( chmod( $mode->{files}, $path ) )
                              )
                            {
                                push @updated, $path;
                                warn "chmod_recursive: $path -> "
                                  . ( sprintf "%#o", $mode->{files} ) . "\n"
                                  if $verbose;
                            } ## end if ( ( not $file_isa_match...))
                        } ## end if ( -f $path )

                        # Process Dirs
                        elsif ( -d $path ) {

                            my $dir_isa_match = 0;

                            # Process Matches
                            foreach
                              my $match_re ( keys %{ $mode->{match_dirs} } )
                            {
                              next if $dir_isa_match;
                              next unless ( $path =~ m{$match_re} );
                                $dir_isa_match = 1;  # Done matching
                                if (
                                    chmod(
                                        $mode->{match_dirs}->{$match_re},
                                        $path
                                    )
                                  )
                                {
                                    push @updated, $path;
                                    warn "chmod_recursive: $path -> "
                                      . (
                                        sprintf "%#o",
                                        $mode->{match_dirs}->{$match_re}
                                      )
                                      . "\n"
                                      if $verbose;
                                } ## end if ( chmod( $mode->{match_dirs...}))
                            } ## end foreach my $match_re ( keys...)

                            # Process generic matches
                            foreach my $match_re ( keys %{ $mode->{match} } )
                            {
                              next if $dir_isa_match;
                              next unless ( $path =~ m{$match_re} );
                                $dir_isa_match = 1;  # Done matching
                                if (
                                    chmod(
                                        $mode->{match}->{$match_re},
                                        $path
                                    )
                                  )
                                {
                                    push @updated, $path;
                                    warn "chmod_recursive: $path -> "
                                      . (
                                        sprintf "%#o",
                                        $mode->{match}->{$match_re}
                                      )
                                      . "\n"
                                      if $verbose;
                                } ## end if ( chmod( $mode->{match...}))
                            } ## end foreach my $match_re ( keys...)

                            # Process non-matches
                            if (

                                # Skip processed
                                ( not $dir_isa_match )

                                # And we're updating files
                                and ( $mode->{dirs} )

                                # And succesfully updated
                                and ( chmod( $mode->{dirs}, $path ) )
                              )
                            {
                                push @updated, $path;
                                warn "chmod_recursive: $path -> "
                                  . ( sprintf "%#o", $mode->{dirs} ) . "\n"
                                  if $verbose;
                            } ## end if ( ( not $dir_isa_match...))
                        } ## end elsif ( -d $path )

                    } ## end if ( not -l $path )

                },
            },
            $dir
        );
    }

    # Done
  return scalar @updated;
} ## end sub chmod_recursive

#######################
# ALIASES
#######################
sub rchmod { return chmod_recursive(@_); }
sub chmodr { return chmod_recursive(@_); }

#######################
1;

__END__