cisco_node_utils 1.0.1 → 1.1.0

data/bin/git/hooks/commit-msg/enforce_style

@@ -0,0 +1,81 @@
+#!/usr/bin/env ruby
+#
+# Enforce rules of good commit message style
+# http://chris.beams.io/posts/git-commit/#seven-rules
+
+message_file = ARGV[0]
+full_message = File.read(message_file)
+message_lines = full_message.split("\n")
+# Omit comment lines - they don't need to be validated!
+message_lines = message_lines.select { |i| i.empty? || i[/^[^#]/] }
+
+$errors = 0 # rubocop:disable Style/GlobalVars
+
+def failure(msg)
+  if STDOUT.tty?
+    puts "\t...[ \033[31mFAIL\033[0m ] #{msg}"
+  else
+    puts msg
+  end
+  $errors += 1 # rubocop:disable Style/GlobalVars
+end
+
+# 1. Separate subject from body with a blank line
+if message_lines.length > 1
+  unless message_lines[1].empty?
+    failure 'Separate subject (first line) from body with a blank line'
+  end
+end
+
+# 2. Limit the subject line to 50 characters
+if message_lines.first.length > 50
+  failure 'First line of commit message should be no more than 50 characters'
+  puts message_lines.first
+  puts '^' * 50
+end
+
+# 3. Capitalize the subject line
+unless message_lines.first =~ /^[A-Z]/
+  failure 'Begin commit message subject line with a capital letter'
+end
+
+# 4. Do not end the subject line with a period
+if message_lines.first =~ /[!.,;]\s*$/
+  failure 'Do not end the subject line with punctuation'
+end
+
+# 5. Use the imperative mood in the subject line
+# This is very hard to enforce by automation, so
+# let's just check some likely cases:
+non_imperatives = [/adds$/,
+                   /added$/,
+                   /change[ds]$/,
+                   /fixe[ds]$/,
+                   /merge[ds]$/,
+                   /remove[ds]$/,
+                   /update[ds]$/,
+                  ]
+s = message_lines.first.split(' ').first.downcase
+if non_imperatives.any? { |re| re.match(s) }
+  failure 'Use the imperative mood in the subject line'
+end
+
+# 6. Wrap the body at 72 characters
+if message_lines.any? { |line| line.length > 72 }
+  failure 'Wrap the body at 72 characters'
+  puts '-' * 72
+  puts message_lines.select { |line| line.length > 72 }.join("\n")
+  puts '-' * 72
+end
+
+# 7. Use the body to explain what and why vs. how
+# The user will just need to exercise judgment on this one :)
+
+if $errors > 0 # rubocop:disable Style/GlobalVars
+  puts 'Rejected commit message:'
+  puts '{'
+  puts message_lines.join("\n")
+  puts '}'
+end
+
+exit $errors # rubocop:disable Style/GlobalVars

data/bin/git/hooks/hook_lib

@@ -0,0 +1,108 @@
+#!/bin/bash
+#
+# Shared library for git hooks
+
+# Colors
+DULL=0
+FG_BLACK=30
+FG_RED=31
+FG_GREEN=32
+FG_YELLOW=33
+FG_BLUE=34
+FG_MAGENTA=35
+FG_CYAN=36
+FG_WHITE=37
+FG_NULL=00
+BG_NULL=00
+ESC="["
+RESET="${ESC}0m"
+BOLD="${ESC}1m"
+BLACK="${ESC}${DULL};${FG_BLACK}m"
+RED="${ESC}${DULL};${FG_RED}m"
+GREEN="${ESC}${DULL};${FG_GREEN}m"
+YELLOW="${ESC}${DULL};${FG_YELLOW}m"
+BLUE="${ESC}${DULL};${FG_BLUE}m"
+MAGENTA="${ESC}${DULL};${FG_MAGENTA}m"
+CYAN="${ESC}${DULL};${FG_CYAN}m"
+WHITE="${ESC}${DULL};${FG_WHITE}m"
+
+# Top-level directory of our repository
+export REPO_DIR="$(git rev-parse --show-toplevel 2>/dev/null)"
+
+#DEBUG=1
+debug() {
+    [ "$DEBUG" == 1 ] && echo $1
+}
+export -f debug
+
+script_name() {
+    echo -e "*** ${BLUE}Running Git hook script: $*${RESET}..."
+}
+export -f script_name
+
+step_name() {
+    echo -e "\t${BOLD}$*${RESET}"
+}
+export -f step_name
+
+success() {
+    echo -e "\t...[ ${GREEN}OK${RESET} ]"
+}
+export -f success
+
+fail() {
+    local RC=$1
+    local msg=$2
+    echo -e "\t...[ ${RED}FAIL${RESET} ] $msg"
+    exit $RC
+}
+export -f fail
+
+check_rc() {
+    rc=$?
+    [ $rc -eq 0 ] || fail $rc "$*"
+    return $rc
+}
+export -f check_rc
+
+check_rc_optional() {
+    local RC=$?
+    local msg=$1
+    [ $RC -eq 0 ] && return $RC
+    echo -e "\t...[ ${YELLOW}WARNING${RESET} ] $msg"
+    read -p "Continue anyway? [y/N] " yn < /dev/tty
+    case $yn in
+      [Yy]* ) return 0;;
+      [Nn]* ) exit $RC;;
+      * ) exit $RC;;
+    esac
+}
+export -f check_rc_optional
+
+get_last_version() {
+    # Get the first subheading in the CHANGELOG, not counting 'Unreleased'
+    VER=$(grep -v "Unreleased" $REPO_DIR/CHANGELOG.md | egrep -m 1 '## \[.*]' | cut -d ' ' -f 2 | tr -d '[]')
+    echo "Detected previous release version as '$VER'"
+}
+export -f get_last_version
+
+add_changelog_diff_link() {
+    local OLD_VERSION=$1
+    local NEW_VERSION=$2
+
+    step_name "Adding link for diffs $OLD_VERSION..$NEW_VERSION in CHANGELOG.md"
+
+    # Automatically add diff link to the CHANGELOG
+    sed -i "/master...develop/ a\
+[$VERSION]: https://github.com/cisco/cisco-network-node-utils/compare/$OLD_VERSION...$NEW_VERSION" $REPO_DIR/CHANGELOG.md
+}
+export -f add_changelog_diff_link
+
+set_gem_version() {
+    local VERSION=$1
+
+    step_name "Updating version.rb to version '$VERSION'"
+
+    sed -i -e "s/VERSION =.*/VERSION = '$VERSION'/" $REPO_DIR/lib/cisco_node_utils/version.rb
+}
+export -f set_gem_version

