Installing rbenv through shell script - ruby

I've created a shell script to install rbenv onto a fresh virtual machine, everyone seems to be working fine, however, once and a while it seems that rbenv fails to install. I'd like to add some extra error checking throughout the way to ensure that the install happens, and if something failed, re-start the install.
Some notes:
This is a small part of a larger script
This is all done through whiptail dialog
I'm redirecting the output to an events.log file >&$log_fd...
This is what I currently have:
set_rbenv(){
# install rbenv
RUBY_VERSION="2.1.4"
RBENV_ROOT="/root/.rbenv"
PROFILE="/root/.bashrc"
# check if rbenv is installed
if [[ ! `which rbenv` ]]; then
if [[ ! -d "$RBENV_ROOT" ]]; then
echo "Cloning rbenv..." >&$log_fd 2>&1
git clone https://github.com/rbenv/rbenv.git $RBENV_ROOT >&$log_fd 2>&1
fi
if [[ ! -d "$RBENV_ROOT/plugins/ruby-build" ]]; then
git clone https://github.com/rbenv/ruby-build.git $RBENV_ROOT/plugins/ruby-build >&$log_fd 2>&1
fi
if [[ ! `grep -e '/.rbenv\/bin' $PROFILE` ]]; then
echo "rbenv not in PATH ... adding..." >&$log_fd 2>&1
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> $PROFILE 2>&1
fi
if [[ ! `grep -e '^\eval "$(rbenv init -)"' $PROFILE` ]]; then
echo "rbenv init not in .bashrc... adding..." >&$log_fd 2>&1
echo 'eval "$(rbenv init -)"' >> $PROFILE 2>&1
fi
. $PROFILE
echo "Finished Installing rbenv..." >&$log_fd 2>&1
else
echo "rbenv already installed... skipping!" >&$log_fd 2>&1
fi
if [ ! -d "$RBENV_ROOT/versions" ]; then
echo "$RBENV_ROOT/versions doesn't exist ... creating..."
mkdir $RBENV_ROOT/versions >&$log_fd 2>&1
fi
if [ ! -d "$RBENV_ROOT/versions/$RUBY_VERSION" ]; then
echo "$RBENV_ROOT/versions/$RUBY_VERSION doesn't exist ... creating..." >&$log_fd 2>&1
mkdir $RBENV_ROOT/versions/$RBENV_VERSION >&$log_fd 2>&1
fi
# check if ruby version is installed
if [[ ! `rbenv version | grep $RUBY_VERSION` ]]; then
echo "installing ruby 2.1.4" >&$log_fd 2>&1
rbenv install $RUBY_VERSION >&$log_fd 2>&1
rbenv global $RUBY_VERSION >&$log_fd 2>&1
if [ ! -d "$RBENV_ROOT/versions/$RUBY_VERSION/etc" ]; then
echo "$RBENV_ROOT/versions/$RUBY_VERSION/etc doesn't exist ... creating..." >&$log_fd 2>&1
mkdir $RBENV_ROOT/versions/$RUBY_VERSION/etc >&$log_fd 2>&1
fi
else
echo "ruby $RUBY_VERSION already exists... skipping!" >&$log_fd 2>&1
fi
(( STATUS += 35 ))
echo $STATUS
}
While the install itself can fail at anytime on the new VM, I'm screwed if rbenv installs, but nothing else does (like ruby-build) or the $PATH, etc.
Would it make more sense to just encase every command in it's own if statement outside of the initial if which rbenv, or is there a more robust way to ensure the install completes successfully?

You can actually perform this task more easily using configuration management tools such as Ansible, puppet or Chef. Instead of trying to specify "how" to check and use endless IF statement, you can specify "what" to check and use existing framework to do so.
For example, in Ansible you can specify to update cache & install latest version of foo using apt module:
- hosts: all
remote_user: root
tasks:
- name: Install the package foo
apt:
name: foo
state: present
update_cache: yes
More information

Related

check if command exists. if not install it

