grab.sh

#!/bin/bash


LIBFILE_NAME="library.sh"

HOST_REGEX="[a-zA-Z0-9_\.]+"
ORG_REGEX="[a-zA-Z0-9_\-]+"
REPO_REGEX="[a-zA-Z0-9_\-]+"
PATH_REGEX="[a-zA-Z0-9_\.\-\/]*"
VERSION_REGEX="[a-zA-Z0-9\.\-]+"

FUNCTION_PATTERN='^[[:space:]]*([[:alnum:]_]+[[:space:]]*\(\)|function[[:space:]]+[[:alnum:]_]+)'

FULL_REGEX="($HOST_REGEX)\/($ORG_REGEX)\/($REPO_REGEX)($PATH_REGEX)?([@]$VERSION_REGEX)?"

#
# Converts a string of the format pointed bellow to an actual git url.
# <host>/<organization>/<repository>@<branch>
#
to_clone_url() {
    echo "https://$1/$2/$3.git"
}

find_host() {
    echo $1 | sed -E "s/$FULL_REGEX/\1/"
}

find_organization() {
    echo $1 | sed -E "s/$FULL_REGEX/\2/"
}

find_repository() {
    echo $1 | sed -E "s/$FULL_REGEX/\3/"
}

find_path() {
    echo -n "."
    echo $1 | sed -E "s/$FULL_REGEX/\4/"
}

find_version() {
    local version=`echo $1 | awk -F "@" '{print $NF}'`
    if [ "$version" == "$1" ]; then
        echo "main"
    elif [ -z "$version" ]; then
        echo "main"
    else
        echo $version
    fi
}

find_library_path() {
    local path=$1
    local filename=$LIBFILE_NAME;

    if [ -f $path ]; then
        filename=$(echo $path | awk -F "/" '{print $NF}')
        path=$(dirname $path)
    fi

    pushd $path
    if [ -f "$filename" ]; then
        realpath $filename
    fi
    popd
}

find_default_branch() {
    local clone_url=$1
    local default_branch=$(git ls-remote --symref $clone_url HEAD 2>/dev/null | grep "^ref:" | cut -f2 | cut -d'/' -f3)
    
    if [ -z "$default_branch" ]; then
        # Fallback to master if we can't determine the default branch
        echo "master"
    else
        echo "$default_branch"
    fi
}

translate_as() {
    local script=$1
    local prefix=""
    local separator=""
    local source=`basename $script | cut -d "." -f1`
    local dir=`dirname $script`
    local target="$script"

    local tmp_dir=$(mktemp -d /tmp/grab-alias.XXXXXXXX)
    local tmp_source=$tmp_dir/source.sh
    local tmp_target=$tmp_dir/target.sh

    local needs_normalization=`grep -E $FUNCTION_PATTERN $script | grep "^__"`


    #If an alias has been specified....
    if [ "$2" == "as" ] && [ -n "$3" ]; then
        prefix=$3
        separator="::"
        mkdir -p $dir/.alias/$source
        target="$dir/.alias/${source}/$prefix.sh"
    elif [ -n "$needs_normalization" ]; then
        mkdir -p $dir/.normalized
        target="$dir/.normalized/${source}.sh"
    fi

    cp $script $tmp_source
    cp $script $tmp_target

    # Get list of functions once, before any modifications
    local functions=$(grep -E $FUNCTION_PATTERN $tmp_source | grep -v "::" | cut -d "{" -f1 | cut -d "(" -f1 | sed "s/^[ ]*function //g")
    
    for func in $functions; do
        # Only apply namespace if function doesn't already have it
        if ! grep -q "\b$prefix$separator$func\b" $tmp_source; then
            cat $tmp_source | sed "s/\b$func\b/$prefix$separator$func/g" > $tmp_target
            cp $tmp_target $tmp_source
        fi
        
        local normalized=`echo $func | sed "s/^__//g"`
        if [ "$normalized" != "$func" ]; then
            cat $tmp_source | sed "s/$func/$normalized/g" > $tmp_target
            cp $tmp_target $tmp_source
        fi
    done

    cp $tmp_target $target
    echo $target
}


# Utils
pushd () {
    command pushd "$@" > /dev/null
}

popd () {
    command popd "$@" > /dev/null
}

do_grab() {
    # Command execution
    local host=$(find_host $1)
    local organization=$(find_organization $1)
    local repository=$(find_repository $1)
    local requested_version=$(find_version $1)
    local path=$(find_path $1)
    local clone_url=$(to_clone_url $host $organization $repository)

    local shellib_home=${SHELLIB_HOME:=$HOME/.shellib}

    # If no specific version was requested (defaults to "master"), detect the actual default branch
    local version=$requested_version
    if [ "$requested_version" == "master" ]; then
        local actual_version=$(echo $1 | awk -F "@" '{print $NF}')
        if [ "$actual_version" == "$1" ] || [ -z "$actual_version" ]; then
            # No version was specified, detect the default branch
            version=$(find_default_branch $clone_url)
        fi
    fi

    mkdir -p $shellib_home/$host/$organization/$repository
    pushd $shellib_home/$host/$organization/$repository

    if [ -d $version ]; then
        pushd $version
        # Update default branches (master or main) with latest changes
        local default_branch=$(find_default_branch $clone_url)
        if [ "$default_branch" == "$version" ]; then
            git pull --rebase origin $version > /dev/null 2> /dev/null
        fi
        translate_as $(find_library_path $path) $2 $3
        popd
    else
        #Clone the repository
        git clone -b $version --single-branch $clone_url $shellib_home/$host/$organization/$repository/$version > /dev/null 2> /dev/null
        pushd $version
        translate_as $(find_library_path $path) $2 $3
        popd
    fi
}

