require 'rake'
require 'rake/clean'
require 'rake/packagetask'
require 'rake/gempackagetask'

#require 'rubygems'

#require 'rbconfig'
#require 'find'
#require 'ftools'
#require 'fileutils'
#include Config

PROJECT = "rockit"

VERSION_FILE = "VERSION"
MANIFEST_FILE = "Manifest"
README_FILE = "README"
TODO_FILE = "TODO"
RAKE_FILE = "rakefile"
CHANGELOG = "Changelog"

CLEAN.include("rockit_paper.pdf")

task :default => [:ptest, :patest]


#############################################################################
# Version related
#############################################################################

# Read the version from the version file
def Version()
  File.open(VERSION_FILE) {|fh| fh.read.strip}
end

# Update the version num on disc
def update_version
  v = Version().split(".").map {|vp| vp.to_i}
  new_v = yield(v)
  File.open(VERSION_FILE, "w") {|fh| fh.write(new_v)}
  puts Version()
end

def inc_tiny; update_version {|v| "#{v[0]}.#{v[1]}.#{v[2]+1}\n"}; end
def inc_minor; update_version {|v| "#{v[0]}.#{v[1]+1}.0\n"}; end
def inc_major; update_version {|v| "#{v[0]+1}.0.0\n"}; end

task :version do
  puts Version()
end
task :inc_tiny  do
  inc_tiny()
end
task :inc_minor do 
  inc_minor()
end
task :inc_major do
  inc_major()
end

#############################################################################
# Test related
#############################################################################

PackratTestFiles = FileList["tests/unit/packrat/test*.rb"]
PackratAcceptanceTestFiles = FileList["tests/acceptance/packrat/**/atest*.rb"]

task :setup_for_test do
  $: << "lib"
end

def load_files(list)
  list.each {|f| puts "Loading #{f}"; require f}
end

task :ptest => [:setup_for_test] do
  load_files PackratTestFiles
end

task :patest => [:setup_for_test] do
  load_files PackratAcceptanceTestFiles
end

task :unit_tests => [:setup_for_test] do
  load_files FileList["tests/unit/**/test*.rb"]
end

task :acceptance_tests do
  load_files FileList["tests/acceptance/**/test*.rb"]
end

task :utest => :unit_tests
task :ut => :unit_tests
task :atest => :acceptance_tests
task :at => :acceptance_tests

#############################################################################
# Gem and package related
#############################################################################

BaseFileToIncludeGlobs = [
    "README", "TODO", "BUGS", "LICENSE", "VERSION",
    "rakefile", "Manifest",
    "lib/packrat/**/*",
    "doc/rockit_paper.pdf",
    #"lib/rockit/prettyprint/**/*",
    #"lib/rockit/tree/**/*",
    #"lib/util/**/*",
]

TestFilesToIncludeGlobs = [
    "tests/acceptance/packrat/**/*", 
    "tests/unit/packrat/**/*",
]

PkgFileGlobs = BaseFileToIncludeGlobs + TestFilesToIncludeGlobs

GemSpec = Gem::Specification.new do |s|
  s.name = PROJECT
  s.version = Version()
  s.platform = Gem::Platform::RUBY
  s.summary = "Rockit is the Ruby Object-oriented Compiler construction toolKIT"
  s.author = "Robert Feldt"
  s.email = "Robert.Feldt@gmail.com"
  s.homepage = "http://www.pronovomundo.com/projects/ruby/rockit"

  s.description = <<EOS
Rockit is a potent parser generator and gives you AST's (Abstract Syntax Tree's) which you can pattern match and pretty-print. Rockit does not distinghuish between lexing and parsing so the generated parsers are scanner-/lexer-less. The vision is to extend Rockit with more advanced compiler-related abilities including back-ends and code generation. However, currently the focus is on parsing and AST-related tasks such as transformation.
EOS

  s.require_path = "lib"
  s.requirements << "none"

  s.has_rdoc = false
  # Dependency on rake?

  s.files = []
  PkgFileGlobs.each do |globpat|
    fs = Dir.glob(globpat).delete_if {|i| i.include?(".svn")}
    s.files += fs
  end

  s.extensions = []
end

Rake::GemPackageTask.new(GemSpec) do |pkg|
  pkg.need_zip = true
  pkg.need_tar = true
end

# Reformat the 'svn log' output to become the Changelog file. We assume
# log entries are single lines with each log event starting with an asterisk
# "*" and use those as split markers. We also insert newlines before the
# svn log event separators "-----------------------...---".
def reformat_svn_log_to_changelog(svnLogAsString)
  s = svnLogAsString.split(/, \*/).join(",\n\n* ")
  s.split(/^------/).join("\n------")
end

task :changelog do
  # We must run 'svn up' first to make sure the log is recent
  system "svn up"
  File.open("Changelog", "w") do |fh|
    fh.write reformat_svn_log_to_changelog(`svn log`)
  end
end

#############################################################################
# Doc related
#############################################################################
task :gen_paper do
  Dir.chdir("doc/rockit_paper") do
    system "rake"
    File.cp "rockit_paper.pdf", ".."
    system "rake clobber"
  end
end

#############################################################################
# Rubyforge related
#############################################################################

# Create a package (a name for a top-level "item" which can then have multiple
# releases where each release can have multiple files)
def create_package(packageName = "rockit")
  system "rubyforge create_package #{PROJECT} #{packageName}"
end

# Release a <file> with a given <release_name> in the given <package>.
def release_file(file, release_name, package = PROJECT)
  group_id = PROJECT
  system "rubyforge add_release #{group_id} #{package} #{release_name} #{file}"
end

# Delete a package (and all its files)
def delete_package(packageName)
  system "rubyforge create_package rockit #{ARGV.last}"
end

# We use a temporary package name for now, should be PROJECT later...
#PACKAGE_NAME = "1801"  # if of the test package in rockit group
PACKAGE_NAME = "368"  # Name of rockit package

task :pack => [:gen_paper, :package]

desc "Create package and release to rubyforge"
task :rubyforge_release => [:pack] do
  puts "Logging in to rubyforge"
  system "rubyforge login"

  release_name = "#{PROJECT}-#{Version()}"
  files_to_release = FileList["pkg/#{release_name}.gem"]
  files_to_release.each do |file|
    puts "Releasing #{file} to Rubyforge"
    release_file(file, release_name, PACKAGE_NAME)
  end
end