perkins 0.0.1

data/lib/perkins/build/script/bundler.rb

@@ -0,0 +1,76 @@
+module Perkins
+  module Build
+    class Script
+      module Bundler
+        DEFAULT_BUNDLER_ARGS = "--jobs=3 --retry=3"
+
+        def cache_slug
+          super << "--gemfile-" << config[:gemfile].to_s
+        end
+
+        def use_directory_cache?
+          super || data.cache?(:bundler)
+        end
+
+        def setup
+          super
+
+          gemfile? do |sh|
+            sh.set "BUNDLE_GEMFILE", "$PWD/#{config[:gemfile]}"
+          end
+        end
+
+        def announce
+          super
+          cmd "bundle --version", timing: false
+        end
+
+        def install
+          gemfile? do |sh|
+            sh.if "-f #{config[:gemfile]}.lock" do |sub|
+              directory_cache.add(sub, bundler_path) if data.cache?(:bundler)
+              sub.cmd bundler_command("--deployment"), fold: "install.bundler", retry: true
+            end
+
+            sh.else do |sub|
+              # Cache bundler if it has been explicitly enabled
+              directory_cache.add(sub, bundler_path) if data.cache?(:bundler, false)
+              sub.cmd bundler_command, fold: "install.bundler", retry: true
+            end
+          end
+        end
+
+        def prepare_cache
+          cmd("bundle clean") if bundler_path
+        end
+
+        private
+
+        def gemfile?(*args, &block)
+          self.if "-f #{config[:gemfile]}", *args, &block
+        end
+
+        def bundler_args_path
+          args = Array(bundler_args).join(" ")
+          path = args[/--path[= ](\S+)/, 1]
+          path ||= "vendor/bundle" #if args.include?("--deployment")
+          path
+        end
+
+        def bundler_path
+          bundler_args_path || "${BUNDLE_PATH:-vendor/bundle}"
+        end
+
+        def bundler_command(args = nil)
+          args = bundler_args || [DEFAULT_BUNDLER_ARGS, args].compact
+          args = [args].flatten << "--path=#{bundler_path}" if data.cache?(:bundler) && !bundler_args_path
+          ["bundle install", *args].compact.join(" ")
+        end
+
+        def bundler_args
+          config[:bundler_args]
+        end
+      end
+    end
+  end
+end

data/lib/perkins/build/script/go.rb

@@ -0,0 +1,100 @@
+module Perkins
+  module Build
+    class Script
+      class Go < Script
+        DEFAULTS = {
+          gobuild_args: '-v',
+          go: '1.3.1'
+        }
+
+        def cache_slug
+          super << "--go-" << config[:go].to_s
+        end
+
+        def pre_setup
+          puts "configure"
+        end
+
+        def configure
+          puts "configure"
+        end
+
+        def export
+          super
+          "export GO_VERSION=#{go_version}"
+        end
+
+        def announce
+          super
+          'gvm version && ' <<
+          'go version && ' <<
+          'go env'
+        end
+
+        def setup
+          super
+          "gvm get &&" <<
+          "gvm update && source #{HOME_DIR}/.gvm/scripts/gvm && " <<
+          "gvm install #{go_version} --binary || gvm install #{go_version} && " <<
+          "gvm use #{go_version} && "
+          # Prepend *our* GOPATH entry so that built binaries and packages are
+          # easier to find and our `git clone`'d libraries are found by the
+          # `go` commands.
+          source_path = repo.url.gsub(/https\:\/\/|\.git/, "")
+          source_owner_path = source_path.split('/')[0..1].join("/")
+          local_path = self.repo.working_dir + self.repo.name
+          "export GOPATH=#{HOME_DIR}/gopath:$GOPATH && " <<
+          #binding.pry
+          "mkdir -p #{HOME_DIR}/gopath/src/#{source_owner_path} && " <<
+          "cp -r #{local_path} #{HOME_DIR}/gopath/src/#{source_owner_path} && " <<
+          "export BUILD_DIR=#{HOME_DIR}/gopath/src/#{source_path} && " <<
+          "cd #{HOME_DIR}/gopath/src/#{source_path}"
+        end
+
+        def install
+          if uses_make?
+            'true'
+          else
+            "go get #{config[:gobuild_args]} ./..."
+          end
+        end
+
+        def script
+          if uses_make?
+            'make'
+          else
+            "go test #{config[:gobuild_args]} ./..."
+          end
+        end
+
+        private
+
+          def uses_make?(*args)
+            self.if '-f GNUmakefile || -f makefile || -f Makefile || -f BSDmakefile', *args
+          end
+
+          def go_version
+            version = config[:go].to_s
+            case version
+            when '1'
+              'go1.3.1'
+            when '1.0'
+              'go1.0.3'
+            when '1.2'
+              'go1.2.2'
+            when '1.3'
+              'go1.3.1'
+            when /^[0-9]\.[0-9\.]+/
+              "go#{config[:go]}"
+            else
+              if config[:go].is_a?(Travis::Yaml::Nodes::VersionList)
+                config[:go].first
+              else
+                config[:go]
+              end
+            end
+          end
+      end
+    end
+  end
+end

