rakefile

# Copyright (C) 2011 Titanium I.T. LLC. All rights reserved. See LICENSE.txt for details.

require 'socket'
require 'timeout'
require "rake/testtask"

SRC_DIR = "src"
LIB_DIR = "lib"
BUILD_DIR = "build"
OUTPUT_DIR = "generated"
GEMS_DIR = "gems"
BIN_DIR = "#{BUILD_DIR}/vendor"
MERGED_DIR = "#{OUTPUT_DIR}/merged"
RESULTS_DIR = "#{OUTPUT_DIR}/run_results" 

RHINO_JAR = "#{BIN_DIR}/rhino.jar"
JSLINTRUNNER_JS = "#{BUILD_DIR}/jslintrunner.js"

PID_DIR = "#{OUTPUT_DIR}/pid"
JSTESTDRIVER_JAR = "#{BIN_DIR}/JsTestDriver-1.3.1.jar"
JSTESTDRIVER_PORT = 4224
JSTESTDRIVER_PID_FILE = "#{PID_DIR}/jstestdriver.pid"
JSTESTDRIVER_SERVER_TIMEOUT_IN_SEC = 10
JSTESTDRIVER_BROWSER_TIMEOUT_IN_SEC = 10

JS_TEST_CONF = "#{BUILD_DIR}/JsTestDriver.conf"
JS_SRC_DIR = "#{SRC_DIR}/javascript"
MAIN_JS_SOURCE = "#{JS_SRC_DIR}/object.js"
MERGED_JS = "#{MERGED_DIR}/schedule.js"

HTML_SRC_DIR = "#{SRC_DIR}/html"
MAIN_HTML_SOURCE = "#{HTML_SRC_DIR}/projection.html"
MERGED_HTML = "#{MERGED_DIR}/projection.html"
MERGE_REGEX = /<%=\s*rabu_library\s*%>/

MINIFIER_JAR = "#{BIN_DIR}/closure-compiler-1043/compiler.jar"
MINIFIED_DIR = "#{OUTPUT_DIR}/minified"
MINIFIED_JS = "#{MINIFIED_DIR}/schedule.js"
MINIFIED_JS_TEST_CONF = "#{MINIFIED_DIR}/jstestdriver.conf"

JAVA_PACKAGE = "com.teamrabu.schedule.cli"
JAVA_PACKAGE_DIR = "com/teamrabu/schedule/cli"
JAVA_SRC_DIR = "#{SRC_DIR}/cli/src"
JAVA_OUTPUT_DIR = "#{OUTPUT_DIR}/java"
JAVA_SRC_RESOURCE_DIR = "#{JAVA_SRC_DIR}/#{JAVA_PACKAGE_DIR}/resources"
JAVA_OUTPUT_RESOURCE_DIR = "#{JAVA_OUTPUT_DIR}/#{JAVA_PACKAGE_DIR}/resources"

JAR_DIR = "#{OUTPUT_DIR}/jar"
JAR_FILE = "#{JAR_DIR}/rabu.jar"
CLI_COMMAND_LINE = "java -jar #{JAR_FILE}"

TEST_CONFIG = "#{HTML_SRC_DIR}/_html_test.rabu"
TEST_OUTPUT = "#{RESULTS_DIR}/projection.html"

PROJECTION_DIR = "#{OUTPUT_DIR}/projection"
PROJECTION_CONFIG = "estimates.rabu"
PROJECTION_HTML = "#{PROJECTION_DIR}/projection.html"

RELEASE_STAGING_DIR = "#{OUTPUT_DIR}/release"
RELEASE_ZIP_FILE = "#{OUTPUT_DIR}/rabu.zip"
RELEASE_DIR = "released"

MARKDOWN_DIR = "#{OUTPUT_DIR}/markdown"
README_HTML = "#{MARKDOWN_DIR}/readme.html"
CHANGELOG_HTML = "#{MARKDOWN_DIR}/CHANGELOG.html"

LICENSE_TXT = "LICENSE.txt"
AGPL_TXT = "copyrights/AGPL.txt"


##### Isolate Gems

def isolate_gems
	$:.unshift "#{BIN_DIR}/isolate-3.1.0.pre.3/lib"
	require 'isolate'
	Isolate.now! :system => false, :path => GEMS_DIR, :install => true do
		gem "selenium-webdriver", "2.21.2"
		gem "watir-webdriver", "0.5.6"
		gem "redcarpet", "1.17.2"
	end