Trying to write a small script to install/update dotfiles, but I can't get this part to function properly:
The array to read files to install:
APPARRAY=(curl htop ncdu pydf tree tmux vim)
And this is a function that gets called when needed.
I'd like it to check if a app exists, if not install it or if it fails then log that to a logfile.
function app_installer(){
for APP in "${APPARRAY[#]}"
do
# echo $APP
#install $APP
if command -v $APP 2> /dev/null; then
echo "$APP already installed!" #>> $LOG
# if command doesnt exist, install it
elif -x command -v $APP 2>/dev/null ; then
echo installing $APP #install $APP
else
echo "$APP FAILED TO INSTALL!!!" #>> $LOG
fi
done
}
How about this approach using which
APPARRAY=(curl htop tree tmux vim vimx)
function app_installer(){
for APP in "${APPARRAY[#]}"
do
which $APP > /dev/null 2>&1
rc=$?
if [ $rc == 0 ]; then
continue
fi
echo installing $APP
# try and install app
# if install fails, log to file
done
}
app_installer
Since I have everything but vimx (I dont think vimx is a thing, I just made something up on the spot) installed, it will output,
installing vimx

Bash check if nvm installed

How can I detirmine if nvm (Node Version Manager) is installed in bash?
I already have it installed in my system but I haven't been able to make any bash script that can detect it. I am making a script that should be used by others which depends on nvm, so I want to output if it's not installed and exit if it isn't..
This doesn't work: https://stackoverflow.com/a/26759734/846348 it says that nvm isn't installed but the bash script can use nvm..
Would be nice if it supported Mac Terminal, Mac iTerm and Windows with Linux shell at least.
one can check with command -v nvm:
$ command -v nvm >/dev/null 2>&1 || { echo >&2 "nvm is required, but it's not installed. Aborting."; exit 1; }
The nvm install script checks if nvm is installed using roughly the following logic:
if [ -d "${HOME}/.nvm/.git" ]; then echo "nvm installed"; else echo "nvm not installed"; fi
This just checks if the directory ~/.nvm/.git exists.
To exit with failure if the directory ~/.nvm/.git does not exist, you could use:
if [ ! -d "${HOME}/.nvm/.git" ]; then exit; fi
Check if nvm installed using a Makefile
NVM_EXISTS := $(shell if [ -d "${HOME}/.nvm/.git" ]; then echo "nvm installed"; fi)
.PHONY: check
check:
ifndef NVM_EXISTS
$(error Please install nvm: https://github.com/nvm-sh/nvm)
endif
Note on nvm install.sh
The actual install script uses the following functions to determine the nvm installation directory (rather than assuming ${HOME}/.nvm). But if you are using the default location ${HOME}/.nvm, you can skip these checks.
nvm_default_install_dir() {
[ -z "${XDG_CONFIG_HOME-}" ] && printf %s "${HOME}/.nvm" || printf %s "${XDG_CONFIG_HOME}/nvm"
}
nvm_install_dir() {
if [ -n "$NVM_DIR" ]; then
printf %s "${NVM_DIR}"
else
nvm_default_install_dir
fi
}

Loading variables in bash from another file

I build some ROMs and other software for various Android devices and to make it easier for me, I use bash based scripts.
Here's an example from my TWRP build script:
#!/usr/bin/env bash
# Variables
export TW_DEVICE_VERSION="0"
export BRANCH="android-5.1"
# Don't touch this
VERSION=$( grep "TW_MAIN_VERSION_STR" bootable/recovery/variables.h -m 1 | cut -d \" -f2 )-${TW_DEVICE_VERSION}
# Acer Liquid Z500 specific TWRP build configuration
export BRAND="acer"
export DEVICE="acer_Z500"
git clone https://github.com/liquidporting/android_device_${BRAND}_${DEVICE}.git -b ${BRANCH} device/${BRAND}/${DEVICE}
. build/envsetup.sh
lunch omni_${DEVICE}-eng
mka recoveryimage > twrp_${DEVICE}.log
cd out/target/product/${DEVICE}
if [ -f "recovery.img" ]
then
mv recovery.img twrp-${VERSION}-${DEVICE}.img
else
echo ""
echo "*******************************************************************************"
echo "Something went wrong during the build process, try checking your device tree."
echo "After that, run the script again and see if you messed up something new or not."
echo "*******************************************************************************"
echo ""
fi
if [ -f "twrp-${VERSION}-${DEVICE}.img" ]
then
megarm /Root/LPAD/TWRP/twrp-${VERSION}-${DEVICE}.img
megarm /Root/LPAD/TWRP/twrp_${DEVICE}.log
megaput --no-progress --path /Root/LPAD/TWRP twrp-${VERSION}-${DEVICE}.img
megaput --no-progress --path /Root/LPAD/TWRP ../../../../twrp_${DEVICE}.log
fi
if [ -f "twrp-${VERSION}-${DEVICE}.img" ]
then
cd ../../../..
rm twrp_${DEVICE}.log
make clean
cd device
rm -rf ${BRAND}
cd ..
else
rm twrp_${DEVICE}.log
make clean
cd device
rm -rf ${BRAND}
cd ..
echo ""
echo "**************************************************************"
echo "The build process of TWRP Recovery failed for device ${DEVICE}"
echo "**************************************************************"
echo ""
exit
fi
# Lenovo A328 specific TWRP build configuration
export BRAND="lenovo"
export DEVICE="A328"
git clone https://github.com/liquidporting/android_device_${BRAND}_${DEVICE}.git -b ${BRANCH} device/${BRAND}/${DEVICE}
. build/envsetup.sh
lunch omni_${DEVICE}-eng
mka recoveryimage > twrp_${DEVICE}.log
cd out/target/product/${DEVICE}
if [ -f "recovery.img" ]
then
mv recovery.img twrp-${VERSION}-${DEVICE}.img
else
echo ""
echo "*******************************************************************************"
echo "Something went wrong during the build process, try checking your device tree."
echo "After that, run the script again and see if you messed up something new or not."
echo "*******************************************************************************"
echo ""
fi
if [ -f "twrp-${VERSION}-${DEVICE}.img" ]
then
megarm /Root/LPAD/TWRP/twrp-${VERSION}-${DEVICE}.img
megarm /Root/LPAD/TWRP/twrp_${DEVICE}.log
megaput --no-progress --path /Root/LPAD/TWRP twrp-${VERSION}-${DEVICE}.img
megaput --no-progress --path /Root/LPAD/TWRP ../../../../twrp_${DEVICE}.log
fi
if [ -f "twrp-${VERSION}-${DEVICE}.img" ]
then
cd ../../../..
rm twrp_${DEVICE}.log
make clean
cd device
rm -rf ${BRAND}
cd ..
else
rm twrp_${DEVICE}.log
make clean
cd device
rm -rf ${BRAND}
cd ..
echo ""
echo "**************************************************************"
echo "The build process of TWRP Recovery failed for device ${DEVICE}"
echo "**************************************************************"
echo ""
exit
fi
Is possible to have a separated bash script containing build instructions and another one containing set of variables?
I Mean something like this:
#!/usr/bin/env bash
export TW_DEVICE_VERSION="0"
export BRANCH="android-5.1"
VERSION=$( grep "TW_MAIN_VERSION_STR" bootable/recovery/variables.h -m 1 | cut -d \" -f2 )-${TW_DEVICE_VERSION}
export BRAND="acer"
export DEVICE="acer_Z500"
export BRAND="lenovo"
export DEVICE="A328"
export BRAND="doogee"
export DEVICE="X5"
But after each device specific configuration I need it to launch the bash script containing the build instructions.
Yes, that is very much feasible and it is a good thing to do as well.
Put your configuration in a file, say, tw_config.sh. Then, invoke the configuration script this way:
source /path/to/tw_config.sh
if [ $? -ne 0 ]; then
# couldn't load config
# your logic here - makes sense to exit
fi
If tw_config.sh is in your PATH, you can simply say:
source tw_config.sh

Bash file working on local computer but not working on Amazon EC2 instance

I have a simple bash file which fixes the npm permission on my system. It goes like this
npm=`npm config get prefix`
echo "$npm"
if [[ $npm = "/usr/local" ]]
then
echo "Yes it's /usr/local"
echo $npm/{lib/node_modules,bin,share}
sudo chown -R $(whoami) $npm/{lib/node_modules,bin,share}
echo "Complete"
elif [[ $npm = "/usr" ]]
then
echo "Uhhohh it's /usr gotta use a different method"
mkdir ~/.npm-global
npm config set prefix '~/.npm-global'
export PATH=~/.npm-global/bin:$PATH
source ~/.profile
echo "No"
fi
npm install -g forever
npm install -g pm2
npm install -g bower
This works fine on my machine. But not my amazon ex2 instance. I am running ubuntu 16.04 LTS on my AWS EC2 instance and Ubuntu 15.04 on my local system. The error which I get is npm-permission.sh: line 2: =/usr: No such file or directory
Which is the second line. What is the issue? Why doesn't it work?
So a change as suggested by #Cyrus in the comments I modified the script to have if [[ $npm = '' ]] which made it work. Here is the working script.
npm=$(npm config get prefix)
echo "$npm"
if [[ $npm = "/usr/local" ]]
then
echo "Yes it's /usr/local"
echo $npm/{lib/node_modules,bin,share}
sudo chown -R $(whoami) $npm/{lib/node_modules,bin,share}
echo "Complete"
elif [[ $npm = "/usr" ]]
then
echo "Uhhohh it's /usr gotta use a different method"
mkdir ~/.npm-global
npm config set prefix '~/.npm-global'
echo "export PATH=~/.npm-global/bin:$PATH" >> ~/.profile
source ~/.profile
echo "No"
fi
I still don't know how it works, but it does. Some bash expert might throw some light on it.

Installing Jekyll without root

I want to set up a jekyll blog on a shared server. When I try to install Jekyll I get "You don't have write permissions". How do I fix this without root or sudo?
More detail:
I have space on a shared server and don't have root access. I couldn't install Ruby, though the hosting company installed it upon my request.
When I try to install Jekyll I use
user#hosting.org [~]# gem install jekyll
and this is the response I get:
ERROR: While executing gem ... (Gem::FilePermissionError)
You don't have write permissions into the /usr/lib/ruby/gems/1.8 directory.
I have seen different suggestions for changing the GEMPATH which I have tried including
export GEM_PATH=/home/user/something
But even after doing so
gem env
still results in
GEM PATHS:
- /usr/lib/ruby/gems/1.8
- /home/user/.gem/ruby/1.8
Any tips? Is it possible to install jekyll without root or sudo priviliges or am I just making some rookie PATH error?
I didn't find the answer for a while. on the #jekyll IRC a user pointed me at the Arch wiki and I discovered that the thing is to force the install as a single user:
gem install jekyll --user-install
This worked for me in MAC
1.Place the gems in user's home folder.Add below commands in .bashrc or .zshrc
export GEM_HOME=$HOME/gems
export PATH=$HOME/gems/bin:$PATH
2.Use installation command
gem install jekyll bundler
3.Verify Installation
jekyll -v
Use the documentation for detailed reference
https://jekyllrb.com/docs/troubleshooting/#no-sudo
The reason for that is the default Ruby that gets shipped with Mac (I am assuming this, but this is true for some distributions of Linux as well) installs gems to a user folder that needs permissions to modify the contents. This is not a Ruby error to be precise.
That said, since Ruby 1.8.7 is not supported any more, you'd be better off avoiding using it and using one of the alternative ruby version managing tools like chruby or rvm or rbenv. (I'd vote for chruby btw). The documentation is pretty dense for all those. The authors are quite helpful in resolving issues if you do end up having one or more.
... am I just making some rookie PATH error?
Yes, I think so... I'm not sure why you're assigning GEM_PATH, I haven't needed to, and think ya perhaps wanted GEM_HOME instead. Though things may have changed since then and the current now that this'll be posted at.
TLDR
I usually write something such as...
## Ruby exports for user level gem & bundle installs
export GEM_HOME="${HOME}/.gem"
export PATH="${GEM_HOME}/bin:${PATH}"
... to somewhere like ~/.bash_aliases for each user that'll be authenticating to a server.
Then within any git-shell-commands script, for an authenticated user that makes use of Gems, source the above settings prior.
I want to set up a jekyll blog on a shared server. When I try to install Jekyll I get "You don't have write permissions". How do I fix this without root or sudo?
Might be worth checking out a project I've published a little while ago. It's been written and tested on Linux systems with Bash versions >= 4 if you sort out Mac feel free to make a PR. Otherwise, for shared servers, the least amount of fuss may be had by sticking with Xenial, from Ubuntu, or the freshest Raspberry flavored Debian.
Here's some snippets that should aid in automating an answer to your question...
/usr/local/etc/Jekyll_Admin/shared_functions/user_mods/jekyll_gem_bash_aliases.sh
#!/usr/bin/env bash
jekyll_gem_bash_aliases(){ ## jekyll_gem_bash_aliases <user>
local _user="${1:?No user name provided}"
local _home="$(awk -F':' -v _user="${_user}" '$0 ~ "^" _user ":" {print $6}' /etc/passwd)"
if [ -f "${_home}/.bash_aliases" ]; then
printf '%s/.bash_aliases already exists\n' "${_home}" >&2
return 1
fi
## Save new user path variable for Ruby executables
su --shell "$(which bash)" --command 'touch ${HOME}/.bash_aliases' --login "${_user}"
tee -a "${_home}/.bash_aliases" 1>/dev/null <<'EOF'
## Ruby exports for user level gem & bundle installs
export GEM_HOME="${HOME}/.gem"
export PATH="${GEM_HOME}/bin:${PATH}"
EOF
su --shell "$(which bash)" --command 'chmod u+x ${HOME}/.bash_aliases' --login "${_user}"
printf '## %s finished\n' "${FUNCNAME[0]}"
}
The above is used by one of three scripts that make use of sudo level permissions, specifically jekyll_usermod.sh... but don't get too caught-up with grokking all the contortions that I'm asking of Bash, because the moral of the above function's story is that it writes something like...
## Ruby exports for user level gem & bundle installs
export GEM_HOME="${HOME}/.gem"
export PATH="${GEM_HOME}/bin:${PATH}"
... to somewhere like /srv/bill/.bash_aliases which'll get sourced in git-shell-commands scripts and/or other shared functions for account setup like the following...
/usr/local/etc/Jekyll_Admin/shared_functions/user_mods/jekyll_user_install.sh
#!/usr/bin/env bash
jekyll_user_install(){ ## jekyll_user_install <user>
local _user="${1:?No user name provided}"
su --shell "$(which bash)" --login "${_user}" <<'EOF'
source "${HOME}/.bash_aliases"
mkdir -vp "${HOME}"/{git,www}
## Initialize Jekyll repo for user account
_old_PWD="${PWD}"
mkdir -vp "${HOME}/git/${USER}"
cd "${HOME}/git/${USER}"
git init .
git checkout -b gh-pages
_ruby_version="$(ruby --version)"
printf 'Ruby Version: %s\n' "${_ruby_version}"
_ruby_version="$(awk '{print $2}' <<<"${_ruby_version%.*}")"
_ruby_version_main="${_ruby_version%.*}"
_ruby_version_sub="${_ruby_version#*.}"
if [[ "${_ruby_version_main}" -ge '2' ]] && [[ "${_ruby_version_sub}" -ge '1' ]]; then
gem install bundler -v '< 2'
gem install jekyll -v '3.8.5'
bundle init
bundle install --path "${HOME}/.bundle/install"
bundle add jekyll-github-metadata github-pages
bundle exec jekyll new --force --skip-bundle "${HOME}/git/${USER}"
bundle install
else
echo 'Please see to installing Ruby verion >= 2.4' >&2
echo 'Hints may be found at, https://jekyllrb.com/docs/installation/' >&2
fi
git config receive.denyCurrentBranch updateInstead
cat >> "${HOME}/git/${USER}/.gitignore" <<EOL
# Ignore files and folders generated by Bundler
Bundler
vendor
.bundle
Gemfile.lock
EOL
git add --all
git -c user.name="${USER}" -c user.email="${USER}#${HOSTNAME}" commit -m "Added files from Bundler & Jekyll to git tracking"
cd "${_old_PWD}"
EOF
local _exit_status="${?}"
printf '## %s finished\n' "${FUNCNAME[0]}"
return "${_exit_status}"
}
Note, .bash_aliases is arbitrary as far as file naming, well so long as one is consistent, it could even be more explicit via something like .gems_aliases; end-users need not know what happens behind the curtains to make this magic happen in other words.
... which'll hopefully show one clear method of causing gem install someThing and related commands to search the user's installed packages first. Though in case another example is needed...
~/git-shell-commands/jekyll-init
#!/usr/bin/env bash
__SOURCE__="${BASH_SOURCE[0]}"
while [[ -h "${__SOURCE__}" ]]; do
__SOURCE__="$(find "${__SOURCE__}" -type l -ls | sed -n 's#^.* -> \(.*\)#\1#p')"
done
__DIR__="$(cd -P "$(dirname "${__SOURCE__}")" && pwd)"
__NAME__="${__SOURCE__##*/}"
__AUTHOR__='S0AndS0'
__DESCRIPTION__='Initializes new Git repository with a gh-pages branch'
## Provides 'failure'
# source "${__DIR__}/shared_functions/failure"
# trap 'failure "LINENO" "BASH_LINENO" "${BASH_COMMAND}" "${?}"' ERR
## Provides: argument_parser <arg-array-reference> <acceptable-arg-reference>
source "${__DIR__}/shared_functions/arg_parser"
## Provides: git_add_commit <string>
source "${__DIR__}/shared_functions/git_shortcuts"
## Provides: __license__ <description> <author>
source "${__DIR__}/shared_functions/license"
usage(){
_message="${1}"
_repo_name="${_repo_name:-repository-name}"
cat <<EOF
## Usage
# ssh ${USER}#host-or-ip ${__NAME__} ${_git_args[#]:-$_repo_name}
#
# ${__DESCRIPTION__}
#
# --quite
# Git initializes quietly
#
# --shared
# Allow git push for group $(groups | awk '{print $1}')
#
# --template=<path>
# Template git repository that git init should pull from
#
# ${_repo_name}
# Name of repository to internalize or add Jekyll gh-pages branch to
#
## For detailed documentation of the above options.
## See: git help init
#
# --clean
# Remove non-git related files and directories from gh-pages branch prior to
# initializing Jekyll related files. This allows for files from previous branch
# to remain separate from files being tracked on the gh-pages branch.
#
# -l --license
# Shows script or project license then exits
#
# -h --help help
# Displays this message and exits
#
## The following options maybe used to modify the generated _config.yml file
#
# --title ${_title}
# --email ${_email}
# --twitter-username ${_twitter_username}
# --github-username ${_github_username}
EOF
if [ -n "${_message}" ] && [[ "${_message}" != '0' ]]; then
printf 'Error - %s\n' "${_message}" >&2
fi
}
_args=("${#:?# No arguments provided try: ${__NAME__} help}")
_valid_args=('--help|-h|help:bool'
'--license|-l|license:bool'
'--quiet:bool'
'--clean:bool'
'--shared:bool'
'--template:path'
'--title:print'
'--email:print'
'--twitter-username:posix'
'--github-username:posix'
'--repo-name:posix-nil')
argument_parser '_args' '_valid_args'
_exit_status="$?"
_git_args=()
if ((_quiet)); then _git_args+=('--quiet'); fi
if ((_shared)); then _git_args+=('--shared'); fi
if [ -n "${_template}" ]; then _git_args+=("--template='${_template}'"); fi
if [ -n "${_repo_name}" ]; then _git_args+=("${_repo_name}"); fi
## Set defaults for some variables if not already set
_github_username="${_github_username:-$USER}"
if [ -z "${_title}" ]; then
for _word in ${_repo_name//[-_]/ }; do
if [[ "${#_word}" -ge '4' ]]; then
_temp_title+=("${_word^}")
else
_temp_title+=("${_word}")
fi
done
_title="${_temp_title[#]}"
fi
_bundle_path="${HOME}/.bundle/install"
if ((_help)) || ((_exit_status)); then
usage "${_exit_status}"
exit "${_exit_status}"
elif ((_license)); then
__license__ "${__DESCRIPTION__}" "${__AUTHOR__}"
exit 0
fi
if [ -z "${_repo_name}" ]; then
usage 'missing repository name argument!'
exit "1"
fi
_git_path="${HOME}/git/${_repo_name:?No repository name provided}"
_old_PWD="${PWD}"
if [ -d "${_git_path}" ]; then cd "${_git_path}"; fi
_git_dir="$(git rev-parse --git-dir 2>/dev/null)"
if [[ "${_git_path}/${_git_dir}" == "${_git_path}/.git" ]]; then
printf '# Skipping git init, path already tracked by git: %s\n' "${_git_preexisting_dir}"
elif [[ "${_git_path}/${_git_dir}" == "${_git_path}/." ]]; then
echo '# Bare git repository detected, cannot install Jekyll to that right now'
exit 1
else
if [ -e "${HOME}/git-shell-commands/git-init" ]; then
"${HOME}/git-shell-commands/git-init" ${_git_args[#]}
else
cd "${HOME}/git" || exit 1
git init ${_git_args[#]}
fi
fi
cd "${_git_path}" || exit 1
_git_branches="$(git branch --list)"
_orig_branch="$(awk '/\*/{print $2}' <<<"${_git_branches}")"
_pages_branch="$(awk '/gh-pages/{print $2}' <<<"${_git_branches}")"
if [ -n "${_pages_branch}" ]; then
printf '# There is already a pages branch %s for repository %s\n' "${_pages_branch}" "${_repo_name}"
exit 1
fi
git_add_commit "Added files on ${_orig_branch} prior to installing Bundler & Jekyll to gh-pages branch"
git checkout -b gh-pages
if [[ "$(git config receive.denyCurrentBranch)" != 'updateInstead' ]]; then
git config receive.denyCurrentBranch updateInstead
fi
if ((_clean)); then
for _path in ${_git_path}/*; do
case "${_path}" in
*'.git') [[ -d "${_path}" ]] && continue ;;
*'.gitignore') [[ -f "${_path}" ]] && continue ;;
esac
git rm -rf "${_path}"
done
git_add_commit 'Cleaned gh-pages branch of files from parent branch'
fi
modify_config_yml(){
if ! [ -f "${_git_path}/_config.yml" ]; then
printf 'Error - no Jekyll config file found under %s\n' "${_git_path}" >&2
return 1
fi
if [ -n "${_title}" ]; then
sed -i "/title:/ { s#:[a-zA-Z 0-9]*#: ${_title}#; }" "${_git_path}/_config.yml"
fi
if [ -n "${_email}" ]; then
sed -i "/email:/ { s#:[a-zA-Z 0-9]*#: ${_email}#; }" "${_git_path}/_config.yml"
fi
if [ -n "${_twitter_username}" ]; then
sed -i "/_twitter_username:/ { s#:[a-zA-Z 0-9]*#: ${_twitter_username}#; }" "${_git_path}/_config.yml"
fi
if [ -n "${_github_username}" ]; then
sed -i "/github_username:/ { s#:[a-zA-Z 0-9]*#: ${_github_username}#; }" "${_git_path}/_config.yml"
fi
if [[ "${_repo_name}" != "${_github_username}" ]]; then
tee -a "${_git_path}/_config_baseurl.yml" 1>/dev/null <<EOF
# Use base URL to simulate GitHub pages behaviour
baseurl: "${_repo_name}"
EOF
fi
}
source "${HOME}/.bash_aliases"
bundle init || exit "${?}"
bundle install --path "${_bundle_path}"
bundle add jekyll
bundle exec jekyll new --force --skip-bundle "${_git_path}"
modify_config_yml
bundle install
cat >> "${_git_path}/.gitignore" <<EOF
# Ignore files and folders generated by Bundler
Bundler
vendor
.bundle
Gemfile.lock
EOF
git_add_commit 'Added files from Bundler & Jekyll to git tracking'
[[ "${_old_PWD}" == "${_git_path}" ]] || cd "${_old_PWD}"
printf '# Clone %s via: git clone %s#domain_or_ip:%s\n' "${_repo_name}" "${USER}" "${_git_path//${HOME}\//}"
printf '# %s finished\n' "${__NAME__}"
... which also shows how to bundle install someThing to somewhere.
Good luck with the publishing and perhaps comment if ya get stuck.

Resources