# Test functions
test_find_host() {
    local host=$(find_host "github.com/owner/repo")
    if [ "$host" = "github.com" ]; then
        echo "✓ find_host works"
        return 0
    else
        echo "✗ find_host failed, got: '$host'"
        return 1
    fi
}

test_find_organization() {
    local org=$(find_organization "github.com/testorg/testrepo")
    if [ "$org" = "testorg" ]; then
        echo "✓ find_organization works"
        return 0
    else
        echo "✗ find_organization failed, got: '$org'"
        return 1
    fi
}

test_find_repository() {
    local repo=$(find_repository "github.com/testorg/testrepo")
    if [ "$repo" = "testrepo" ]; then
        echo "✓ find_repository works"
        return 0
    else
        echo "✗ find_repository failed, got: '$repo'"
        return 1
    fi
}

test_find_path() {
    local path=$(find_path "github.com/owner/repo/path/to/file")
    if [ "$path" = "./path/to/file" ]; then
        echo "✓ find_path works"
        return 0
    else
        echo "✗ find_path failed, got: '$path'"
        return 1
    fi
}

test_find_version() {
    local version1=$(find_version "github.com/owner/repo@v1.0")
    if [ "$version1" = "v1.0" ]; then
        echo "✓ find_version works with explicit version"
    else
        echo "✗ find_version failed with version, got: '$version1'"
        return 1
    fi
    
    local version2=$(find_version "github.com/owner/repo")
    if [ "$version2" = "main" ]; then
        echo "✓ find_version defaults to main"
        return 0
    else
        echo "✗ find_version failed default, got: '$version2'"
        return 1
    fi
}

test_to_clone_url() {
    local url=$(to_clone_url "github.com" "owner" "repo")
    if [ "$url" = "https://github.com/owner/repo.git" ]; then
        echo "✓ to_clone_url works"
        return 0
    else
        echo "✗ to_clone_url failed, got: '$url'"
        return 1
    fi
}

test_translate_as_simple() {
    # Create a temporary test library
    local temp_lib=$(mktemp)
    cat > "$temp_lib" << 'EOF'
#!/bin/bash

simple_function() {
    echo "test"
}

another_function() {
    local var="value"
    echo "$var"
}
EOF
    
    # Test without alias
    local result=$(translate_as "$temp_lib")
    if [ -f "$result" ] && grep -q "simple_function" "$result"; then
        echo "✓ translate_as works without alias"
    else
        echo "✗ translate_as failed without alias"
        rm -f "$temp_lib"
        return 1
    fi
    
    rm -f "$temp_lib"
    return 0
}

test_translate_as_with_alias() {
    # Create a temporary test library
    local temp_lib=$(mktemp)
    cat > "$temp_lib" << 'EOF'
#!/bin/bash

test_function() {
    echo "test"
}

another_test() {
    echo "another"
}
EOF
    
    # Test with alias
    local result=$(translate_as "$temp_lib" "as" "myprefix")
    if [ -f "$result" ] && grep -q "myprefix::test_function" "$result"; then
        echo "✓ translate_as works with alias"
    else
        echo "✗ translate_as failed with alias"
        rm -f "$temp_lib"
        return 1
    fi
    
    # Test that functions are properly namespaced
    if grep -q "myprefix::another_test" "$result"; then
        echo "✓ translate_as namespaces all functions"
    else
        echo "✗ translate_as failed to namespace all functions"
        rm -f "$temp_lib"
        return 1
    fi
    
    rm -f "$temp_lib"
    return 0
}

test_translate_as_no_double_namespace() {
    # Create a temporary test library with already namespaced functions
    local temp_lib=$(mktemp)
    cat > "$temp_lib" << 'EOF'
#!/bin/bash

simple_function() {
    echo "test"
}

already_namespaced() {
    echo "already"
}
EOF
    
    # First pass - apply namespace
    local first_result=$(translate_as "$temp_lib" "as" "test")
    
    # Second pass - should not double-namespace
    local second_result=$(translate_as "$first_result" "as" "test")
    
    # Check that we don't have test::test:: anywhere
    if ! grep -q "test::test::" "$second_result"; then
        echo "✓ translate_as prevents double namespacing"
    else
        echo "✗ translate_as created double namespace"
        rm -f "$temp_lib" "$first_result" "$second_result"
        return 1
    fi
    
    rm -f "$temp_lib" "$first_result" "$second_result"
    return 0
}

# Run all tests
run_tests() {
    echo "Running tests for grab..."
    local failed=0
    
    test_find_host || failed=1
    test_find_organization || failed=1
    test_find_repository || failed=1
    test_find_path || failed=1
    test_find_version || failed=1
    test_to_clone_url || failed=1
    test_translate_as_simple || failed=1
    test_translate_as_with_alias || failed=1
    test_translate_as_no_double_namespace || failed=1
    
    if [ $failed -eq 0 ]; then
        echo "All tests passed!"
        return 0
    else
        echo "Some tests failed!"
        return 1
    fi
}

# Handle command line arguments
if [ "$1" = "--test" ]; then
    run_tests
    exit $?
fi

#Only run grab if script is not sourced and not testing
if [ -n "$1" ] && [ "$1" != "--test" ]; then
    do_grab $*
fi