end
isolate_gems
		
		
##### Directories

directory PID_DIR
directory MERGED_DIR
directory MINIFIED_DIR
directory JAVA_OUTPUT_DIR
directory JAR_DIR
directory RESULTS_DIR
directory PROJECTION_DIR
directory MARKDOWN_DIR
directory RELEASE_STAGING_DIR
directory RELEASE_DIR


##### Clean

desc "Erase all generated files (except gems)"
task :clean => [:shutdown] do       # must shut down because the pid file is in output directory
    explain "Cleaning build" do
        rm_rf OUTPUT_DIR
    end
end

desc "Erase absolutely all generated files (including gems)"
task :nuke => [:clean] do
	rm_rf GEMS_DIR
end


##### Tests

desc "Check everything"
task :default => [:check_all]
task :check_all => [:javascript, :html, :java, :minifier_test]

desc "Check Javascript"
task :javascript => [:js_test, :js_lint]

desc "Check HTML"
task :html => [:html_test]

desc "Check Java"
task :java => [:java_test]

task :js_test => [:startup] do
    explain "Running Javascript unit tests" do
        JsTestDriver::run_tests(JS_TEST_CONF)
    end
end

task :js_lint do
	explain "Running lint" do
		# NOTE: Because I haven't figured out how to pass command-line arguments
		# to Rhino scripts, jslintrunner must be configured by editing source file.
		run "Lint", "java -jar #{RHINO_JAR} #{JSLINTRUNNER_JS}"
	end
end

task :minifier_test => [MINIFIED_JS, MINIFIED_JS_TEST_CONF, :startup] do
	next if !minify?
	explain "Testing minification" do
        JsTestDriver::run_tests(MINIFIED_JS_TEST_CONF)
	end
end

task :html_test => [TEST_OUTPUT] do
    require "#{HTML_SRC_DIR}/_html_test"
    explain "Running HTML unit tests" do
        test_html(TEST_OUTPUT)
    end
end

task :java_test => [:javac] do
	explain "Running CLI unit tests" do
		run "JUnit", "java -cp #{LIB_DIR}/junit-4.9b2.jar:#{JAVA_OUTPUT_DIR} org.junit.runner.JUnitCore #{JAVA_PACKAGE}._GeneratorTest #{JAVA_PACKAGE}._SimpleFileTest"
	end
end


##### Tools

desc "Update projection"
task :projection => [PROJECTION_HTML]

desc "Generate output file"
task :output => [TEST_OUTPUT]


##### Builds

desc "Build markdown"
task :markdown => [MARKDOWN_DIR] do
	explain "Rendering Markdown" do
		require 'redcarpet'
		FileList.new('*.md').each do |in_name|
			root_name = /^(.*)\.md$/.match(in_name)[1]
			out_name = "#{MARKDOWN_DIR}/#{root_name}.html"
			puts "#{in_name} => #{out_name}"
			markdown = Redcarpet.new(IO.read(in_name))
			File.open(out_name, "w") do |out_file|
				out_file.write markdown.to_html
			end
		end
	end
end

task MERGED_JS => [MAIN_JS_SOURCE, MERGED_DIR] do
	explain "Merging Javascript" do
		rm_f MERGED_JS
		puts "Concatenating #{MERGED_JS}"
		File.open(MERGED_JS, "w") do |dest_file|
			files = FileList.new(
				"#{LIB_DIR}/jquery-1.6.1.js",
				"#{LIB_DIR}/jqueryui-1.8.13/jquery.ui.core.js",
				"#{LIB_DIR}/jqueryui-1.8.13/jquery.ui.widget.js",
				"#{LIB_DIR}/jqueryui-1.8.13/jquery.ui.mouse.js",
				"#{LIB_DIR}/jqueryui-1.8.13/jquery.ui.draggable.js",
				"#{LIB_DIR}/*.js",
				MAIN_JS_SOURCE,
				"#{JS_SRC_DIR}/**/*.js"
			)
			files.exclude "#{JS_SRC_DIR}/**/_*test.js"
			files.uniq.each do |src_file|
				append(src_file, dest_file)
			end
		end
	end
end