data/lib/perkins/build/script/helpers.rb

@@ -0,0 +1,39 @@
+module Perkins
+  module Build
+    class Script
+      module Helpers
+        Shell::Dsl.instance_methods(false).each do |name|
+          define_method(name) do |*args, &block|
+            options = args.last if args.last.is_a?(Hash)
+            sh.send(name, *args, &stacking(&block)) unless sh.blank?
+          end
+        end
+
+        def sh
+          stack.last
+        end
+
+        def failure(message)
+          echo message
+          raw 'false'
+        end
+
+        def stacking
+          ->(sh) {
+            stack.push(sh)
+            yield(sh) if block_given?
+            stack.pop
+          }
+        end
+
+        def before_install
+          puts "before install"
+        end
+
+        def announce?(stage)
+          stage && stage != :after_result
+        end
+      end
+    end
+  end
+end

data/lib/perkins/build/script/jdk.rb

@@ -0,0 +1,43 @@
+module Perkins
+  module Build
+    class Script
+      module Jdk
+        def export
+          super
+          set 'TRAVIS_JDK_VERSION', config[:jdk], echo: false if uses_jdk?
+        end
+
+        def setup
+          super
+          cmd "jdk_switcher use #{config[:jdk]}", assert: true, timing: false if uses_jdk?
+          self.if '-f build.gradle' do
+            set 'TERM', 'dumb', echo: false
+          end
+        end
+
+        def announce
+          super
+          if uses_java?
+            cmd "java -version", timing: false
+            cmd "javac -version", timing: false
+          end
+        end
+
+        def cache_slug
+          return super unless uses_jdk?
+          super << "--jdk-" << config[:jdk].to_s
+        end
+
+        private
+
+          def uses_java?
+            true
+          end
+
+          def uses_jdk?
+            !!config[:jdk]
+          end
+      end
+    end
+  end
+end

data/lib/perkins/build/script/ruby.rb

@@ -0,0 +1,31 @@
+module Perkins
+  module Build
+    class Script
+      class Ruby < Script
+        DEFAULTS = {
+          rvm:     'default',
+          gemfile: 'Gemfile'
+        }
+
+        include Jdk
+        include RVM
+        include Bundler
+
+        def announce
+          super
+          cmd 'gem --version', timing: false
+        end
+
+        def script
+          gemfile? then: 'bundle exec rake', else: 'rake'
+        end
+
+        private
+
+        def uses_java?
+          uses_jdk?
+        end
+      end
+    end
+  end
+end

data/lib/perkins/build/script/rvm.rb

