# -*- ruby -*-

begin require 'rubygems'; rescue LoadError; end
require 'rake'
require 'rake/contrib/sshpublisher'
require 'rake/gempackagetask'
require 'rake/rdoctask'
require 'rake/testtask'
require 'rbconfig'

class Hoe
  VERSION = '1.0.0'

  rubyprefix = Config::CONFIG['prefix']
  sitelibdir = Config::CONFIG['sitelibdir']

  PREFIX = ENV['PREFIX'] || rubyprefix
  RUBYLIB = if PREFIX == rubyprefix then
              sitelibdir
            else
              File.join(PREFIX, sitelibdir[rubyprefix.size..-1])
            end
  RUBY_DEBUG = ENV['RUBY_DEBUG']
  RUBY_FLAGS = ENV['RUBY_FLAGS'] ||
    "-w -I#{%w(lib bin ../../RubyInline/dev).join(File::PATH_SEPARATOR)}" +
    (RUBY_DEBUG ? " #{RUBY_DEBUG}" : '')
  FILTER = ENV['FILTER'] # for tests (eg FILTER="-n test_blah")

  attr_accessor :author, :bin_files, :clean_globs, :email, :lib_files, :name, :rubyforge_name, :spec, :summary, :test_files, :url, :version

  def initialize(name, version)
    self.name = name
    self.version = version

    # Defaults
    self.rubyforge_name = name.downcase
    self.url = "http://www.zenspider.com/ZSS/Products/#{name}/"
    self.author = "Ryan Davis"
    self.email = "ryand-ruby@zenspider.com"
    self.clean_globs = %w(diff diff.txt demo.rb *.gem **/*~)
    
    yield self if block_given?

    define_tasks
  end

  def define_tasks
    desc 'Run the default tasks'
    task :default => :test

    desc 'Run the test suite. Use FILTER to add to the command line.'
    task :test do
      run_tests
    end

    desc 'Run the test suite using multiruby'
    task :multi do
      run_tests :multi
    end

    ############################################################
    # Packaging and Installing
    
    self.spec = Gem::Specification.new do |s|
      s.name = name
      s.version = version
      s.summary = summary
      s.author = author
      s.email = email
      s.homepage = url
      s.rubyforge_project = rubyforge_name

      paragraphs = File.read("README.txt").split(/\n\n+/)
      s.description = paragraphs[2]

      s.add_dependency('RubyInline', '>= 3.2.0')
      s.files = File.read("Manifest.txt").split
      s.executables = s.files.grep(/bin/) { |f| File.basename(f) }

      s.bindir = "bin"
      s.require_paths = ['lib', 'test']
      s.has_rdoc = true
      s.test_suite_file = "test/test_all.rb" if test ?f, "test/test_all.rb"

      if $DEBUG then
        puts "Gem Info:"
        puts
        puts "Summary     = #{s.summary}"
        puts
        puts "Description = #{s.description}"
        puts
        puts "Executables = #{s.executables.join(", ")}"
        puts
        puts "Files       = #{s.files.join(", ")}"
        puts
      end
    end

    self.lib_files = spec.files.grep(/^lib/)
    self.bin_files = spec.files.grep(/^bin/)
    self.test_files = %w(test/test_sexp_processor.rb) # for ruby_to_c's tests.

    Rake::GemPackageTask.new spec do |pkg|
      pkg.need_tar = true
    end

    desc 'Install the package. Uses PREFIX and RUBYLIB'
    task :install do
      [
       [lib_files + test_files, RUBYLIB, 0444],
       [bin_files, file.join(PREFIX, 'bin'), 0555]
      ].each do |files, dest, mode|
        FileUtils.mkdir_p dest unless test ?d, dest
        files.each do |file|
          install file, dest, :mode => mode
        end
      end
    end

    desc 'Uninstall the package.'
    task :uninstall do
      Dir.chdir RUBYLIB do
        rm_f((lib_files + test_files).map { |f| File.basename f })
      end
      Dir.chdir File.join(PREFIX, 'bin') do
        rm_f bin_files.map { |f| File.basename f }
      end
    end

    desc 'Deploy the package to rubyforge.'
    task :deploy => [:clean, :package] do |t|
      v = ENV["VERSION"] or abort "Must supply VERSION=x.y.z"
      abort "Versions don't match #{v} vs #{version}" if v != version
      puts "Releasing #{name} v. #{version}"
      require 'rubyforge'
      pkg = "pkg/#{name}-#{version}"

      if $DEBUG then
        puts "release_id = rf.add_release #{rubyforge_name.inspect}, #{name.inspect}, #{version.inspect}, \"#{pkg}.gem\""
        puts "rf.add_file #{rubyforge_name.inspect}, #{name.inspect}, release_id, \"#{pkg}.tgz\""
      else
        rf = RubyForge.new
        rf.login
        release_id = rf.add_release rubyforge_name, name, version, "#{pkg}.gem"
        rf.add_file rubyforge_name, name, release_id, "#{pkg}.tgz"
      end
    end

    ############################################################
    # Doco

    Rake::RDocTask.new(:docs) do |rd|
      rd.main = "README.txt"
      rd.options << '-d' if `which dot` =~ /\/dot/ and RUBY_PLATFORM !~ /win32/
      rd.rdoc_dir = 'doc'
      rd.rdoc_files.push(*spec.files.grep(/^(lib|bin|READ|Hist)/))
    end

    desc 'Upload RDoc to RubyForge'
    task :upload => [:clean, :docs] do
      config = YAML.load(File.read(File.expand_path("~/.rubyforge/config.yml")))
      user = "#{config["username"]}rubyforge.org"
      project = "/var/www/gforge-projects/#{rubyforge_name}"
      local_dir = 'doc'
      pub = Rake::SshDirPublisher.new user, project, local_dir
      pub.upload
    end

    ############################################################
    # Misc/Maintenance:

    desc 'Run ZenTest against the package'
    task :audit do
      libs = %w(lib test).join(File::PATH_SEPARATOR)
      sh "zentest -I=#{libs} #{spec.files.grep(/^(lib|test)/).join(' ')}"
    end

    desc 'Clean up all the extras'
    task :clean => [ :clobber_docs, :clobber_package ] do
      clean_globs.each do |pattern|
        files = Dir[pattern]
        rm_rf files unless files.empty?
      end
    end
  end # end define

  def run_tests(multi=false)
    msg = multi ? :sh : :ruby
    cmd = if test ?f, 'test/test_all.rb' then
            "#{RUBY_FLAGS} test/test_all.rb #{FILTER}"
          else
            tests = (Dir.glob("test/**/test_*.rb") + ['test/unit']).map { |f|
        "require \"#{f}\""
      }
            "#{RUBY_FLAGS} -e '#{tests.join("; ")}' #{FILTER}"
          end
    cmd = "multiruby #{cmd}" if multi
    send msg, cmd
  end
end