hen 0.2.7 → 0.3.2

data/lib/hen/version.rb

@@ -3,8 +3,8 @@ class Hen
   module Version
 
     MAJOR = 0
-    MINOR = 2
-    TINY  = 7
+    MINOR = 3
+    TINY  = 2
 
     class << self
 

data/lib/hens/gem.rake

@@ -1,38 +1,58 @@
 Hen :gem => :rdoc do
   # Dependencies:
-  # * rdoc -- Uses RDOC_OPTIONS and 'publish_docs' task
+  # * rdoc -- Uses RDOC_OPTIONS and 'doc:publish' task
 
   require 'rake/gempackagetask'
 
-  gem_options = config[:gem]
-  rf_config   = config[:rubyforge]
+  gem_options = config[:gem].merge(
+    :files => FileList[
+      'lib/**/*.rb',
+      'bin/*'
+    ].to_a,
+    :default_extra_files => FileList[
+      '[A-Z]*',
+      'example/**/*',
+      'ext/**/*',
+      'spec/**/*', '.rspec',
+      'test/**/*', '.autotest'
+    ].to_a,
+    :extensions => FileList[
+      'ext/**/extconf.rb'
+    ].to_a,
+    :require_path => 'lib'
+  )
+
+  rf_config = config[:rubyforge]
 
   if Object.const_defined?(:RDOC_OPTIONS)
+    rdoc_files = RDOC_OPTIONS[:rdoc_files]
+    gem_options[:has_rdoc] = !rdoc_files.empty?
+
     gem_options[:rdoc_options] ||= RDOC_OPTIONS[:options]