data/bin/git/hooks/hooks-wrapper

@@ -0,0 +1,38 @@
+#!/bin/bash
+#
+# Generic git hook. Calls all associated helper scripts.
+#
+# Based on:
+# http://stackoverflow.com/questions/8730514/chaining-git-hooks
+# https://github.com/henrik/dotfiles/blob/master/git_template/hooks/pre-commit
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+
+. "$GIT_DIR"/hooks/hook_lib
+
+# What hook are we supposed to be?
+hookname=`basename $0`
+
+debug "Running wrapper script for '$hookname'..."
+
+exitcodes=()
+
+# Run each hook, passing through STDIN and storing the exit code.
+# We don't want to bail at the first failure, so the user can see everything.
+
+for hook in "$GIT_DIR"/hooks/$hookname-*; do
+    debug "Checking hook '$hook'"
+    test -x "$hook" || continue
+    script_name "${hook##*/}"
+    "$hook" "$@"
+    rc=$?
+    [ "$rc" == 0 ] && success
+    exitcodes+=($rc)
+done
+
+# If any exit code isn't 0, bail.
+for i in "${exitcodes[@]}"; do
+    [ "$i" == 0 ] || fail $i "One or more hook scripts reported an error"
+done
+debug "Wrapper script executed successfully"
+exit 0

