cqpkg

#!/bin/sh
# CQ Unix Toolkit
# Copyright (C) 2021 Wunderman Thompson Technology
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
_usage() {
    cat <<EOT
Usage: $(basename "${0}") [SPECIFICATION...] package-name
Create minimal empty CQ Vault ZIP package locally using provided specification
that can be uploaded to CRX/CQ Package Manager and built or installed.

Please note that all CQ-related files like 'nodetype.cnd' are added to package
during it's building (see 'cqbld' command).
 
Examples:
  cqpkg -r /content content           # Create package 'content-1.0.zip'
                                      # in current working directory named
                                      # 'content' that holds '/content' node
                                      # and all subnodes under it.

  cqpkg -r /content -o /tmp/pack.zip  # Create package 'pack.zip'
        content                       # in '/tmp' directory named
                                      # 'content' that holds '/content' node
                                      # and all subnodes under it.

  cqpkg -r /content -g mypackages     # Create package 'content-2.0.zip'
        -v 2.0 -d 'My first package'  # named content with version 2.0,
         content                      # with group 'mypackages' (as namespace)
                                      # with 'My first package' description
                                      # that holds /content node and all
                                      # subnodes under it

  cqpkg -r /content/dam               # Create dam-jpeg package
        -i '/content/dam(/[^/.]+)*(/[^/\.]+\.jpe?g(/.*)?)?$'
        dam-jpeg                      # that holds .jpeg or .jpg nodes
                                      # from /content/dam node.

Options:

  -g GROUP              define Vault group/namespace for package
  -v VERSION            define version for package
  -d DESCRIPTION        define user-friendly package description
  -r JCRPATH            define new filter root JCR path (allowed many times)
  -i REGEXP             define include regular expression (allowed many times)
                        for current filter root path (indicated by -r)
  -e REGEXP             define exclude regular expression (allowed many times)
                        for current filter root path (indicated by -r)
  -o ZIPPATH            generates package in path specified by ZIPPATH


EOT
    exit 1
}

_add_filter() {
    filter_definition=$(
        cat <<EOF
${filter_definition}
<filter root="${1}">
EOF
    )
}

_add_include_entry() {
    filter_definition=$(
        cat <<EOF
${filter_definition}
  <include pattern="${1}"/>
EOF
    )
}

_add_exclude_entry() {
    filter_definition=$(
        cat <<EOF
${filter_definition}
  <exclude pattern="${1}"/>
EOF
    )
}

CWD=$(dirname "${0}")
API="${CWD}/cqapi"
"${API}" -P >/dev/null
if [ ${?} -ne 0 ]; then
    echo "Fatal: cannot find or test cqapi command" >&2
    exit 1
fi

filter_definition=$(
    cat <<EOT
<?xml version="1.0" encoding="UTF-8"?>
<workspaceFilter version="1.0">
EOT
)
toolkit_version=$("${API}" -v)
package_definition=$(
    cat <<EOT
<?xml version="1.0" encoding="utf-8" standalone="no"?>
<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
<properties>
<comment>FileVault Package Properties</comment>
<entry key="createdBy">cq-unix-toolkit</entry>
<entry key="buildCount">1</entry>
<entry key="dependencies"/>
<entry key="packageFormatVersion">2</entry>
EOT
)

description="Package genereated by CQ Unix Toolkit ${toolkit_version}"
in_filter_context=0
version="1.0"

while getopts ":g:v:r:i:e:o:d:" opt; do
    case "${opt}" in
    g)
        group="${OPTARG}"
        ;;
    v)
        version="${OPTARG}"
        ;;
    d)
        description="${OPTARG}"
        ;;
    o)
        zipfilename="${OPTARG}"
        ;;
    r)
        if [ ${in_filter_context} -eq 1 ]; then
            filter_definition="${filter_definition}\n</filter>"
        fi
        in_filter_context=1
        _add_filter "${OPTARG}"
        ;;
    i)
        if [ ${in_filter_context} -eq 0 ]; then
            echo "Include pattern (-i) should be nested in scope of" \
                "filter root path (-r)." >&2
            echo "Please add -r JCRPATH before adding -i/-e options." >&2
            exit 1
        fi
        _add_include_entry "${OPTARG}"
        ;;
    e)
        if [ ${in_filter_context} -eq 0 ]; then
            echo "Exclude pattern (-e) should be nested in scope of" \
                "filter root path (-r)." >&2
            echo "Please add -r JCRPATH before adding -i/-e options." >&2
            exit 1
        fi
        _add_exclude_entry "${OPTARG}"
        ;;
    \?)
        echo "Invalid option: -${OPTARG}" >&2
        _usage
        ;;
    :)
        echo "Option -${OPTARG} requires an argument." >&2
        _usage
        ;;
    esac
done
shift $((OPTIND - 1))

if [ ${#} -ne 1 ]; then
    _usage
fi
group_entry=$(
    cat <<EOT
<entry key="group">${group}</entry>
EOT
)
name=${1}
dir=$(pwd)
if [ -z "${zipfilename}" ]; then
    zipfile="${dir}/${name}-${version}.zip"
else
    zipfile=$(
        cd $(dirname "${zipfilename}")
        pwd
    )/$(basename "${zipfilename}")
fi

filter_definition=$(
    cat <<EOT
${filter_definition}
</filter>
</workspaceFilter>
EOT
)
package_definition=$(
    cat <<EOT
${package_definition}
${group_entry}
<entry key="name">${name}</entry>
<entry key="version">${version}</entry>
<entry key="description">${description}</entry>
</properties>
EOT
)
ZIP=$(which zip)
if [ ${?} -ne 0 -o "${ZIP}" = "" ]; then
    echo "Cannot find zip packaging command-line tool. Aborted" >&2
    exit 2
fi
tempdir=$(mktemp -d cqpkgXXXXXXXXXX)
exitcode=${?}
if [ ${exitcode} -ne 0 ]; then
    echo "Cannot create temporary directory ${tempdir}. Aborted" >&2
    exit 1
fi
vault="${tempdir}/META-INF/vault"
mkdir -p "${tempdir}/jcr_root"
mkdir -p "${vault}"

printf "%s" "${filter_definition}" >"${vault}/filter.xml"
printf "%s" "${package_definition}" >"${vault}/properties.xml"
cd "${tempdir}"
"${ZIP}" -q -r - ./ >"${zipfile}"
exitcode=${?}
cd "${dir}"
if [ ${exitcode} -ne 0 ]; then
    echo "Cannot create zip package properly." >&2
fi
rm "${vault}/filter.xml"
rm "${vault}/properties.xml"
rmdir "${tempdir}/jcr_root"
rmdir "${tempdir}/META-INF/vault"
rmdir "${tempdir}/META-INF"
rmdir "${tempdir}"

if [ ${exitcode} -eq 0 ]; then
    echo "Empty package created: '${zipfile}'"
else
    exit 3
fi