root/cobra/trunk/Samples/Sizes.cobra

"""
sizes.cobra

The most effective technique to free up disk space on a drive is to look in the
directories that consume the most space. You may find entire directories that
can be deleted or excessively large files that are no longer needed. The first
time you do this, you might downsize the space consumed by a large factor with
only a few minutes of effort. Credit goes to the old "Dark Forest" application
on the old NeXTstep platform for introducing me to this approach.

This command line utility scans the current directory and its files for their
sizes, including all subdirectories. It then reports the total size and shows
the largest directories and files first. You can use this report to look for
large things to delete and rerun it as you progress. To run:

> cd \to\path\of\interest
> cobra \path\to\sizes.cobra

Unix users get a similar result with something like "du -k | sort -nr"

As an example, I ran `sizes` on a directory and it reported:

203658 directories and files read
180.30 seconds to read
21,297.34 MB

After spending 20 minutes cleaning up the biggest directories and files
that it listed, it then reported this:

186345 directories and files read
49.95 seconds to read
8,809.15 MB
"""

class FileNode implements IComparable
    """
    One of these will be created for every directory and file, and put into a
    list that can be sorted.
    """

    test
        a = FileNode('a', 100)
        assert a.pathName == 'a'
        assert a.numBytes == 100
        assert a.compareTo(nil) == 1
        b = FileNode('b', 200)
        assert a.compareTo(b) < 0
        assert b.compareTo(a) > 0
        c = FileNode('c', 100)
        assert a.compareTo(c) == 0

    var _pathName as String
    var _numBytes as decimal

    cue init(pathName as String, numBytes as decimal)
        _pathName = pathName
        _numBytes = numBytes

    get pathName from _pathName

    get numBytes from _numBytes

    def compareTo(obj as Object?) as int
        require
            obj is nil  or  obj inherits FileNode
        body
            if obj is nil
                return 1
            else if obj inherits FileNode
                return _numBytes.compareTo(obj.numBytes)
            else
                throw FallThroughException(obj)


class Dir
    """
    Dir does the work of scanning the files and subdirectories.
    This results in a tree-like structure that matches the file system.
    """

    shared
        var _sep    as char   # Path.directorySeparatorChar

    var _di         as DirectoryInfo
    var _dir        as Dir?  # parent directory
    var _baseName   as String
    var _pathName   as String

    var _files      as List<of FileInfo>
    var _subdirs    as List<of Dir>

    var _count      as int
    var _numBytes   as decimal  # using 'decimal' because FileInfo.length returns int64

    cue init(pathName as String)
        """ Creates a Dir from a filesystem path string. Scans all subdirs. """
        _di = DirectoryInfo(pathName)
        _pathName = pathName
        _baseName = pathName
        _init(nil)

    cue init(di as DirectoryInfo, parentDir as Dir)
        """ Creates a Dir from a parent Dir. Scans all subdirs. """
        _di = di
        _baseName = di.name
        _pathName = di.fullName
        _init(parentDir)

    get count from _count

    get numBytes from _numBytes

    def _init(parentDir as Dir?)
        assert _baseName.length
        _sep = Path.directorySeparatorChar
        _dir = parentDir
        if _dir, _pathName = '[_dir._pathName][_sep][_baseName]'
        _files = List<of FileInfo>()
        _subdirs = List<of Dir>()
        .scan

    def scan
        assert _pathName.length

        try
            dirInfo = DirectoryInfo(_pathName)
        catch IOException
            print 'warning: Unreadable directory:', _pathName
            return

        try
            files = dirInfo.getFiles
        catch IOException
            print 'warning: Unreadable files in directory:', _pathName
            return

        for fi in files
            try
                _files.add(fi)
                _count += 1
                _numBytes += fi.length to decimal
            catch IOException
                print 'warning: Cannot scan file:', fi.fullName

        for di in dirInfo.getDirectories
            d = Dir(di, this)
            _subdirs.add(d)
            _count += d.count
            _numBytes += d.numBytes
        
    get toList as List<of FileNode>
        """
        Returns a flat list containing self, all files and all subdirs (recursively).
        """
        t = List<of FileNode>()
        .populateList(t)
        return t

    def populateList(t as List<of FileNode>) is protected
        ensure
            t.count > old t.count
        body
            t.add(FileNode(_pathName, _numBytes))
            for fi in _files
                try
                    t.add(FileNode(fi.fullName, fi.length))
                catch IOException
                    print 'warning: Cannot scan file:', fi.fullName
            for subdir in _subdirs
                subdir.populateList(t)


class Sizes

    test
        assert _topPercent > 0.0 and _topPercent <= 1.0
        assert _divisor > 0.0
        assert _minSize >= 0.0

    shared
        var _topPercent = 0.1
        var _divisor = 1024 * 1024.0  # megabyte
        var _minSize = 1.0  # expressed in terms of _divisor
        var _divisorLabel = 'MB'

        def main
            print 'Scanning...'
            Console.out.flush
            start = DateTime.now
            args = CobraCore.commandLineArgs
            dirName = if(args.count > 1, args[1], Directory.getCurrentDirectory)
            topDir = Dir(dirName)
            duration = DateTime.now.subtract(start)
            print
            print '[topDir.count] directories and files read'
            print '[duration.totalSeconds:N] seconds to read'
            print '[topDir.numBytes/_divisor:N] [_divisorLabel]'
            print
            files = topDir.toList
            files.sort
            files.reverse
            n = (files.count*_topPercent) to int
            for i in n
                f = files[i]
                size = f.numBytes / _divisor
                if size < _minSize, break  # small files are uninteresting
                #print '%4i %7.1f %s' % (i+1, size, f.pathname)
                istr = (i+1).toString.padLeft(4)
                sizestr = size.toString('0.0').padLeft(7)
                print '[istr] [sizestr] [f.pathName]'