data/bin/git/hooks/post-flow-hotfix-start/update-version

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+VERSION=$1
+debug "Detected VERSION as '$VERSION'"
+STRIP_VERSION=$(echo "$VERSION" | tr -c -d '0-9.')
+debug "Detected STRIP_VERSION as '$STRIP_VERSION'"
+
+LAST_VERSION=get_last_version
+
+step_name "Adding new release subheading in CHANGELOG.md"
+
+# Automatically update the CHANGELOG to mark the new release.
+# Unlike our post-flow-release-start script, there is no'Unreleased' tag
+# so we just insert the new version number immediately after the header
+sed -i "/^=========$/ a\
+\\\n## [$VERSION] - $(date +%Y-%m-%d)\nTODO
+" "$REPO_DIR/CHANGELOG.md"
+
+add_changelog_diff_link "$LAST_VERSION" "$STRIP_VERSION"
+
+set_gem_version "$STRIP_VERSION"

data/bin/git/hooks/post-flow-release-finish/update-version

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+VERSION=$1
+debug "Detected VERSION as '$VERSION'"
+STRIP_VERSION=$(echo "$VERSION" | tr -c -d '0-9.')
+debug "Detected STRIP_VERSION as '$STRIP_VERSION'"
+
+step_name "Adding 'Unreleased' subheader to CHANGELOG.md in development branch."
+
+# Add new 'Unreleased' section header to the CHANGELOG
+sed -i "/^=========$/ a\
+\\\n## [Unreleased]\n
+" $REPO_DIR/CHANGELOG.md
+
+# Bump the minor version number
+BUGFIX_NUM=$(($(echo $STRIP_VERSION | cut -d. -f 3)+1))
+NEW_VERSION="$(echo $STRIP_VERSION | cut -d. -f 1-2).$BUGFIX_NUM-dev"
+
+echo "New development version will be $NEW_VERSION"
+
+set_gem_version "$NEW_VERSION"
+
+step_name "Commit CHANGELOG.md and version.rb to develop branch"
+
+git commit -a -m "Post-release fixup"
+check_rc "Git commit to develop failed?"

data/bin/git/hooks/post-flow-release-start/update-version

@@ -0,0 +1,19 @@
+#!/bin/bash
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+VERSION=$1
+debug "Detected VERSION as '$VERSION'"
+STRIP_VERSION=$(echo "$VERSION" | tr -c -d '0-9.')
+debug "Detected STRIP_VERSION as '$STRIP_VERSION'"
+
+LAST_VERSION=get_last_version
+
+step_name "Change 'Unreleased' subhead to '$VERSION' in CHANGELOG.md"
+
+sed -i -e "s/^## \[Unreleased\]$/## [$VERSION] - $(date +%Y-%m-%d)/" "$REPO_DIR"/CHANGELOG.md
+
+add_changelog_diff_link "$LAST_VERSION" "$STRIP_VERSION"
+
+set_gem_version "$STRIP_VERSION"

data/bin/git/hooks/post-merge/update-hooks

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+[ -x "$REPO_DIR"/bin/git/update-hooks ] && "$REPO_DIR"/bin/git/update-hooks

data/bin/git/hooks/post-rewrite/update-hooks

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+[ -x "$REPO_DIR"/bin/git/update-hooks ] && "$REPO_DIR"/bin/git/update-hooks

data/bin/git/hooks/pre-commit/rubocop

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+# Run the rubocop lint checks (only).
+# We don't enforce a full rubocop run here because we want to let people
+# commit work-in-progress code to their local branch. We will do a full
+# rubocop run of all checks as part of the pre-push hook
+
+step_name "Running RuboCop lint checks"
+rubocop --lint
+check_rc "Please fix RuboCop lint failures before committing."
+
+# Do a full rubocop run to warn the user, but don't block a commit by it.
+step_name "Running all RuboCop checks"
+rubocop
+check_rc_optional "Fix all RuboCop failures before pushing upstream"
+
+exit 0

data/bin/git/hooks/pre-commit/validate-diffs

