skinny

#!/bin/bash

current_dir=.
current_project=`ls | grep project`
script_dir=`dirname $0`
sbt_path=${script_dir}/sbt
sbt_debug_path=${script_dir}/sbt-debug
chmod +x ${sbt_path}
chmod +x ${sbt_debug_path}

# prepared deps
if [ -d "${current_dir}/ivy2" ]; then
  mkdir -p $HOME/.ivy2/cache/
  cp -prn ${current_dir}/ivy2/cache/* $HOME/.ivy2/cache/.
  rm -rf ${current_dir}/ivy2
fi

function verify_skinny_project() {
  if [ "${current_project}" == "" ]; then
    echo "Skinny applicaiton not found here!"
    exit 1
  fi
}

function run_app() {
  ${sbt_path} "~;container:restart"
}
function run_precompile_app() {
  ${sbt_path} "project precompileDev" "~;container:restart"
}
function run_debuggable_app() {
  ${sbt_debug_path} $1 "~;container:restart"
}
function setup_build() {
  rm -rf build
  mkdir build
  cp -pr src build/src
  cp -pr build.sbt build/build.sbt
}
function setup_standalone_build() {
  rm -rf standalone-build
  mkdir standalone-build
  cp -pr src standalone-build/src
  cp -p build.sbt standalone-build/
  cp -p _skinny_assembly_settings.sbt standalone-build/
}
function copy_resources_to_task() {
  rm -rf task/src/main/resources
  mkdir -p task/src/main/resources
  cp -pr src/main/resources/* task/src/main/resources/.
}
function setup_scalajs() {
  setting_file="${current_dir}/project/_skinny_scalajs.sbt"
  if [ ! -f "${setting_file}" ]; then
    echo "resolvers += \"scala-js-release\" at \"http://dl.bintray.com/scala-js/scala-js-releases\"
addSbtPlugin(\"org.scala-js\" % \"sbt-scalajs\" % \"0.6.4\")" > ${setting_file}

echo "lazy val scalajs = (project in file(\"src/main/webapp/WEB-INF/assets\")).settings(
  name := \"application\", // JavaScript file name
  scalaVersion := \"2.11.6\",
  unmanagedSourceDirectories in Compile <+= baseDirectory(_ / \"scala\"),
  libraryDependencies ++= Seq(
    \"org.scala-js\" %%% \"scalajs-dom\"    % \"0.8.0\",
    \"be.doeraene\"  %%% \"scalajs-jquery\" % \"0.8.0\",
    \"org.monifu\"   %%  \"minitest\"       % \"0.11\" % \"test\"
  ),
  crossTarget in Compile <<= baseDirectory(_ / \"..\" / \"..\" / \"assets\" / \"js\")
).enablePlugins(ScalaJSPlugin)" > ${current_dir}/_skinny_scalajs_settings.sbt
  fi
}

command="$1"
if [ "$command" != "" -a "$command" != "new" ]; then
  verify_skinny_project
fi

if [ "$command" == "new" ]; then
  name="$2"
  if [ "$name" == "" ]; then
    echo "Usage: ./skinny new [application name]"
    exit 1
  fi
  # node_modules can be configured with PREFIX env variable
  # homebrew formula will set this value to avoid using universal npm modules
  if [ "${PREFIX}" == "" ]; then
    existing_version=`npm list -g | grep generator-skinny`
    if [ "${existing_version}" == "" ]; then
      npm install -g yo
      npm install -g generator-skinny
    fi
  fi
  mkdir -p ${name}
  cd ${name}
  yo skinny

  echo " ******************************************** "
  echo "   New Skinny application has been created!"
  echo ""
  echo "   $ cd ./${name}"
  echo "   $ ./skinny run"
  echo ""
  echo "   Enjoy Scala programming!"
  echo ""
  echo " ******************************************** "
  echo ""

elif [ "$command" == "upgrade" ]; then
  npm update -g yo
  npm update -g generator-skinny
  mv package.json _package.json
  yo --no-insight skinny
  mv _package.json package.json
  
elif [ "$command" == "run" -o "$command" == "s" -o "$command" == "server" ]; then
  option="$2"
  if [ "$option" == "-precompile" -o "$option" == "--precompile" ]; then
    run_precompile_app
  else
    run_app
  fi
elif [ "$command" == "debug" -o "$command" == "d" ]; then
  port="$2"
  [ -z "${port}" ] && port=5005
  run_debuggable_app ${port}
elif [ "$command" == "clean" ]; then
  ${sbt_path} dev/clean
  ${sbt_path} task/clean
  copy_resources_to_task
elif [ "$command" == "update" ]; then
  ${sbt_path} update
elif [ "$command" == "console" ]; then
  ${sbt_path} dev/console
elif [ "$command" == "~compile" ]; then
  ${sbt_path} "project dev" "~;compile"
elif [ "$command" == "compile" ]; then
  ${sbt_path} dev/compile
elif [ "$command" == "test" ]; then
  export SKINNY_ENV="test"
  ${sbt_path} dev/test
elif [ "$command" == "~test" ]; then
  export SKINNY_ENV="test"
  ${sbt_path} "project dev" "~;test"
elif [ "$command" == "test-quick" -o "$command" == "testQuick" ]; then
  export SKINNY_ENV="test"
  ${sbt_path} dev/testQuick
elif [ "$command" == "~test-quick" -o "$command" == "~testQuick" ]; then
  export SKINNY_ENV="test"
  ${sbt_path} "project dev" "~;testQuick"
elif [ "$command" == "test-only" -o "$command" == "testOnly" ]; then
  export SKINNY_ENV="test"
  ${sbt_path} "dev/testOnly $2"
elif [ "$command" == "~test-only" -o "$command" == "~testOnly" ]; then
  export SKINNY_ENV="test"
  ${sbt_path} "project dev" "~;testOnly $2"
elif [ "$command" == "test:coverage" ]; then
  export SKINNY_ENV="test"
  ${sbt_path} "coverage" "dev/test"
elif [ "$command" == "scalajs:watch" ]; then
  setup_scalajs
  ${sbt_path} "project scalajs" "~;fastOptJS"
elif [ "$command" == "scalajs:package" ]; then
  setup_scalajs
  ${sbt_path} "project scalajs" fullOptJS
elif [ "$command" == "task:clean" ]; then
  ${sbt_path} "task/clean"
  copy_resources_to_task
elif [ "$command" == "task:run" ]; then
  copy_resources_to_task
  shift
  command="task/run $@"
  ${sbt_path} "${command}"
elif [ "$command" == "g" -o "$command" == "generate" ]; then
  generator_type="$2"
  shift
  shift
  if [ "$generator_type" == "" ]; then
    echo "Usage: ./skinny g/generate [type] [options...]"
  else
    copy_resources_to_task
    command="task/run generate:$generator_type $@"
    ${sbt_path} "${command}"
  fi
elif [ "$command" == "db:migrate" ]; then
  copy_resources_to_task
  shift
  ${sbt_path} "task/run db:migrate $@"
elif [ "$command" == "db:repair" ]; then
  copy_resources_to_task
  shift
  ${sbt_path} "task/run db:repair $@"
elif [ "$command" == "eclipse" ]; then
  setting_file="${current_dir}/project/_skinny_eclipse.sbt"
  if [ ! -f "${setting_file}" ]; then
    echo "addSbtPlugin(\"com.typesafe.sbteclipse\" % \"sbteclipse-plugin\" % \"2.4.0\")" > ${setting_file} 
  fi
  ${sbt_path} eclipse
elif [ "$command" == "idea" -o "$command" == "gen-idea" ]; then
  ${sbt_path} gen-idea
elif [ "$command" == "package" ]; then
  setup_build
  copy_resources_to_task
  ${sbt_path} "task/run assets:precompile" build/package
elif [ "$command" == "package:standalone" ]; then
  setting_file="${current_dir}/project/_skinny_assembly.sbt"
  if [ ! -f "${setting_file}" ]; then
    echo "addSbtPlugin(\"com.eed3si9n\" % \"sbt-assembly\" % \"0.11.2\")" > ${setting_file} 
    echo "import AssemblyKeys._

assemblySettings

mainClass in assembly := Some(\"skinny.standalone.JettyLauncher\")

_root_.sbt.Keys.test in assembly := {}

resourceGenerators in Compile <+= (resourceManaged, baseDirectory) map { (managedBase, base) =>
  val webappBase = base / \"src\" / \"main\" / \"webapp\"
  for ( (from, to) <- webappBase ** \"*\" \`pair\` rebase(webappBase, managedBase / \"main/\") )
  yield {
    Sync.copy(from, to)
    to
  }
}
" > "${current_dir}/_skinny_assembly_settings.sbt"
  fi

  setup_standalone_build
  copy_resources_to_task
  ${sbt_path} "task/run assets:precompile standalone-build"
  ${sbt_path} standalone-build/assembly
elif [ "$command" == "publish" ]; then
  setup_build
  copy_resources_to_task
  ${sbt_path} "task/run assets:precompile" build/publish
else
  echo ""
  echo " Usage: ./skinny [COMMAND] [OPTIONS]..."
  echo ""
  echo "  new             : will create new Skinny application"
  echo "  upgrade         : will upgrade Skinny app project"
  echo "  run/server/s    : will run application for local development"
  echo "  run -precompile : will run application with Scalate precompilation"
  echo "  debug/d         : will run application with JDWP. default port 5005"
  echo "  clean           : will clear target directory"
  echo "  update          : will run sbt update"
  echo "  console         : will run sbt console"
  echo "  compile         : will compile all the classes"
  echo "  ~compile        : will compile all the classes when changes are detected"
  echo "  db:migrate      : will execute database migration"
  echo "  db:repair       : will recover when previous migration failed"
  echo "  test            : will run all the tests"
  echo "  ~test           : will run all the tests when changes are detected"
  echo "  testQuick       : will run only failed tests"
  echo "  ~testQuick      : will run only failed tests when changes are detected"
  echo "  testOnly        : will run the specified test"
  echo "  ~testOnly       : will run the specified test when changes are detected"
  echo "  test:coverage   : will run all the tests and output coverage reports"
  echo "  package            : will create *.war file to deploy"
  echo "  package:standalone : will create *.jar file to run as stand alone app"
  echo "  publish            : will publish *.war file to repository"
  echo ""
  echo "  scalajs:watch    : will watch Scala.js Scala code change and convert to JS"
  echo "  scalajs:package  : will convert Scala.js Scala code to JS file"
  echo ""
  echo "  eclipse       : will setup Scala IDE settings"
  echo "  idea/gen-idea : will setup IntelliJ IDEA settings"
  echo ""
  echo "  task:clean    : will clean task project's target directory"
  echo "  task:run      : will run tasks"
  echo ""
  echo "  g/generate controller : will generate controller"
  echo "  g/generate model      : will generate model"
  echo "  g/generate migration  : will generate db migration file"
  echo ""
  echo "  g/generate scaffold       : will generate scaffold files with ssp templates"
  echo "  g/generate scaffold:scaml : will generate scaffold files with scaml templates"
  echo "  g/generate scaffold:jade  : will generate scaffold files with jade templates"
  echo ""
  echo "  g/generate reverse-scaffold       : will generate scaffold from existing database"
  echo "  g/generate reverse-scaffold:scaml : will generate scaffold from existing database"
  echo "  g/generate reverse-scaffold:jade  : will generate scaffold from existing database"
  echo ""
fi