build local gem repository from Gemfile(s)

build-bundled-tarball.sh

#!/bin/sh
#
#
set -e

LANG=C
LC_ALL=C

tarball=$1
[ $# = 1 ] || {
  exit 1
}

proj_dir=$(tar ztvf ${tarball} 2>/dev/null | head -1 | awk '{print $6}')
[ -d ${proj_dir} ] && rm -rf ${proj_dir}

tar zxvf ${tarball} -C .
cd ${proj_dir}

uri_fmt="file://%s/.vendor/local-gem"

# Gemfile
find . -type f -name Gemfile | while read gemfile; do
  echo === ${gemfile}
  local_gem_uri=$(printf ${uri_fmt} $(cd $(dirname ${gemfile}) && pwd))

  egrep ^source ${gemfile} -q && {
    perl -pi -e "s,^source.*,source '${local_gem_uri}',g" ${gemfile}
  }
done

# Gemfile.lock
find . -type f -name Gemfile.lock | while read gemfile; do
  echo === ${gemfile}
  local_gem_uri=$(printf ${uri_fmt} $(cd $(dirname ${gemfile}) && pwd))

  egrep remote: ${gemfile} -q && {
    perl -pi -e "s,remote: .*,remote: ${local_gem_uri},g" ${gemfile}
  }

  pwd

  (
    cd $(dirname ${gemfile})
    pwd

    mkdir .bundle
    cat <<EOS > .bundle/config
---
BUNDLE_DISABLE_SHARED_GEMS: "1"
BUNDLE_PATH: ./.vendor/bundle/
EOS

    bundle update
    bundle show
  )
done

bundle-local-gem.sh

#!/bin/bash
#  depends on generate-local-gem-repo.sh
#
set -e

LANG=C
LC_ALL=C

#git_repo_map="wakame-adapters=git://github.com/axsh/wakame-adapters.git"
#git_repo_map="wakame-vdc=git://github.com/axsh/wakame-vdc.git"
[ $# = 1 ]  || {
  echo "$0 [git repository uri]" >&2
  exit 1
}
git_repo_map=$1

abs_path=$(cd $(dirname $0) && pwd)
tmp_dir=${abs_path}/tmp
repo_dir=${tmp_dir}/local-repo
local_gem_builder_dir=${tmp_dir}/local-gem-builder

sub_dirs="
  ${tmp_dir}
  ${repo_dir}
"

[ -d ${tmp_dir} ] && rm -rf ${tmp_dir}

for sub_dir in ${sub_dirs}; do
  [ -d ${sub_dir} ] || mkdir -p ${sub_dir}
done

[ -d ${local_gem_builder_dir} ] || {
  git clone git://gist.github.com/1382117.git ${local_gem_builder_dir}
}

gem list | grep builder -q || {
  echo "builder is not installed." >&2
  echo "gem install builder" >&2
  exit 1
}

echo ... ${git_repo_map}
name=${git_repo_map%%=*}
repo=${git_repo_map##*=}

[ ${name} = ${repo} ] && {
  name=$(basename ${repo})
  echo ${name%%.git}
}

proj_dir=${repo_dir}/${name}
[ -d "${proj_dir}" ] || {
  git clone ${repo} ${proj_dir}
} && {
  (cd ${proj_dir} && git pull)
}

local_gem_repo_builder=${local_gem_builder_dir}/generate-local-gem-repo.sh
[ -x "${local_gem_repo_builder}" ] || {
  echo cannot exec ${local_gem_repo_builder}. >&2
  exit 1
}

gemfiles=$(find ${proj_dir} -type f -name Gemfile)
for gemfile in ${gemfiles}; do
  echo ... ${gemfile}
  # redefine "tmp_prefix" and "local_gem_dir" value in generate-local-gem-repo.sh.
  tmp_prefix=${tmp_prefix} local_gem_dir=$(dirname ${gemfile})/.vendor/local-gem ${local_gem_repo_builder} ${gemfile}
done

(cd ${repo_dir} && tar zcvf ${abs_path}/${name}.tar.gz ${name} --exclude=".git*")
echo "=> ${name}.tar.gz"

exit 0

generate-local-gem-repo.sh

#!/bin/bash
#
# $ generate-local-gem-repo.sh [Gemfile] [Gemfile] [Gemfile] ...
#
set -e

LANG=C
LC_ALL=C

gemfile_paths=$*
[ $# = 0 ] && exit 1

tmp_prefix=${tmp_prefix:-/var/tmp/__$(basename $0).$$}
gem_home=${gem_home:-${tmp_prefix}/gem-home}
ruby_ver=${ruby_ver:-1.8}
cached_gem_dir=${cached_gem_dir:-${gem_home}/ruby/${ruby_ver}/cache}
local_gem_dir=${local_gem_dir:-${tmp_prefix}/local-gem}

[ -d "${gem_home}" ] || mkdir -p ${gem_home}
[ -d "${local_gem_dir}" ] || mkdir -p ${local_gem_dir}

for gemfile_path in ${gemfile_paths}; do
  echo ... ${gemfile_path}
  [ -f "${gemfile_path}" ] || {
    echo no such file: ${gemfile_path} >&2
    exit 1
  }
  cp ${gemfile_path} ${tmp_prefix}

  cd ${tmp_prefix}; pwd
  bundle install --path=${gem_home}
  cd -; pwd
done

[ -d ${cached_gem_dir} ] || exit 1

for dir in ${local_gem_dir}/cache ${local_gem_dir}/cache; do
  [ -d ${dir} ] && rm -rf ${dir}
done

rsync -avx ${cached_gem_dir} ${local_gem_dir}/
mv ${local_gem_dir}/cache ${local_gem_dir}/gems

cd ${local_gem_dir}/
gem generate_index

echo "=> ${local_gem_dir}"