@@ -0,0 +1,73 @@
+module Perkins
+  module Build
+    class Script
+      module RVM
+        def cache_slug
+          super << "--rvm-" << ruby_version.to_s
+        end
+
+        def export
+          super
+          set 'TRAVIS_RUBY_VERSION', config[:rvm], echo: false
+        end
+
+        def setup
+          super
+          config[:ruby] ? setup_chruby : setup_rvm
+        end
+
+        def announce
+          super
+          cmd 'ruby --version'
+          if config[:ruby]
+            cmd 'chruby --version'
+          else
+            cmd 'rvm --version'
+          end
+        end
+
+        private
+
+        def ruby_version
+          config[:rvm].to_s.gsub(/-(1[89]|2[01])mode$/, '-d\1')
+        end
+
+        def setup_chruby
+          echo 'BETA: Using chruby to select Ruby version. This is currently a beta feature and may change at any time."', color: :yellow
+          cmd "curl -sLo ~/chruby.sh https://gist.githubusercontent.com/henrikhodne/a01cd7367b12a59ee051/raw/chruby.sh", echo: false
+          cmd "source ~/chruby.sh", echo: false
+          cmd "chruby #{config[:ruby]}"
+        end
+
+        def setup_rvm
+          file '$rvm_path/user/db', %w(
+            rvm_remote_server_url3=https://s3.amazonaws.com/travis-rubies/binaries
+            rvm_remote_server_type3=rubies
+            rvm_remote_server_verify_downloads3=1
+          ).join("\n")
+
+          if ruby_version =~ /ruby-head/
+            fold("rvm.1") do
+              echo 'Setting up latest %s' % ruby_version, ansi: :yellow
+              cmd "rvm get stable", assert: false if ruby_version == 'jruby-head'
+              set 'ruby_alias', "`rvm alias show #{ruby_version} 2>/dev/null`"
+              cmd "rvm alias delete #{ruby_version}", assert: false
+              cmd "rvm remove ${ruby_alias:-#{ruby_version}} --gems", assert: false
+              cmd "rvm remove #{ruby_version} --gems --fuzzy", assert: false
+              cmd "rvm install #{ruby_version} --binary"
+            end
+            cmd "rvm use #{ruby_version}"
+          elsif ruby_version == 'default'
+            self.if "-f .ruby-version" do |sh|
+              sh.echo 'BETA: Using Ruby version from .ruby-version. This is a beta feature and may be removed in the future.', color: :yellow
+              fold("rvm.1") { sh.cmd "rvm use . --install --binary --fuzzy" }
+            end
+            self.else "rvm use default"
+          else
+            fold("rvm.1") { cmd "rvm use #{ruby_version} --install --binary --fuzzy" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/perkins/build/script/stages.rb

@@ -0,0 +1,28 @@
+module Perkins
+  module Build
+    class Script
+      module Stages
+
+        def run_stages
+          STAGES[:builtin].each { |stage| run_builtin_stage(stage) }
+          STAGES[:custom].each  { |stage| run_stage(stage) }
+        end
+
+        def run_builtin_stage(stage)
+          self.send(stage)
+        end
+
+        def run_stage(stage)
+          puts "call #{stage}"
+          call_custom_stage(stage)
+        end
+
+        def call_custom_stage(stage)
+          #binding.pry
+          @config.send(stage).present? ? cmd(@config.send(stage)) : self.send(stage)
+        end
+
+      end
+    end
+  end
+end

data/lib/perkins/build/script/templates/footer.sh

@@ -0,0 +1,3 @@
+echo -e "\nDone. Your build exited with $TRAVIS_TEST_RESULT."
+
+travis_terminate $TRAVIS_TEST_RESULT

data/lib/perkins/build/script/templates/header.sh

@@ -0,0 +1,201 @@
+#!/bin/bash
+source $HOME/.profile
+
+ANSI_RED="\033[31;1m"
+ANSI_GREEN="\033[32;1m"
+ANSI_RESET="\033[0m"
+ANSI_CLEAR="\033[0K"
+
+TRAVIS_TEST_RESULT=
+TRAVIS_CMD=
+
+function travis_cmd() {
+  local assert output display retry timing cmd result
+
+  cmd=$1
+  TRAVIS_CMD=$cmd
+  shift
+
+  while true; do
+    case "$1" in
+      --assert)  assert=true; shift ;;
+      --echo)    output=true; shift ;;
+      --display) display=$2;  shift 2;;
+      --retry)   retry=true;  shift ;;
+      --timing)  timing=true; shift ;;
+      *) break ;;
+    esac
+  done
+
+  if [[ -n "$timing" ]]; then
+    travis_time_start
+  fi
+
+  if [[ -n "$output" ]]; then
+    echo "\$ ${display:-$cmd}"
+  fi
+
+  if [[ -n "$retry" ]]; then
+    travis_retry eval "$cmd"
+  else
+    eval "$cmd"
+  fi
+  result=$?
+
+  if [[ -n "$timing" ]]; then
+    travis_time_finish
+  fi
+
+  if [[ -n "$assert" ]]; then
+    travis_assert $result
+  fi
+
+  travis_result $result
+  return $result
+}
+
+travis_time_start() {
+  travis_timer_id=$(printf %08x $(( RANDOM * RANDOM )))
+  travis_start_time=$(travis_nanoseconds)
+  echo -en "travis_time:start:$travis_timer_id\r${ANSI_CLEAR}"
+}
+
+travis_time_finish() {
+  local result=$?
+  travis_end_time=$(travis_nanoseconds)
+  local duration=$(($travis_end_time-$travis_start_time))
+  echo -en "travis_time:end:$travis_timer_id:start=$travis_start_time,finish=$travis_end_time,duration=$duration\r${ANSI_CLEAR}"
+  return $result
+}
+
+function travis_nanoseconds() {
+  local cmd="date"
+  local format="+%s%N"
+  local os=$(uname)
+
+  if hash gdate > /dev/null 2>&1; then
+    cmd="gdate" # use gdate if available
+  elif [[ "$os" = Darwin ]]; then
+    format="+%s000000000" # fallback to second precision on darwin (does not support %N)
+  fi
+
+  $cmd -u $format
+}
+
+travis_assert() {
+  local result=${1:-$?}
+  if [ $result -ne 0 ]; then
+    echo -e "\n${ANSI_RED}The command \"$TRAVIS_CMD\" failed and exited with $result during $TRAVIS_STAGE.${ANSI_RESET}\n\nYour build has been stopped."
+    travis_terminate 2
+  fi
+}
+
+travis_result() {
+  local result=$1
+  export TRAVIS_TEST_RESULT=$(( ${TRAVIS_TEST_RESULT:-0} | $(($result != 0)) ))
+  if [ $result -eq 0 ]; then
+    echo -e "\n${ANSI_GREEN}The command \"$TRAVIS_CMD\" exited with $result.${ANSI_RESET}"
+  else
+    echo -e "\n${ANSI_RED}The command \"$TRAVIS_CMD\" exited with $result.${ANSI_RESET}"
+  fi
+}
+
+travis_terminate() {
+  pkill -9 -P $$ &> /dev/null || true
+  exit $1
+}
+
+travis_wait() {
+  local timeout=$1
+
+  if [[ $timeout =~ ^[0-9]+$ ]]; then
+    # looks like an integer, so we assume it's a timeout
+    shift
+  else
+    # default value
+    timeout=20
+  fi
+
+  local cmd="$@"
+  local log_file=travis_wait_$$.log
+
+  $cmd &>$log_file &
+  local cmd_pid=$!
+
+  travis_jigger $! $timeout $cmd &
+  local jigger_pid=$!
+  local result
+
+  {
+    wait $cmd_pid 2>/dev/null
+    result=$?
+    ps -p$jigger_pid &>/dev/null && kill $jigger_pid
+  } || return 1
+
+  if [ $result -eq 0 ]; then
+    echo -e "\n${ANSI_GREEN}The command \"$TRAVIS_CMD\" exited with $result.${ANSI_RESET}"
+  else
+    echo -e "\n${ANSI_RED}The command \"$TRAVIS_CMD\" exited with $result.${ANSI_RESET}"
+  fi
+
+  echo -e "\n${ANSI_GREEN}Log:${ANSI_RESET}\n"
+  cat $log_file
+
+  return $result
+}
+
+travis_jigger() {
+  # helper method for travis_wait()
+  local cmd_pid=$1
+  shift
+  local timeout=$1 # in minutes
+  shift
+  local count=0
+
+  # clear the line
+  echo -e "\n"
+
+  while [ $count -lt $timeout ]; do
+    count=$(($count + 1))
+    echo -ne "Still running $count of $timeout: $@\r"
+    sleep 60
+  done
+
+  echo -e "\n${ANSI_RED}Timeout ${timeout} minutes reached. Terminating \"$@\"${ANSI_RESET}\n"
+  kill -9 $cmd_pid
+}
+
+travis_retry() {
+  local result=0
+  local count=1
+  while [ $count -le 3 ]; do
+    [ $result -ne 0 ] && {
+      echo -e "\n${ANSI_RED}The command \"$@\" failed. Retrying, $count of 3.${ANSI_RESET}\n" >&2
+    }
+    "$@"
+    result=$?
+    [ $result -eq 0 ] && break
+    count=$(($count + 1))
+    sleep 1
+  done
+
+  [ $count -gt 3 ] && {
+    echo -e "\n${ANSI_RED}The command \"$@\" failed 3 times.${ANSI_RESET}\n" >&2
+  }
+
+  return $result
+}
+
+travis_fold() {
+  local action=$1
+  local name=$2
+  echo -en "travis_fold:${action}:${name}\r${ANSI_CLEAR}"
+}
+
+decrypt() {
+  echo $1 | base64 -d | openssl rsautl -decrypt -inkey ~/.ssh/id_rsa.repo
+}
+
+mkdir -p <%= BUILD_DIR %>
+cd       <%= @working_dir %>
+

data/lib/perkins/build/script/templates/xcode.sh

@@ -0,0 +1,21 @@
+mkdir ~/bin
+cat > ~/bin/xcodebuild <<EOF
+#!/usr/bin/env perl
+
+my $status = 1;
+
+open my $fh, "-|", @ARGV
+  or die "unable to run command: $!\n";
+
+while (my $line = readline($fh)) {
+	print $line;
+	$status = 0 if $line =~ /^\*\* TEST SUCCEEDED \*\*$/;
+}
+
+close $fh;
+
+exit $status;
+EOF
+chmod +x ~/bin/xcodebuild
+
+export PATH="$HOME/bin:$PATH"