1

#!/bin/bash

     2

# vim: set ft=sh :

     3

#

     4

# Dependency-based updates + utils

     5

     6

## Compare the given output file with all given source files:

     7

#

     8

#   check_update $out ${deps[@]} && do_update $out ... || ...

     9

#

    10

# Returns true if the output file needs to be updated.

    11

function check_update {

    12

    # target

    13

    local out=$1; shift

    14

    15

    debug "$out"

    16

    17

    # need update?

    18

    local update=

    19

    20

    if [ ${#@} == 0 ]; then

    21

        debug "  update: unknown deps"

    22

        update=y

    23

    24

    elif [ ! -e $out ]; then

    25

        debug "  update: dest missing"

    26

        update=y

    27

    28

    elif [ $UPDATE_FORCE ]; then

    29

        debug "  update: forced"

    30

        update=y

    31

    fi

    32

    33

    # check deps

    34

    for dep in "$@"; do

    35

        # don't bother checking if already figured out

    36

        [ $update ] && continue

    37

    38

        # check

    39

        if [ ! -e $ROOT/$dep ]; then

    40

            fail "$dst: Missing source: $dep"

    41

    42

        elif [ $ROOT/$out -ot $ROOT/$dep ]; then

    43

            debug "  update: $dep"

    44

            update=y

    45

        else

    46

            debug "  check: $dep"

    47

        fi

    48

    done

    49

    50

    [ ! $update ] && debug "  up-to-date"

    51

    52

    # return

    53

    [ $update ]

    54

}

    55

    56

## Generate updated output file from given command's stdout:

    57

#

    58

#   do_update $out $BIN/cmd --args

    59

#

    60

# Writes output to a temporary .new file, optionally shows a diff of changes, and commits

    61

# the new version to $out (unless noop'd).

    62

function do_update {

    63

    local out=$1; shift

    64

    local tmp=$out.new

    65

    66

    debug "$out"

    67

    cmd "$@" > $ROOT/$tmp

    68

    69

    # compare

    70

    if [ -e $ROOT/$out ] && [ $UPDATE_DIFF ]; then

    71

        debug "  changes:"

    72

    73

        # terse

    74

        indent "        " diff --unified=1 $ROOT/$out $ROOT/$tmp || true

    75

    fi

    76

    77

    # deploy

    78

    if [ $UPDATE_NOOP ]; then

    79

        # cleanup

    80

        debug "  no-op"

    81

    82

        cmd rm $ROOT/$tmp

    83

    else

    84

        # commit

    85

        debug "  deploy"

    86

    87

        cmd mv $ROOT/$tmp $ROOT/$out

    88

    fi

    89

}

    90

    91

## Look for a link target:

    92

#

    93

#   find_link   $lnk    $tgt...

    94

#

    95

# Outputs the first given target to exist, skipping any that are the same as the given $lnk.

    96

# If no $tgt matches, outputs the last one, or '-'.

    97

function choose_link {

    98

    local lnk=$1; shift

    99

    local tgt=-

   100

   101

    for tgt in "$@"; do

   102

        [ $tgt != $out ] && [ -e $ROOT/$tgt ] && break

   103

    done

   104

   105

    echo $tgt

   106

}

   107

   108

   109

## Compare symlink to target:

   110

#

   111

#   check_link $lnk $tgt && do_link $lnk $tgt || ...

   112

#

   113

# Tests if the symlink exists, and the target matches.

   114

# Fails if the target does not exist.

   115

function check_link {

   116

    local lnk=$1

   117

    local tgt=$2

   118

   119

    [ ! -e $ROOT/$tgt ] && fail "$tgt: target does not exist"

   120

   121

    [ ! -e $ROOT/$lnk ] || [ $(readlink $ROOT/$lnk) != $ROOT/$tgt ]

   122

}

   123

   124

## Update symlink to point to target:

   125

#

   126

#   do_link $lnk $tgt

   127

#

   128

function do_link {

   129

    local lnk=$1

   130

    local tgt=$2

   131

   132

    cmd ln -sf $ROOT/$tgt $ROOT/$lnk

   133

}

   134