-    rdoc_files                   = RDOC_OPTIONS[:rdoc_files]
   end
 
   gem_spec = Gem::Specification.new { |spec|
 
     ### name
 
-    gem_options[:name] ||= rf_config[:package]
+    gem_name = gem_options[:name] ||= rf_config[:package]
 
-    abort 'Gem name missing' unless gem_options[:name]
+    abort 'Gem name missing' unless gem_name
 
     ### version
 
     abort 'Gem version missing' unless gem_options[:version]
 
-    if gem_options.delete(:append_svnversion) && svnversion = `svnversion`[/\d+/]
-      gem_options[:version] << '.' << svnversion
-    end
+    svn { |svn|
+      gem_options[:version] << '.' << svn.version
+    } if gem_options.delete(:append_svnversion)
 
     ### author(s)
 
-    if author = gem_options.delete(:author)
-      gem_options[:authors] ||= [author]
-    end
+    authors = gem_options[:authors] ||= []
+    authors.concat(Array(gem_options.delete(:author))).uniq!
+
+    warn 'Gem author(s) missing' if authors.empty?
 
     ### description
 
@@ -43,28 +63,35 @@ Hen :gem => :rdoc do
     gem_options[:rubyforge_project] ||= rf_config[:project]
 
     if rf_project = gem_options[:rubyforge_project] and !rf_project.empty?
-      rdoc_dir = rf_config[:rdoc_dir] == :package ?
-        rf_config[:package] || gem_options[:name] : RDOC_OPTIONS[:rdoc_dir]
-
-      gem_options[:homepage] ||= "#{rf_project}.rubyforge.org/#{rdoc_dir}"
+      rf_rdoc_dir = RDOC_OPTIONS[:rf_rdoc_dir] if Object.const_defined?(:RDOC_OPTIONS)
+      gem_options[:homepage] ||= "#{rf_project}.rubyforge.org/#{rf_rdoc_dir}"
     end
 
-    if gem_options[:homepage] && gem_options[:homepage] !~ %r{://}
-      gem_options[:homepage] = 'http://' << gem_options[:homepage]
+    if homepage = gem_options[:homepage]
+      homepage = "github.com/#{homepage}/#{gem_name}" if homepage.is_a?(Symbol)
+      homepage.insert(0, 'http://') unless homepage.empty? || homepage =~ %r{://}
     end
 
-    ### extra_rdoc_files, files, executables, bindir
+    ### extra_rdoc_files, files, extensions, executables, bindir
 
     gem_options[:files]            ||= []
+    gem_options[:extensions]       ||= []
     gem_options[:extra_rdoc_files] ||= rdoc_files - gem_options[:files] if rdoc_files
-    gem_options[:files]             += gem_options.delete(:extra_files) || []
-
-    gem_options[:executables] ||= gem_options[:files].grep(/\Abin\//)
 
-    [:extra_rdoc_files, :files, :executables].each { |files|
-      gem_options[files].delete_if { |file| !File.exists?(file) }
+    [:extra_files, :default_extra_files].each { |files|
+      gem_options[:files].concat(gem_options.delete(files) || [])
     }
 
+    if exclude_files = gem_options.delete(:exclude_files)
+      gem_options[:files] -= exclude_files
+    end
+
+    gem_options[:executables] ||= gem_options[:files].grep(%r{\Abin/})
+
+    mangle_files!(*gem_options.values_at(
+      :extra_rdoc_files, :files, :executables, :extensions
+    ))
+
     unless gem_options[:executables].empty?
       gem_options[:bindir] ||= File.dirname(gem_options[:executables].first)
       gem_options[:executables].map! { |executable| File.basename(executable) }
@@ -76,20 +103,22 @@ Hen :gem => :rdoc do
       spec.add_dependency(*dependency)
     }
 
+    (gem_options.delete(:development_dependencies) || []).each { |dependency|
+      spec.add_development_dependency(*dependency)
+    }
+
     ### => set options!
 
-    gem_options.each { |option, value|
-      spec.send("#{option}=", value)
-    }
+    gem_options.each { |option, value| spec.send("#{option}=", value) }
   }
 
   desc 'Display the gem specification'
-  task :gemspec do
+  task 'gem:spec' do
     puts gem_spec.to_ruby
   end
 
   desc "Update (or create) the project's gemspec file"
-  task 'gemspec:update' do
+  task 'gem:spec:update' do
     file = "#{gem_spec.name}.gemspec"
     action = File.exists?(file) ? 'Updated' : 'Created'
 
@@ -98,7 +127,7 @@ Hen :gem => :rdoc do
     puts "#{action} #{file}"
   end
 
-  pkg_task = Rake::GemPackageTask.new(gem_spec) do |pkg|
+  pkg_task = Rake::GemPackageTask.new(gem_spec) { |pkg|
     pkg.need_tar_gz = true
     pkg.need_zip    = true
 
@@ -106,13 +135,33 @@ Hen :gem => :rdoc do
       require 'nuggets/file/which'
       pkg.zip_command = File.which_command(ZIP_COMMANDS) || ZIP_COMMANDS.first
     end
+  }
+
+  release_desc = "Release #{pkg_task.name} version #{pkg_task.version}"
+
+  rubygems do |rg_pool|
+
+    gem_path = File.join(pkg_task.package_dir, pkg_task.gem_file)
+
+    desc "Create the gem and install it"
+    task 'gem:install' => :gem do
+      rg_pool.call.install(gem_path)
+    end
+
+    desc 'Create the gem and upload it to RubyGems.org'
+    task 'gem:push' => :gem do
+      rg_pool.call.push(gem_path)
+    end
+
+    desc release_desc; release_desc = nil
+    task :release => 'gem:push'
+
   end
 
-begin
   rubyforge do |rf_config, rf_pool|
 
-    desc 'Package and upload the release to Rubyforge'
-    task :release => [:package, :publish_docs] do
+    desc 'Package and upload the release to RubyForge'
+    task 'release:rubyforge' => [:package, 'doc:publish'] do
       files = Dir[File.join(pkg_task.package_dir, "#{pkg_task.package_name}.*")]
       abort 'Nothing to release!' if files.empty?
 
@@ -130,19 +179,9 @@ begin
       rf.add_release(rf_config[:project], pkg_task.name, version, *files)
     end
 
-  end
-rescue RuntimeError => err
-  raise unless err.to_s == 'Skipping Rubyforge tasks'
-
-  gemcutter do |gc_pool|
-
-    desc 'Create the gem and upload it to Gemcutter'
-    task :release => [:gem] do
-      gc = gc_pool.call
-      gc.push(File.join(pkg_task.package_dir, pkg_task.gem_file))
-    end
+    desc release_desc
+    task :release => 'release:rubyforge'
 
   end
-end
 
 end

data/lib/hens/rdoc.rake

@@ -1,8 +1,25 @@
 Hen :rdoc do
 
-  require 'rake/rdoctask'
-
-  rdoc_options = config[:rdoc]
+  rdoc_options = config[:rdoc].merge(
+    :rdoc_dir       => 'doc',
+    :rdoc_files     => %w[README COPYING ChangeLog lib/**/*.rb],
+    :charset        => 'UTF-8',
+    :inline_source  => true,
+    :line_numbers   => true,
+    :all            => true
+  )
+
+  rdoc_klass = begin
+    raise LoadError if rdoc_options.delete(:legacy)
+
+    require 'rdoc/task'
+
+    rdoc_options.delete(:inline_source)  # deprecated
+    RDoc::Task
+  rescue LoadError
+    require 'rake/rdoctask'
+    Rake::RDocTask
+  end
 
   rdoc_options[:title] ||= begin
     title = 'Application documentation'
@@ -22,14 +39,21 @@ Hen :rdoc do
 
   rdoc_dir = rdoc_options.delete(:rdoc_dir)
 
-  ### rdoc_files
+  ### rdoc_files, main
 
-  rdoc_files = FileList[rdoc_options.delete(:rdoc_files)].
-    sort.uniq.select { |file| File.exists?(file) }
+  rdoc_files = FileList[rdoc_options.delete(:rdoc_files)].to_a
+  rdoc_files_local = rdoc_files.dup
 
-  ### rdoc_options
+  if mangle_files!(rdoc_files)
+    mangle_files!(rdoc_files_local, :managed => false)
+  else
+    rdoc_files_local = nil
+  end
 
   rdoc_options.delete(:main) unless rdoc_files.include?(rdoc_options[:main])
+  rdoc_options[:main] ||= rdoc_files.first
+
+  ### rdoc_options
 
   rdoc_options = rdoc_options.map { |option, value|
     option = '--' << option.to_s.tr('_', '-')
@@ -44,8 +68,7 @@ Hen :rdoc do
   }
 
   unless rdoc_files.empty?
-    # Rake::RDocTask -> RDoc::Task (require 'rdoc/task')
-    rdoc_task = Rake::RDocTask.new(:doc) { |rdoc|
+    rdoc_task = rdoc_klass.new(:doc) { |rdoc|
       rdoc.rdoc_dir   = rdoc_dir
       rdoc.rdoc_files = rdoc_files
       rdoc.options    = rdoc_options
@@ -56,39 +79,23 @@ Hen :rdoc do
     end
   end
 
-begin
-  rubyforge do |rf_config|
-
-    desc 'Publish RDoc to Rubyforge'
-    task :publish_docs => :doc do
-      rf_project = rf_config[:project]
-      abort 'Rubyforge project name missing' unless rf_project
-
-      rf_user = rf_config[:username]
-      abort 'Rubyforge user name missing' unless rf_user
-
-      rf_host = "#{rf_user}@rubyforge.org"
-
-      local_dir  = rdoc_task.rdoc_dir
-      remote_dir = "/var/www/gforge-projects/#{rf_project}"
-
-      if rdoc_dir = rf_config[:rdoc_dir]
-        if rf_package = rf_config[:package]
-          rdoc_dir = rf_package if rdoc_dir == :package
-        end
-
-        remote_dir = File.join(remote_dir, rdoc_dir)
-      end
+  unless rdoc_files_local.nil? || rdoc_files_local.empty?
+    rdoc_klass.new('doc:local') { |rdoc|
+      rdoc.rdoc_dir   = rdoc_dir + '.local'
+      rdoc.rdoc_files = rdoc_files_local
+      rdoc.options    = rdoc_options
 
-      execute(
-        "rsync -av --delete #{local_dir}/ #{rf_host}:#{remote_dir}/",
-        "scp -r #{local_dir}/ #{rf_host}:#{remote_dir}/"
-      )
-    end
+      extend_object(rdoc) {
+        def local_description(desc); "#{desc} (including unmanaged files)"; end
 
+        def clobber_task_description; local_description(super); end
+        def rdoc_task_description;    local_description(super); end
+        def rerdoc_task_description;  local_description(super); end
+      }
+    }
   end
-rescue RuntimeError => err
-  raise unless err.to_s == 'Skipping Rubyforge tasks'
+
+  publish_desc = "Publish RDoc documentation"
 
   git do |git|
 
@@ -105,7 +112,7 @@ rescue RuntimeError => err
     if pages_url  # inside git repo and found gh-pages branch
 
       desc "Publish RDoc to GitHub pages"
-      task :publish_docs => :doc do
+      task 'doc:publish:github' => :doc do
         rm_rf clone_dir
 
         git.easy_clone pages_url, clone_dir, git_remote
@@ -120,10 +127,13 @@ rescue RuntimeError => err
         }
       end
 
+      desc publish_desc; publish_desc = nil
+      task 'doc:publish' => 'doc:publish:github'
+
     elsif clone_url  # still git repo, but no gh-pages branch
 
       desc "Create #{git_branch} branch on #{git_remote}"
-      task :make_ghpages do
+      task 'doc:make_ghpages' do
         git.easy_clone clone_url, clone_dir, git_remote
 
         Dir.chdir(clone_dir) {
@@ -146,6 +156,37 @@ rescue RuntimeError => err
     end
 
   end
-end
+
+  rubyforge do |rf_config|
+
+    rf_project = rf_config[:project]
+
+    rf_rdoc_dir, rf_package = rf_config.values_at(:rdoc_dir, :package)
+    rf_rdoc_dir ||= :package if rf_package && rf_package != rf_project
+    rf_rdoc_dir = rf_package if rf_package && rf_rdoc_dir == :package
+
+    RDOC_OPTIONS[:rf_rdoc_dir] = rf_rdoc_dir
+
+    desc 'Publish RDoc to RubyForge'
+    task 'doc:publish:rubyforge' => :doc do
+      rf_user = rf_config[:username]
+      abort 'RubyForge user name missing' unless rf_user
+
+      rf_host = "#{rf_user}@rubyforge.org"
+
+      local_dir  = rdoc_task.rdoc_dir
+      remote_dir = "/var/www/gforge-projects/#{rf_project}"
+      remote_dir = File.join(remote_dir, rf_rdoc_dir) if rf_rdoc_dir
+
+      execute(
+        "rsync -av --delete #{local_dir}/ #{rf_host}:#{remote_dir}/",
+        "scp -r #{local_dir}/ #{rf_host}:#{remote_dir}/"
+      )
+    end
+
+    desc publish_desc
+    task 'doc:publish' => 'doc:publish:rubyforge'
+
+  end
 
 end

data/lib/hens/spec.rake

@@ -1,17 +1,30 @@
 Hen :spec do
 
-  begin
+  spec_options = config[:spec].merge(
+    :pattern => 'spec/**/*_spec.rb',
+    :helper  => 'spec/spec_helper.rb',
+    :options => 'spec/spec.opts'
+  )
+
+  spec_klass = begin
+    raise LoadError if spec_options.delete(:legacy)
+
     require 'rspec/core/rake_task'
+    RSpec::Core::RakeTask
   rescue LoadError
     require 'spec/rake/spectask'
+    Spec::Rake::SpecTask
   end
 
-  spec_options = config[:spec]
+  spec_files = spec_options.delete(:files) ||
+      FileList[spec_options.delete(:pattern)].to_a
 
-  spec_files = spec_options.delete(:files) || FileList[spec_options.delete(:pattern)]
+  mangle_files!(spec_files, :managed => false)
 
-  if spec_files && !spec_files.empty?
-    if spec_helper = spec_options.delete(:helper) and File.readable?(spec_helper)
+  unless spec_files.empty?
+    spec_helper = spec_options.delete(:helper)
+
+    if spec_helper && File.readable?(spec_helper)
       spec_files.delete(spec_helper)
       spec_files.unshift(spec_helper)
     end
@@ -27,30 +40,28 @@ Hen :spec do
       File.readlines(opts_file).each { |l| spec_opts << l.chomp }
     end
 
-    klass, spec_task = if defined?(RSpec::Core::RakeTask)
-      [RSpec::Core::RakeTask, lambda { |t|
-        t.pattern    = spec_files
-        t.rspec_opts = spec_opts
-      }]
-    else
-      [Spec::Rake::SpecTask, lambda { |t|
+    spec_block = lambda { |t|
+      if t.respond_to?(:spec_files=)
         t.spec_files = spec_files
         t.spec_opts  = spec_opts
-      }]
-    end
+      else
+        t.pattern    = spec_files
+        t.rspec_opts = spec_opts
+      end
+    }
 
-    klass.new(&spec_task)
+    spec_klass.new(&spec_block)
 
     rcov_opts = ['--exclude', spec_files.join(',')]
-    rcov_file = File.join(spec_files.first[/[^\/.]+/], 'rcov.opts')
+    rcov_file = File.join(spec_files.first[%r{[^/.]+}], 'rcov.opts')
 
     if rcov_file && File.readable?(rcov_file)
-      File.readlines(rcov_file).each { |l| rcov_opts << l.chomp }
+      File.readlines(rcov_file).each { |line| rcov_opts << line.chomp }
     end
 
     #desc "Run specs with RCov"
     klass.new('spec:rcov') do |t|
-      spec_task[t]
+      spec_block[t]
 
       t.rcov = true
       t.rcov_opts = rcov_opts