task MINIFIED_JS_TEST_CONF => [MINIFIED_DIR] do
	next unless minify?
	explain "Configuring minification tests" do
		puts "cat > #{MINIFIED_JS_TEST_CONF}"
		File.open(MINIFIED_JS_TEST_CONF, "w") do |file|
			file.write("server: http://localhost:#{JSTESTDRIVER_PORT}\n")
			file.write("\n")
			file.write("load:\n")
			file.write(" - #{MINIFIED_JS}\n")
			FileList.new("#{JS_SRC_DIR}/**/_*test.js").each do |filename|
				file.write(" - #{filename}\n")
			end
		end
		puts IO.readlines(MINIFIED_JS_TEST_CONF)
	end
end

task MINIFIED_JS => [MERGED_JS, MINIFIED_DIR] do
	if (!minify?) then
		explain "Skipping minification" do
			cp MERGED_JS, MINIFIED_JS
		end
	else
		explain "Minifying Javascript" do
			rm_f MINIFIED_JS
			# Using ADVANCED_OPTIMIZATIONS caused the tests to fail--last checked 24 June 2011
			# Consider replacing Closure Compiler with Uglify.js in future--it gets good reviews
			run "Closure Compiler", "java -jar #{MINIFIER_JAR} --js #{MERGED_JS} --js_output_file #{MINIFIED_JS} --compilation_level SIMPLE_OPTIMIZATIONS --warning_level QUIET"
		end
	end
end

task MERGED_HTML => [MAIN_HTML_SOURCE, MINIFIED_JS, MERGED_DIR] do
	explain "Merging HTML" do
		rm_f MERGED_HTML
		puts "Concatenating #{MERGED_HTML}"
		merged_library = false;
		File.open(MERGED_HTML, "w") do |dest_file|
			puts "  #{MAIN_HTML_SOURCE}"
			IO.readlines(MAIN_HTML_SOURCE).each do |line|
				if MERGE_REGEX.match line then
					append(MINIFIED_JS, dest_file)
					merged_library = true
				else
					dest_file.write line
				end
			end
		end
		raise "Merge regex (#{MERGE_REGEX.inspect}) not found in #{MAIN_HTML_SOURCE}" unless merged_library
	end
end

task :javac => [MERGED_HTML] do
	explain "Compiling Java" do
		rm_rf JAVA_OUTPUT_DIR
		mkdir JAVA_OUTPUT_DIR
		run "Java compile", "javac -cp #{LIB_DIR}/*.jar -d #{JAVA_OUTPUT_DIR} #{JAVA_SRC_DIR}/#{JAVA_PACKAGE_DIR}/*.java"
		mkdir JAVA_OUTPUT_RESOURCE_DIR
		cp MERGED_HTML, JAVA_OUTPUT_RESOURCE_DIR
		FileList.new("#{JAVA_SRC_RESOURCE_DIR}/*").each do |src_file|
			cp src_file, JAVA_OUTPUT_RESOURCE_DIR
		end
	end
end

task :cli => JAR_FILE
task JAR_FILE => [:javac, JAR_DIR] do
	explain "Building JAR file" do
		rm_f JAR_FILE
		run "Java Jar", "jar cmf #{JAVA_SRC_DIR}/mainClass #{JAR_FILE} -C #{JAVA_OUTPUT_DIR} com"
	end
end

task TEST_OUTPUT => [RESULTS_DIR, JAR_FILE] do
	explain "Creating Rabu output file" do
		run "Rabu", "#{CLI_COMMAND_LINE} < #{TEST_CONFIG} > #{TEST_OUTPUT}"
	end
end

task PROJECTION_HTML => [PROJECTION_DIR, JAR_FILE] do
	explain "Updating release projection" do
		run "Rabu", "#{CLI_COMMAND_LINE} < #{PROJECTION_CONFIG} > #{PROJECTION_HTML}"
	end
end

task :release_staging => [:markdown, JAR_FILE, PROJECTION_CONFIG] do
	explain "Staging release" do
		rm_rf RELEASE_STAGING_DIR
		mkdir RELEASE_STAGING_DIR
		cp JAR_FILE, RELEASE_STAGING_DIR
		cp TEST_CONFIG, "#{RELEASE_STAGING_DIR}/estimates.rabu"
		cp README_HTML, RELEASE_STAGING_DIR
		cp CHANGELOG_HTML, RELEASE_STAGING_DIR
		cp LICENSE_TXT, RELEASE_STAGING_DIR
		cp AGPL_TXT, RELEASE_STAGING_DIR
	end
end

task RELEASE_ZIP_FILE => [:release_staging] do
	explain "Zipping release" do
		rm_f RELEASE_ZIP_FILE
		run "Zip", "zip -rj #{RELEASE_ZIP_FILE} #{RELEASE_STAGING_DIR}/*"
	end
