Subversion Repositories DevTools

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

# CLASS Clearcase::LsCmd

# This class inherits from the CCCmpdProc and executes the cleartool command

# "ls" with args "-recurse -long" to list all files in cwd.

#

# It overrider the CCProcess member to process the resultant output from the ls

# command and store information about all files/dirs in and below the pwd.

# 

# It uses the CCIgnore class to determine if a file should be ignored or included

# in the processing of the cmd output.

#

# It stores as a result of the command for each file/dir

# NAME      = The full path of the file (as defined by CCCmdProc)

# STATE     = File NAME State (CHECKEDOUT, CHECKIN, PRIVATE)

# VERSION   = If state=CHECKEDIN Then current version of NAME in view 

#             If state=CHECKEDOUT Then version of NAME that the checkout was from

# ANNOTATION= Any Special Annotations returned by ls on NAME

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

package Clearcase::LsCmd;

use strict;

use Cwd qw/ abs_path /;

use DeployUtils::Logger;

use Clearcase::IgnoreList;

use Clearcase::CmdProc;

use vars qw( @ISA );

@ISA = qw( Clearcase::CmdProc );

# Globally defined states

our $StateCheckedIn  = "CHECKEDIN";

our $StateCheckedOut = "CHECKEDOUT";

our $StatePrivate    = "PRIVATE";

#==============================================================================

#   Constructor

#==============================================================================

sub new

{

    my $obclass = shift;

    my $class = ref($obclass) || $obclass;

    my $dir = shift;

    LogDebug("Clearcase::LsCmd::new Instantiating new object of class $class");

    # if no dir of dir is "." the get full absolute path, abs_path returns path with "/" regardless of platform

    $dir = abs_path(".") if ( ! defined($dir) || $dir eq "." );    

    # however if passed in make sure we change \ to /

    $dir =~ s|\\|/|g;

    # Call base class's constructor

    my $self = $class->SUPER::new();

    # Add this class's data to the class object

    $self->{_FINDDIR} = $dir;

    $self->{_IGNOREFILES} = 1;

    $self->{_IGNORECOUNT} = 0;

    #indexes used

    # State index is a hash of hashes of arrays.  The contents of _STATE are hashes keyed on global states

    # These hashes contain an array of element numbers into the FILEINFO array

    # The branch & annotation are similar but keyed on branches and annotations

    $self->{_STATE}      = {};

    $self->{_BRANCH}     = {};

    $self->{_ANNOTATION} = {};

    bless($self, $class);

    # set Clearcase command and arg

    $self->CCcmd("ls");

    $self->CCargs("-long");

    return $self;

}   # new

#==============================================================================

#   ignoreFiles

# Sets & returns the ignore files variable that determines whether to use the 

# IgnoreFiles class for files to ignore

#==============================================================================

sub ignoreFiles

{

    my $self = shift;

    if ( @_ )

    {

        $self->{_IGNOREFILES} = shift;

        LogDebug("ClearCase::LsCmd::ignoreFiles Set to $self->{_IGNOREFILES}");

    }

    return $self->{_IGNOREFILES};

}   # ignoreFiles

#==============================================================================

#   CCexecute

# simply adds dir to args and runs base class CCexecute

#==============================================================================

sub CCexecute

{

    my $self = shift;

    my $args = $self->CCargs();

    # search directory first

    $self->CCargs("$args -directory $self->{_FINDDIR}");

    $self->SUPER::CCexecute();

    # now serach the contents

    $self->CCargs("$args -recurse $self->{_FINDDIR}");

    $self->SUPER::CCexecute();

}   # CCexecute

#==============================================================================

#   CCprocess overrides base class's CCProcess to process result

#==============================================================================

sub CCprocess

