foamEtcFile

#!/bin/sh
#------------------------------------------------------------------------------
# =========                 |
# \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
#  \\    /   O peration     |
#   \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
#    \\/     M anipulation  | Copyright (C) 2017 OpenCFD Ltd.
#-------------------------------------------------------------------------------
# License
#     This file is part of OpenFOAM, licensed under GNU General Public License
#     <http://www.gnu.org/licenses/>.
#
# Script
#     foamEtcFile
#
# Description
#     Locate user/group/other file as per '#includeEtc'.
#
#     The -mode option can be used to allow chaining from personal settings
#     to site-wide settings.
#
#     For example, within the user ~/.OpenFOAM/<VER>/config.sh/compiler:
#     \code
#        eval $(foamEtcFile -sh -mode=go config.sh/compiler)
#     \endcode
#
#     The -mode option is similarly used within etc/{bashrc,cshrc} to ensure
#     that system prefs are respected:
#     \code
#        eval $(foamEtcFile -sh -mode=o  prefs.sh)
#        eval $(foamEtcFile -sh -mode=ug prefs.sh)
#     \endcode
#
# Environment
#     - WM_PROJECT:         (unset defaults to OpenFOAM)
#     - WM_PROJECT_SITE:    (unset defaults to PREFIX/site)
#     - WM_PROJECT_VERSION: (unset defaults to detect from path)
#
# Note
#     This script must exist in one of these locations:
#     - $WM_PROJECT_INST_DIR/OpenFOAM-<VERSION>/bin
#     - $WM_PROJECT_INST_DIR/openfoam-<VERSION>/bin
#     - $WM_PROJECT_INST_DIR/openfoam<VERSION>/bin  (debian version)
#
#-------------------------------------------------------------------------------
printHelp() {
    cat<<USAGE

Usage: foamEtcFile [OPTION] fileName
       foamEtcFile [OPTION] [-list|-list-test] [fileName]

options:
  -all (-a)         Return all files (otherwise stop after the first match)
  -list (-l)        List directories or files to be checked
  -list-test        List (existing) directories or files to be checked
  -mode=MODE        Any combination of u(user), g(group), o(other)
  -prefix=DIR       Specify an alternative installation prefix
  -version=VER      Specify alternative OpenFOAM version (eg, 3.0, 1612, ...)
  -csh              Produce output suitable for a csh or sh 'eval'
  -csh-verbose      As per -csh with additional verbosity
  -sh               Produce output suitable for a csh or sh 'eval'
  -sh-verbose       As per -sh  with additional verbosity
  -quiet (-q)       Suppress all normal output
  -silent (-s)      Suppress stderr, except -csh-verbose, -sh-verbose output
  -help             Print the usage

Locate user/group/other file as per '#includeEtc'

Do not group single character options.
Equivalent options:
  |  -mode=MODE     |  -mode MODE     | -m MODE
  |  -prefix=DIR    |  -prefix DIR    | -p DIR
  |  -version=VER   |  -version VER   | -v VER

Exit status
    0  when the file is found. Print resolved path to stdout.
    1  for miscellaneous errors.
    2  when the file is not found.

USAGE
    exit 0  # A clean exit
}


unset optQuiet optSilent
# Report error and exit
die()
{
    [ "${optQuiet:-$optSilent}" = true ] && exit 1
    exec 1>&2
    echo
    echo "Error encountered:"
    while [ "$#" -ge 1 ]; do echo "    $1"; shift; done
    echo
    echo "See 'foamEtcFile -help' for usage"
    echo
    exit 1
}

#-------------------------------------------------------------------------------
binDir="${0%/*}"                # The bin dir
projectDir="${binDir%/bin}"     # The project dir
prefixDir="${projectDir%/*}"    # The prefix dir (same as $WM_PROJECT_INST_DIR)

# Could not resolve projectDir, prefixDir? (eg, called as ./bin/foamEtcFile)
if [ "$prefixDir" = "$projectDir" ]
then
    binDir="$(cd $binDir && pwd -L)"
    projectDir="${binDir%/bin}"
    prefixDir="${projectDir%/*}"
fi
projectDirName="${projectDir##*/}"      # The project directory name

projectVersion="$WM_PROJECT_VERSION"    # Empty? - will be treated later
userDir="$HOME/.OpenFOAM"               # Hard-coded as per foamVersion.H

#-------------------------------------------------------------------------------

# Guess project version or simply get the stem part of the projectDirName.
# Handle standard and debian naming conventions.
#
# - projectVersion: update unless already set
#
# Helper variables:
# - dirBase (for reassembling name) == projectDirName without the version
# - versionNum (debian packaging)
unset dirBase versionNum
guessVersion()
{
    local version

    case "$projectDirName" in
    (OpenFOAM-* | openfoam-*)
        # Standard naming: OpenFOAM-<VERSION> or openfoam-<VERSION>
        dirBase="${projectDirName%%-*}-"
        version="${projectDirName#*-}"
        version="${version%%*-}" # Extra safety, eg openfoam-version-packager
        ;;

    (openfoam[0-9]*)
        # Debian naming: openfoam<VERSION>
        dirBase="openfoam"
        version="${projectDirName#openfoam}"
        versionNum="$version"

        # Convert digits version number to decimal delineated
        case "${#versionNum}" in (2|3|4)
            version=$(echo "$versionNum" | sed -e 's@\([0-9]\)@\1.@g')
            version="${version%.}"
            ;;
        esac

        # Ignore special treatment if no decimals were inserted.
        [ "${#version}" -gt "${#versionNum}" ] || unset versionNum
        ;;

    (*)
        die "unknown/unsupported naming convention for '$projectDirName'"
        ;;
    esac

    # Set projectVersion if required
    : ${projectVersion:=$version}
}