end

desc "Create tested release package (use 'minify=true')"
task :release => [:check_all, RELEASE_ZIP_FILE] do
	explain "Creating official release" do
		raise "Must use 'minify=true' when creating release" unless minify?
		rm_rf RELEASE_DIR
		mkdir RELEASE_DIR
		cp RELEASE_ZIP_FILE, RELEASE_DIR
	end
end


##### JsTestDriver

desc "Start JsTestDriver"
task :startup => [PID_DIR] do
    next if JsTestDriver::is_running?
    explain "Starting JsTestDriver (use 'rake shutdown' to stop)" do
        JsTestDriver::launch
    end
end

desc "Shut down JsTestDriver"
task :shutdown do
    next unless JsTestDriver::is_running?
    explain "Shutting down JsTestDriver server (close the JsTestDriver browser manually)" do
        JsTestDriver::terminate
    end
end

desc "Reset JsTestDriver"
task :reset => [:startup] do
	explain "Resetting JsTestDriver" do
		JsTestDriver::reset
	end
end


##### Helpers

def append(src_filename, dest_file)
	puts "  #{src_filename}"
	dest_file.write(IO.read(src_filename))
end

def explain(headline, &block)
    puts
    puts bright(headline)
    block.call
end

def bright(text)
    return "\033[1m#{text}\033[0m";
end

def minify?()
	ENV['minify']
end

def run(name, command)
    puts command
    system command
	raise "#{name} failed" if $? != 0
end

class JsTestDriver
	require "selenium-webdriver"
	
    COMMAND = "java -jar #{JSTESTDRIVER_JAR}"

    def self.run_tests(conf)
		result = attempt_tests(conf)
		if (result =~ /No browsers available/) then
			capture_browser
			result = attempt_tests(conf)
		end
		raise "Javascript unit tests failed" if $? != 0
	end

    def self.capture_browser
        puts "Launching JsTestDriver browser"
        url = "http://localhost:#{JSTESTDRIVER_PORT}/capture?strict"
        driver = Selenium::WebDriver.for :firefox
        driver.navigate.to url
    end

    def self.launch
        pid = run_in_background("#{COMMAND} --port #{JSTESTDRIVER_PORT}")
        File.open(JSTESTDRIVER_PID_FILE, 'w') do |file|
            puts "echo '#{pid}' > #{JSTESTDRIVER_PID_FILE}"
            file.write(pid)
        end
        wait_for_start
#        capture_browser
    end

    def self.terminate
        pid = IO.read(JSTESTDRIVER_PID_FILE);
        puts "Terminating process #{pid}"
        Process.kill('TERM', Integer(pid))
        rm JSTESTDRIVER_PID_FILE
    end

    def self.reset
        run "JsTestDriver", "#{COMMAND} --config #{BUILD_DIR}/JsTestDriver.conf --basePath . --reset 2>&1"
    end

    def self.is_running?
        is_port_open?("localhost", JSTESTDRIVER_PORT)
    end

private

    def self.attempt_tests(conf)
        command = "#{COMMAND} --config #{conf} --basePath . --tests all 2>&1"
        result = ""
        puts command
        IO.popen(command) do |pipe|
            pipe.sync = true
            while c = pipe.getc
                c = c.chr
                print c
                result += c
            end
        end
        return result
    end

    def self.wait_for_start
        begin
            puts "Waiting for JsTestDriver server to start"
            Timeout::timeout(JSTESTDRIVER_SERVER_TIMEOUT_IN_SEC) do
                until is_running? do
                    sleep 0.2
                end
            end
        rescue Timeout::Error
            puts "JsTestDriver server timed out"
            terminate
            raise "JsTestDriver did not start within #{JSTESTDRIVER_SERVER_TIMEOUT_IN_SEC} seconds"
        end
    end

    def self.run_in_background(command)
        puts "#{command} &"
        pipe = IO.popen(command)
        puts "Process ID: #{pipe.pid}"
        return pipe.pid
    end

    # This function courtesy of 'joast'
    # http://stackoverflow.com/questions/517219/ruby-see-if-a-port-is-open
    def self.is_port_open?(ip, port)
      begin
        Timeout::timeout(1) do
          begin
            s = TCPSocket.new(ip, port)
            s.close
            return true
          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
            return false
          end
        end
      rescue Timeout::Error
      end

      return false
    end

end