reap 0.5.0 → 0.6.1

data/lib/reap/package-task.rb

@@ -0,0 +1,165 @@
+require 'reap/task'
+
+begin
+  require 'rubygems'
+rescue
+  # no rubygems
+end
+
+#
+# Package Task
+#
+# This task allows on to create standard .zip, .tgz, or .tbz
+# packages, plus create gem distributions.
+#
+class Reap::PackageTask < Reap::Task
+
+  section_name :package
+
+  attr_accessor :dir, :name, :version, :package_name,
+                :author, :email, :summary, :project, :homepage,
+                :include, :exclude, :zip, :gzip, :bzip2, :gem,
+                :gem_platform, :gem_autorequire, :gem_dependencies,
+                :requirements, :executables
+
+  def init
+    @dir          = section['dir']      || 'pkg'
+
+    @name         = section['name']     || master['name']
+    @version      = section['version']  || master['version'] || '0.0.1'
+    @package_name = @name + '-' + @version
+
+    @author       = section['author']   || master['author']
+    @email        = section['email']    || master['email']
+    @summary      = section['summary']  || master['summary']
+    @project      = section['project']  || master['rubyforge']['project']
+    @homepage     = section['homepage'] || master['homepage'] || master['rubyforge']['homepage']
+
+    @include      = section['include']  || DEFAULT_INCLUDE
+    @exclude      = MUST_EXCLUDE + section['exclude']
+
+    @zip = section['zip'].nil? ? true : section['zip']
+    @gzip = section['gzip'].nil? ? true : section['zip']
+    @bzip2 = section['bzip2'].nil? ? true : section['zip']
+    @gem = section['gem'].nil? ? true : section['gem']
+
+    # gem specific
+    if defined?(Gem)
+      if section['platform']
+        @gem_platform = ::Gem.const_get(section['platform'])
+      else
+        @gem_platform = ::Gem::Platform::RUBY
+      end
+      @gem_autorequire  = section['autorequire']
+      @gem_dependencies = section['dependencies'] || []
+      @requirements = section['requirements'] || []
+      @executables = section['executables'] || []
+    end
+  end
+
+  def define
+    desc "build .tgz, .tbz (.bzip2), .zip and/or .gem packages *"
+    task :package do
+      run_package
+    end
+  end
+
+  private
+
+  def run_package
+    # create package image
+    if FileTest.directory?(@dir)
+      print "Directory '#{@dir}' already exists. Clobber? [y/N] "
+      until inp = $stdin.gets[0,1] ; sleep 1 ; end
+      if (inp || 'y').downcase == 'y'
+        puts "Removing old directory '#{File.expand_path(@dir)}'..."
+        trash_dir = ".trash/#{File.basename(@dir)}"
+        FileUtils.mkdir_p(".trash") unless FileTest.directory?(".trash")
+        FileUtils.rm_r(trash_dir) if FileTest.exists?(trash_dir)
+        FileUtils.mv(@dir, trash_dir)
+      else
+        puts "Reap package task canceled."
+        exit 0
+      end
+    end
+    package_dir_path = "#{@dir}/#{@package_name}"
+    package_files = FileList.new
+    package_files.include(*@include)
+    package_files.exclude(*@exclude) if @exclude and not @exclude.empty?
+    FileUtils.mkdir_p @dir #rescue nil
+    package_files.each do |fn|
+      f = File.join(package_dir_path, fn)
+      fdir = File.dirname(f)
+      FileUtils.mkdir_p(fdir) if not File.exist?(fdir)
+      if File.directory?(fn)
+        FileUtils.mkdir_p(f)
+      else
+        FileUtils.rm_f(f)
+        FileUtils.safe_ln(fn, f)
+      end
+    end
+
+    # create standard package files
+    FileUtils.chdir(@dir) do
+      # tar bzip2 for unix
+      if @bzip2
+        puts "\nReap is shelling out work to tar and bzip2..."
+        sh %{tar --bzip2 -cvf #{@package_name}.tbz #{@package_name}}
+      end
+      # tar gzip for unix
+      if @gzip
+        puts "\nReap is shelling out work to tar and gzip..."
+        sh %{tar --gzip -cvf #{@package_name}.tgz #{@package_name}}
+      end
+      # zip for windows
+      if @zip
+        puts "\nReap is shelling out work to zip..."
+        sh %{zip -r #{@package_name}.zip #{@package_name}}
+      end
+      puts
+    end
+
+    # create gem package
+    run_gem if defined?(Gem) and @gem
+
+    return true
+  end
+
+  def run_gem
+    spec = Gem::Specification.new { |s|
+      s.name = @name
+      s.version = @version
+      @gem_dependencies.each{ |d,v|
+        if v
+          s.add_dependency(d, v)
+        else
+          s.add_dependency(d)
+        end
+      }
+      s.platform = @gem_platform
+      s.summary = @summary
+      s.requirements = @requirements
+
+      # s.files = Dir.glob("lib/**/*").delete_if {|item| item.include?("CVS")}
+      # s.files.concat Dir.glob("bin/**/*").delete_if {|item| item.include?("CVS")}
+      package_files = FileList.new
+      package_files.include(*@include)
+      package_files.exclude(*@exclude) if @exclude and not @exclude.empty?
+      s.files = package_files.to_a
+
+      s.require_path = 'lib'
+      s.autorequire = @gem_autorequire if @gem_autorequire
+      s.author = @author
+      s.email = @email
+      s.rubyforge_project = @project
+      s.homepage = @homepage
+      s.executables = @executables
+      s.bindir = "bin"
+    }
+    puts "Reap is shelling out work to the Gem Package Manager..."
+    Gem.manage_gems
+    Gem::Builder.new(spec).build
+    sh %{mv ./*.gem #{@dir}/}
+  end
+
+end

data/lib/reap/publish-task.rb

@@ -0,0 +1,53 @@
+require 'reap/task'
+
+#
+# Publish Task
+#
+class Reap::PublishTask < Reap::Task
+
+  section_name :publish
+
+  attr_accessor :host, :type, :dir, :project, :username
+
+  def init
+    @host     = (section['host'] || 'rubyforge').to_s.downcase
+    @type     = (section['type'] || 'www').to_s.downcase
+    #@command  = section['command']
+    @dir      = section['dir']
+    #@exclude = section['exclude']
+    @project  = section['project'] || master['rubyforge']['project'] || master['name']
+    @username = section['username'] || master['rubyforge']['username']
+  end
+
+  def define
+    desc "publish documents to the web *"
+    task :publish do
+      run_publish
+    end
+  end
+
+  def run_publish
+    cmd = ''; skip = false
+
+    case @host
+    when 'rubyforge'
+      case @type
+      when 'www', 'web'
+        cmd = %{scp -r #{@dir}/* #{@username}@rubyforge.org:/var/www/gforge-projects/#{@project}/}
+      else
+        puts %{Unrecognized publishing type '#{@type}' for host '#{@host}'. Skipped.}
+        skip = true
+      end
+    else
+      puts %{Unrecognized publishing host '#{@host}'. Skipped.}
+      skip = true
+    end
+
+    unless skip
+      puts "Reap is shelling out publishing work..."
+      puts cmd
+      sh(cmd) unless $PRETEND
+    end
+  end
+
+end

data/lib/reap/rdoc-task.rb

@@ -0,0 +1,70 @@
+require 'reap/task'
+
+#
+# RDoc Task
+#
+class Reap::RDocTask < Reap::Task
+
+  section_name :rdoc
+
+  attr_accessor :dir, :main, :title, :template, :include, :exclude, :options
+
+  def init
+    @dir      = section["dir"]      || 'doc'
+    @main     = section["main"]     || 'README'
+    @title    = section["title"]    || master["title"]
+    @template = section["template"] || 'html'
+    @include  = section["include"]  || ['lib/**/*']
+    @exclude  = section["exclude"]  || []
+    @options  = section["options"]  || []
+  end
+
+  def define
+    desc "generate RDocs (in #{@dir}) *"
+    task :rdoc do
+      run_rdoc
+    end
+  end
+
+  private
+
+  def run_rdoc
+    if !File.exists?(@main) or File.directory?(@main)
+      warn "Specified RDoc Main file #{@main} not found. Ignored."
+      @main = nil
+    end
+    rdoc_dir = File.expand_path(@dir)
+    if FileTest.directory?(@dir)
+      print "Directory '#{@dir}' already exists. Clobber? [y/N] "
+      until inp = $stdin.gets[0,1] ; sleep 1 ; end ; puts
+      if (inp || 'y').downcase == 'y'
+        puts "Removing old directory '#{rdoc_dir}'..."
+        #FileUtils.mkdir_p(".trash") unless FileTest.directory?(".trash")
+        #trashdir = ".trash/#{File.basename(@dir)}"
+        #FileUtils.rm_r(trashdir) if FileTest.exists?(trashdir)
+        #FileUtils.mv(@dir, trashdir)
+        FileUtils.rm_r(@dir)
+      else
+        puts "Reap rdoc task canceled."
+        return nil
+      end
+    end
+    rdoc_target = "#{rdoc_dir}/index.html"
+    # rdoc files
+    rdoc_files = FileList.new
+    rdoc_files.include(*@include)
+    rdoc_files.exclude(*@exclude)
+    rdoc_files = '"' << rdoc_files.join('" "') << '"'
+    # build options string
+    build = @options.dup
+    build << "--main '#{@main}'" if @main
+    build << "--title '#{@title}'" if @title
+    build << "-T '#{@template}'" if @template
+    rdoc_opts = build.join(' ')
+    # do it!
+    puts "Reap is shelling work out to RDoc..."
+    puts %{rdoc -o #{@dir} #{rdoc_opts}}
+    sh %{rdoc -o #{rdoc_dir} #{rdoc_opts} #{rdoc_files}}
+  end
+
+end

data/lib/reap/reap-all.rb

@@ -0,0 +1,15 @@
+require 'reap/template-task'
+require 'reap/chmod-task'
+require 'reap/test-task'
+require 'reap/rdoc-task'
+require 'reap/announce-task'
+require 'reap/package-task'
+require 'reap/publish-task'
+
+Reap::TemplateTask.new
+Reap::ChmodTask.new
+Reap::TestTask.new
+Reap::RDocTask.new
+Reap::AnnounceTask.new
+Reap::PackageTask.new
+Reap::PublishTask.new

data/lib/reap/task.rb

@@ -1,106 +1,166 @@
 
 require 'rbconfig'
+require 'yaml'
+require 'fileutils'
+
+require 'rake'
+require 'rake/tasklib'
+
+#require 'mega/filelist'
+require 'nano/hash/traverse'
+
+module Reap ; end
+
+# Base class for reap tasks.
+#
+# When creating a specifc task, subclass this one and create two class-level
+# methods #task and #desc. #task will return the name of the task and
+# #desc a description of the task. Then create an instance method called
+# #setup to do any initial preping. Usually that means assigning
+# some instance vars from the Reapfile configutration. You can use
+# section[<name>] for settings from the task's particular section (as
+# determined by self.task method above) and/or use master[<name>]
+# for top-level settings. Finally write a #run method that preforms the
+# actual task.
+#
+# Here's an oh so simple example:
+#
+#   class MyTask < Task
+#     def self.task ; 'mytask' ; end
+#     def self.desc ; 'This is my first custom task.' ; end
+#
+#     def setup
+#       @message = section['message'] || master['default'] || 'None Found!'
+#     end
+#
+#     def run
+#       puts @message
+#     end
+#   end
+#
+# This corresponding settings in the Reapfile will then be:
+#
+#   default: Default text, if any.
+#
+#   mytask:
+#     message: Message text, if any.
+#
+# Reap automatically handles multiple task runs if an array is provided
+# under the task section instead of a single mapping.  For example:
+#
+#   mytask:
+#     -
+#       message: First Run.
+#     -
+#       message: Second Run.
+#
+class Reap::Task < Rake::TaskLib
+
+  RUBY = Config::CONFIG['ruby_install_name']
+
+  DEFAULT_INCLUDE = [ '[A-Z]*', 'setup.rb', 'lib/**/*', 'bin/**/*', 'data/**/*',
+                      'doc/**/*', 'rdoc/**/*', 'test/**/*', 'bench/**/*',
+                      'demo/**/*', 'samples/**/*', 'examples/**/*' ]
+
+  MUST_EXCLUDE = [ 'InstalledFiles', '**/CVS/**/*', '**/*~' ]
+
+
+  def initialize #:yield:
+    load_config
+    init
+    yield( self ) if block_given?
+    define
+  end
 
-module Reap
+  def init
+    raise "not implemented"
+  end
 
-  # Base class for all tasks.
-  #
-  # When creating a specifc task, subclass this one and create two class-level
-  # methods #task and #desc. #task will return the name of the task and
-  # #desc a description of the task. Then create an instance method called
-  # #setup to do any initial preping. Usually that means assigning
-  # some instance vars from the Reapfile configutration. You can use
-  # section[<name>] for settings from the task's particular section (as
-  # determined by self.task method above) and/or use master[<name>]
-  # for top-level settings. Finally write a #run method that preforms the
-  # actual task.
-  #
-  # Here's an oh so simple example:
-  #
-  #   class MyTask < Task
-  #     def self.task ; 'mytask' ; end
-  #     def self.desc ; 'This is my first custom task.' ; end
-  #
-  #     def setup
-  #       @message = section['message'] || master['default'] || 'None Found!'
-  #     end
-  #
-  #     def run
-  #       puts @message
-  #     end
-  #   end
-  #
-  # This corresponding settings in the Reapfile will then be:
-  #
-  #   default: Default text, if any.
-  #
-  #   mytask:
-  #     message: Message text, if any.
-  #
-  # Reap automatically handles multiple task runs if an array is provided
-  # under the task section instead of a single mapping.  For example:
-  #
-  #   mytask:
-  #     -
-  #       message: First Run.
-  #     -
-  #       message: Second Run.
-  #
-  class Task
+  def define
+    raise "not implemented"
+  end
 
-    RUBY = Config::CONFIG['ruby_install_name']
+  attr_reader :config
+
+  def load_config( config_file=nil )
+    config_file ||= 'Reapfile'
+    if File.file?( config_file )
+      # load config file
+      @config = ::YAML.load( File.open( config_file ) ).traverse{ |k,v| [k.downcase, v] }
+      # required main parameters
+      raise "TITLE is a required configuration field" unless @config['title']
+      raise "NAME is a required configuration field" unless @config['name']
+      raise "VERSION is a required configuration field" unless @config['version']
+    else
+      @config = {}
+    end
+  end
 
-    DEFAULT_INCLUDE = [ '[A-Z]*', 'setup.rb', 'lib/**/*', 'bin/**/*', 'data/**/*',
-                        'doc/**/*', 'rdoc/**/*', 'test/**/*', 'bench/**/*',
-                        'demo/**/*', 'samples/**/*', 'examples/**/*' ]
+  def master ; @config ; end
+
+  def section
+    sect = @config[self.class.section_name] || {}
+  end
 
-    MUST_EXCLUDE = [ 'InstalledFiles', '**/CVS/**/*', '**/*~' ]
+  # Class Methods
 
-    class << self
-      def inherited( klass )
-        (@task_registry ||= []) << klass
-      end
-      def registry ; @task_registry ||= [] ; end
-      def tasks    ; @task ||= registry.collect { |t| t.task } ; end
+  class << self
+    def section_name(n=nil)
+      @sname = n.to_s if n
+      @sname
     end
+  end
 
-    attr_reader :master, :section
 
-    def initialize( master_config, section_config )
-      @master = master_config
-      @section = section_config
-      setup if respond_to?(:setup)
+=begin
+  class << self
+    def inherited( klass )
+      (@task_registry ||= []) << klass
     end
+    def registry ; @task_registry ||= [] ; end
+    def tasks    ; @task ||= registry.collect { |t| t.task_name } ; end
+
+    def task_name(n=nil) ; @tname = n.to_sym if n ; @tname ; end
+    def task_desc(d=nil) ; @tdesc = d.to_s   if d ; @tdesc ; end
+  end
+
+  attr_reader :master, :section
+
+  def initialize( master_config, section_config )
+    @master = master_config
+    @section = section_config
+    setup if respond_to?(:setup)
+  end
+
+  def [](x) ; @section[x] ; end
 
-    def [](x) ; @section[x] ; end
-
-    # Run the system command +cmd+.
-    #
-    # Example:
-    #   sh %{ls -ltr}
-    #
-    def sh(cmd, options={})
-      FileUtils.send( :fu_check_options, options, :noop, :verbose )
-      FileUtils.send( :fu_output_message, cmd ) if options[:verbose]
-      unless options[:noop]
-        system(cmd) or fail "Command Failed: [#{cmd}]"
-      end
+  # Run the system command +cmd+.
+  #
+  # Example:
+  #   sh %{ls -ltr}
+  #
+  def sh(cmd, options={})
+    FileUtils.send( :fu_check_options, options, :noop, :verbose )
+    FileUtils.send( :fu_output_message, cmd ) if options[:verbose]
+    unless options[:noop]
+      system(cmd) or fail "Command Failed: [#{cmd}]"
     end
+  end
 
-    # Run a Ruby interpreter with the given arguments.
-    #
-    # Example:
-    #   ruby %{-pe '$_.upcase!' <README}
-    #
-    def ruby(*args)
-      if Hash === args.last
-        options = args.pop
-      else
-        options = {}
-      end
-      puts "#{RUBY} #{args.join(' ')}" if $DEBUG
-      sh "#{RUBY} #{args.join(' ')}", options
+  # Run a Ruby interpreter with the given arguments.
+  #
+  # Example:
+  #   ruby %{-pe '$_.upcase!' <README}
+  #
+  def ruby(*args)
+    if Hash === args.last
+      options = args.pop
+    else
+      options = {}
     end
+    puts "#{RUBY} #{args.join(' ')}" if $DEBUG
+    sh "#{RUBY} #{args.join(' ')}", options
+  end
 
 #     # Attempt to do a normal file link, but fall back
 #     # to a copy if the link fails.
@@ -117,36 +177,35 @@ module Reap
 #       end
 #     end
 
-    # Returns the full package name which combines package name and version.
-    def package_name
-      @config['name'] + '-' + ( @config['version'] || '0.0.1' )
-    end
-
-    #   def rakefile
-    #     s = ''
-    #     rf = File.join(locate, 'packmule', 'packmule.rake')
-    #     File.open( rf ) { |f| s << f.gets(nil) }
-    #     s
-    #   end
-    #
-    #   def yamlform
-    #     s = ''
-    #     yf = File.join(locate, 'packmule', 'packmule.yaml')
-    #     File.open( yf ) { |f| s << f.gets(nil) }
-    #     s
-    #   end
-
-    #def value( key, *alt_masters )
-    #  return section[key] if section.key?( key )
-    #  alt_masters.each do |path|
-    #    parr = path.split(':').collect { |e| e.downcase }
-    #    conf = @config
-    #    parr.each { |e| conf = conf[e] }
-    #    return conf if conf
-    #  end
-    #  nil
-    #end
-
+  # Returns the full package name which combines package name and version.
+  def package_name
+    @config['name'] + '-' + ( @config['version'] || '0.0.1' )
   end
 
-end #module Reap
+  #   def rakefile
+  #     s = ''
+  #     rf = File.join(locate, 'packmule', 'packmule.rake')
+  #     File.open( rf ) { |f| s << f.gets(nil) }
+  #     s
+  #   end
+  #
+  #   def yamlform
+  #     s = ''
+  #     yf = File.join(locate, 'packmule', 'packmule.yaml')
+  #     File.open( yf ) { |f| s << f.gets(nil) }
+  #     s
+  #   end
+
+  #def value( key, *alt_masters )
+  #  return section[key] if section.key?( key )
+  #  alt_masters.each do |path|
+  #    parr = path.split(':').collect { |e| e.downcase }
+  #    conf = @config
+  #    parr.each { |e| conf = conf[e] }
+  #    return conf if conf
+  #  end
+  #  nil
+  #end
+=end
+
+end #class Reap::Task