# Set projectVersion and update versionNum, projectDirName accordingly
setVersion()
{
    projectVersion="$1"

    # Need dirBase when reassembling projectDirName
    [ -n "$dirBase" ] || guessVersion

    # Debian: update x.y.z -> xyz version
    if [ -n "$versionNum" ]
    then
        versionNum=$(echo "$projectVersion" | sed -e 's@\.@@g')
    fi

    projectDirName="$dirBase${versionNum:-$projectVersion}"
}


optMode=ugo         # Default mode is always 'ugo'
unset optAll optList optShell optVersion

# Parse options
while [ "$#" -gt 0 ]
do
    case "$1" in
    -h | -help*)
        printHelp
        ;;
    -a | -all)
        optAll=true
        unset optShell
        ;;
    -l | -list)
        optList=true
        unset optShell
        ;;
    -list-test)
        optList='test'
        unset optShell
        ;;
    -csh | -sh | -csh-verbose | -sh-verbose)
        optShell="${1#-}"
        unset optAll
        ;;
    -mode=[ugo]*)
        optMode="${1#*=}"
        ;;
    -prefix=/*)
        prefixDir="${1#*=}"
        prefixDir="${prefixDir%/}"
        ;;
    -version=*)
        optVersion="${1#*=}"
        ;;
    -m | -mode)
        optMode="$2"
        shift
        # Sanity check. Handles missing argument too.
        case "$optMode" in
        ([ugo]*)
            ;;
        (*)
            die "invalid mode '$optMode'"
            ;;
        esac
        ;;
    -p | -prefix)
        [ "$#" -ge 2 ] || die "'$1' option requires an argument"
        prefixDir="${2%/}"
        shift
        ;;
    -q | -quiet)
        optQuiet=true
        ;;
    -s | -silent)
        optSilent=true
        ;;
    -v | -version)
        [ "$#" -ge 2 ] || die "'$1' option requires an argument"
        optVersion="$2"
        shift
        ;;
    --)
        shift
        break
        ;;
    -*)
        die "unknown option: '$1'"
        ;;
    *)
        break
        ;;
    esac
    shift
done


#-------------------------------------------------------------------------------

if [ -n "$optVersion" ]
then
    setVersion $optVersion
elif [ -z "$projectVersion" ]
then
    guessVersion
fi

# Updates:
# - projectDir  for changes via -prefix or -version
# - groupDir    for changes via -prefix
projectDir="$prefixDir/$projectDirName"
groupDir="${WM_PROJECT_SITE:-$prefixDir/site}"


# Debugging:
# echo "Installed locations:" 1>&2
# for i in projectDir prefixDir projectDirName projectVersion
# do
#     eval echo "$i=\$$i" 1>&2
# done


# Save the essential bits of information
# silently remove leading ~OpenFOAM/ (used in Foam::findEtcFile)
nArgs=$#
fileName="${1#~OpenFOAM/}"

# Define the various places to be searched:
unset dirList
case "$optMode" in (*u*) # (U)ser
    dirList="$dirList $userDir/$projectVersion $userDir"
    ;;
esac

case "$optMode" in (*g*) # (G)roup == site
    dirList="$dirList $groupDir/$projectVersion $groupDir"
    ;;
esac

case "$optMode" in (*o*) # (O)ther == shipped
    dirList="$dirList $projectDir/etc"
    ;;
esac
set -- $dirList


#
# The main routine
#

exitCode=0
if [ -n "$optList" ]
then

    # List directories, or potential file locations
    [ "$nArgs" -le 1 ] || \
    die "-list expects 0 or 1 filename, but $nArgs provided"

    # A silly combination, but -quiet does have precedence
    [ -n "$optQuiet" ] && exit 0

    # Test for directory or file too?
    if [ "$optList" = "test" ]
    then
        exitCode=2  # Fallback to a general error (file not found)

        if [ "$nArgs" -eq 1 ]
        then
            for dir
            do
                resolved="$dir/$fileName"
                if [ -f "$resolved" ]
                then
                    echo "$resolved"
                    exitCode=0  # OK
                fi
            done
        else
            for dir
            do
                if [ -d "$dir" ]
                then
                    echo "$dir"
                    exitCode=0  # OK
                fi
            done
        fi
    else
        for dir
        do
            echo "$dir${fileName:+/}$fileName"
        done
    fi

else

    [ "$nArgs" -eq 1 ] || die "One filename expected - $nArgs provided"

    exitCode=2  # Fallback to a general error (file not found)

    for dir
    do
        if [ -f "$dir/$fileName" ]
        then
            exitCode=0
            [ -n "$optQuiet" ] && break

            case "$optShell" in
            (*verbose)
                echo "Using: $dir/$fileName" 1>&2
                ;;
            esac

            case "$optShell" in
            csh*)
                echo "source $dir/$fileName"
                break
                ;;
            sh*)
                echo ". $dir/$fileName"
                break
                ;;
            *)
                echo "$dir/$fileName"
                [ -n "$optAll" ] || break
                ;;
            esac
        fi
    done

fi

exit $exitCode

#------------------------------------------------------------------------------