@@ -0,0 +1,31 @@
+#!/bin/bash
+#
+# Hook script to verify what is about to be committed.
+# Called by "git commit" with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message if
+# it wants to stop the commit.
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+# What are we diffing this commit against?
+if git rev-parse --verify HEAD >/dev/null 2>&1
+then
+    against=HEAD
+else
+    # Initial commit: diff against an empty tree object
+    against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
+fi
+
+# We exploit the fact that the printable range starts at the space character
+# and ends with tilde.
+# Note that the use of brackets around a tr range is ok here, (it's
+# even required, for portability to Solaris 10's /usr/bin/tr), since
+# the square bracket bytes happen to fall in the designated range.
+git diff --cached --name-only --diff-filter=A -z $against |
+        LC_ALL=C tr -d '[ -~]\0' | wc -c
+check_rc "Rename non-ASCII file name(s) before committing"
+
+# If there are whitespace errors, print the offending file names and fail.
+git diff-index --check --cached $against --
+check_rc "Fix trailing whitespace before committing"

data/bin/git/hooks/pre-push/check-changelog

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+z40=0000000000000000000000000000000000000000
+
+IFS=' '
+
+# Information about the commits which are being pushed is supplied as lines to
+# the standard input in the form:
+#
+#   <local ref> <local sha1> <remote ref> <remote sha1>
+while read local_ref local_sha remote_ref remote_sha
+do
+    # do nothing if we're creating or deleting a new branch.
+    if [ "$local_sha" != $z40 ] && [ "$remote_sha" != $z40 ] ; then
+        # Make sure CHANGELOG.md is updated
+        step_name "Checking CHANGELOG.md..."
+        git diff --name-only --diff-filter=ACM $remote_sha $local_sha |
+            grep 'CHANGELOG.md' >> /dev/null
+        check_rc_optional "Please update CHANGELOG.md before pushing code upstream"
+    fi
+done

data/bin/git/hooks/pre-push/rubocop

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+[ -n "$GIT_DIR" ] || export GIT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)/.git"
+. "$GIT_DIR"/hooks/hook_lib
+
+rubocop
+check_rc "Please fix RuboCop failures before pushing code upstream."

data/bin/git/update-hooks

@@ -0,0 +1,65 @@
+#!/bin/bash
+#
+# Based on:
+# http://stackoverflow.com/questions/3462955/putting-git-hooks-into-repository
+# https://github.com/sjungwirth/githooks
+
+# Where hooks are stored in the repo
+SRC_DIR="$(git rev-parse --show-toplevel)/bin/git/hooks"
+
+# Where hooks need to be installed
+HOOK_DIR="$(git rev-parse --show-toplevel)/.git/hooks"
+
+. "$SRC_DIR/hook_lib"
+
+install_hook_wrapper() {
+    local hook=$1
+    # Does the symlink exist?
+    if [ ! -h $HOOK_DIR/$hook ]; then
+        # If a hook already exists and is a file:
+        if [ -f $HOOK_DIR/$hook ]; then
+            step_name "Moving existing '$hook' script to '$hook-local'"
+            mv $HOOK_DIR/$hook $HOOK_DIR/$hook-local
+        fi
+        # create the symlink to our wrapper script
+        step_name "Installing hook wrapper script for '$hook'"
+        ln -s -f ./hooks-wrapper $HOOK_DIR/$hook
+    fi
+}
+
+check_update() {
+    local src=$1
+    local dest=$2
+    if [ ! -e "$dest" ] ; then
+        step_name "Creating new file at '$dest':"
+        git diff --color --no-index /dev/null $src
+        cp $src $dest
+    else
+        diff $src $dest >> /dev/null
+        if [ $? -ne 0 ] ; then
+            step_name "File '$dest' will be updated: "
+            git diff --color --no-index $dest $src
+            cp -f $src $dest
+        fi
+    fi
+}
+
+for item in "$SRC_DIR"/*; do
+    if [ ! -d "$item" ]; then
+        # Not a hook subdirectory, just a library file - update it as needed
+        file="${item##*/}"
+        check_update "$SRC_DIR/$file" "$HOOK_DIR/$file"
+        continue
+    fi
+    # Else it's a hook subdirectory.
+    hook="${item##*/}"
+    # First, make sure we have our hook-wrapper script installed for this hook:
+    install_hook_wrapper "$hook"
+    # Now descend into the subdirectory and update the individual scripts:
+    for file in "$item"/*; do
+        # bin/git/hooks/pre-commit/rubocop --> "pre-commit-rubocop"
+        hook_script="${hook}-${file##*/}"
+        check_update "$file" "$HOOK_DIR/$hook_script"
+    done
+done
+