{

    my $self = shift;

    my $line;

    my ($name, $state, $version, $branch, $annotation ) = ( "", "", "", "", "" );

    my $index;

    my $dirRE = $self->{_FINDDIR};

    # Change the search RE for the findDir so that all occurances of "/" in path are changed to "[/\\]" 

    # to match either type of path separator

    $dirRE =~ s|/|\[/\\\\\]|g;

NEXTLINE:

    while ( $line = $self->getline() )

    {

        chomp $line;

        $line =~ s/\r//g;    # remove carraige returns

        # ignore blank lines or lines with directory ".*" with quotes

        next NEXTLINE if ( $line =~ /^\s*$/ || $line =~ /directory\s*\".*\":/ );

        if ( $line =~ /^view private object\s*(.*)\s*$/ )

        {

            $name       = $1;

            $state      = $StatePrivate;

            $version    = "";

            $branch     = "";

            $annotation = "";

            if ( $self->{_IGNOREFILES} && Clearcase::IgnoreList->ignoreFile($name) )

            {

                LogDebug("Clearcase::LsCmd::CCProcess Ignoring Private file $name");

                $self->{_IGNORECOUNT}++;

                next NEXTLINE;

            }

        }

        elsif ( $line =~ /^(?:directory |)version\s*(.*)\@\@(.*)$/ )

        {

            # got the file name, & rest of line

            $name = $1;

            $line = $2;

            # remove the Rule: from the end of the line as we dont need it

            $line =~ s/\s*Rule: .*$//;

            # Check for annotations & store, removing from line

            $line =~ s/\s*\[(.*)\]\s*$//;

            if ( defined($1) )

            {   $annotation = $1; }

            else

            {   $annotation = ""; }

            # See if Checked out state

            if ( $line =~ /^.*CHECKEDOUT from (.*)$/ )

            {

                $state = $StateCheckedOut;

                $version = $1;  # version is version checked out from

            }

            else

            {

                $state = $StateCheckedIn;

                $version = $line;

            }

            $branch = $version;

            # remove version number and dir separator from version to get branch

            $branch =~ s|[/\\]\d*$||;

        }

        else

        {

            LogError("-x", "Clearcase::LsCmd::CCprocess Unknown Input Line as follows");

            LogError("$line");

        }                                                                        

        # Remove findDir from path if find dir is same as pwd, makes it less clutered

        $name =~ s|$dirRE|\.| if ( $self->CCcwd() =~ m|^$dirRE| );

        # Add name to file list and set it as current element

        $index = $self->addToFileList($name);

        # now add other elements, the index is remembered in the base class

        $self->updateCurrentFile("STATE", $state, "VERSION", $version, "ANNOTATION", $annotation);

        # update indexes

        push(@{$self->{_STATE}{$state}}, $index);

        push(@{$self->{_BRANCH}{$branch}}, $index) if ( $branch ne "" );

        push(@{$self->{_ANNOTATION}{$annotation}}, $index) if ( $annotation ne "" );

    }

}   # process

#==============================================================================

#   getNumByState - Returns the number of items found by state

#==============================================================================

sub getNumByState

{

    my $self = shift;

    my $state = shift;

    my $retval;

    if ( $state eq $StateCheckedIn )

    {

        $retval = $#{$self->{_STATE}{$StateCheckedIn}} + 1;

    }

    elsif ( $state eq $StateCheckedOut )

    {

        $retval = $#{$self->{_STATE}{$StateCheckedOut}} + 1;

    }

    elsif ( $state eq $StatePrivate )

    {

        $retval = $#{$self->{_STATE}{$StatePrivate}} + 1;

    }

    else

    {

        LogError("Clearcase::LsCmd::getNumByState Invalid State supplied");

    }

    return $retval;

}   # getNumByState

#==============================================================================

#   getListByState - Returns a reference to an array of files by state

#==============================================================================

sub getListByState

{

    my $self = shift;

    my $state = shift;

    my @retval;

    if ( $state eq $StateCheckedIn )

    {

        foreach my $index ( @{$self->{_STATE}{$StateCheckedIn}} )

        {

            push(@retval, $self->getElement($index)->{NAME});

        }

    }

    elsif ( $state eq $StateCheckedOut )

    {

        foreach my $index ( @{$self->{_STATE}{$StateCheckedOut}} )

        {

            push(@retval, $self->getElement($index)->{NAME});

        }

    }

    elsif ( $state eq $StatePrivate )

    {

        foreach my $index ( @{$self->{_STATE}{$StatePrivate}} )

        {

            push(@retval, $self->getElement($index)->{NAME});

        }

    }

    else

    {

        LogError("Clearcase::LsCmd::getListByState Invalid State supplied");

    }

    return \@retval;

}   # getListByState

#==============================================================================

#   getNumBranches - Returns number of branches found

#==============================================================================

sub getNumBranches

{

    my $self = shift;

    return scalar keys %{$self->{_BRANCH}};

}   # getNumBranches

#==============================================================================

#   getListBranches - Returns a reference to an array of branches found

#==============================================================================

sub getListBranches

{

    my $self = shift;

    my @retval;

    @retval = keys %{$self->{_BRANCH}};

    return \@retval;

}   # getListBranches

#==============================================================================

#   getNumFilesByBranch - Returns the number of files associated to the supplied branch

#==============================================================================

sub getNumFilesByBranch

{

    my $self = shift;

    my $branch = shift;

    my $retval = undef;

    if ( defined($branch) && defined($self->{_BRANCH}{$branch}) )

    {

        $retval = $#{$self->{_BRANCH}{$branch}} + 1;

    }

    return $retval;

}   # getNumFilesByBranch

#==============================================================================

#   getListFilesByBranch - Returns a reference to an array of files found in the

# supplied branch

#==============================================================================

sub getListFilesByBranch

{

    my $self = shift;

    my $branch = shift;

    my @retval;

    if ( defined($branch) && defined($self->{_BRANCH}{$branch}) )

    {

        foreach my $index ( @{$self->{_BRANCH}{$branch}} )

        {

            push(@retval, $self->getElement($index)->{NAME});

        }

    }

    return \@retval;

}   # getListFilesByBranch

#==============================================================================

#   getNumAnnotations - Returns number of Annotations found

#==============================================================================

sub getNumAnnotations

{

    my $self = shift;

    return scalar keys %{$self->{_ANNOTATION}};

}   # getNumAnnotations

#==============================================================================

#   getListAnnotations - Returns a reference to an array of Annotations found

#==============================================================================

sub getListAnnotations

{

    my $self = shift;

    my @retval;

    @retval = keys %{$self->{_ANNOTATION}};

    return \@retval;

}   # getListAnnotations

#==============================================================================

#   getNumFilesByAnnotation - Returns the number of files associated to the supplied Annotation

# If supplied is all then it returns the total number of files with annotations

#==============================================================================

sub getNumFilesByAnnotation

{

    my $self = shift;

    my $annotation = shift;

    my $retval = undef;

    if ( defined($annotation) )

    {

        if ( $annotation =~ /all/i )

        {

            $retval = 0;

            foreach my $annot ( keys %{$self->{_ANNOTATION}} )

            {

                $retval += $#{$self->{_ANNOTATION}{$annot}} + 1

            }

        }

        if ( defined($self->{_ANNOTATION}{$annotation}) )

        {

            $retval = $#{$self->{_ANNOTATION}{$annotation}} + 1;

        }

    }

    return $retval;

}   # getNumFilesByAnnotation

#==============================================================================

#   getListFilesByAnnotation - Returns a reference to an array of files found 

# with the supplied Annotation

#==============================================================================

sub getListFilesByAnnotation

{

    my $self = shift;

    my $annotation = shift;

    my @retval;

    if ( defined($annotation) && defined($self->{_ANNOTATION}{$annotation}) )

    {

        foreach my $index ( @{$self->{_ANNOTATION}{$annotation}} )

        {

            push(@retval, $self->getElement($index)->{NAME});

        }

    }

    return \@retval;

}   # getListFilesByAnnotation

#==============================================================================

# getNumIgnored

# Returns the number of files ignored.

#==============================================================================

sub getNumIgnored

{

    my $self = shift;

    return $self->{_IGNORECOUNT};

}   # getNumIgnored

1;