reap 5.0.0 → 5.10.10

data/lib/reap/readymade.rb

@@ -0,0 +1,21 @@
+
+# This loads in the reap tasks and setsup
+# some tasks that are typically ready to go
+# without additional paramaters.
+
+require 'reap/task/announce'
+require 'reap/task/extract_tests'
+require 'reap/task/fileperm'
+require 'reap/task/info'
+require 'reap/task/install'
+require 'reap/task/package'
+require 'reap/task/publish'
+require 'reap/task/rdoc'
+require 'reap/task/test'
+
+rdoc_task( :rdoc )
+tests_task( :test )
+install_task( :install )
+info_task( :info )
+package_task( :package )
+extract_tests_task( :exttests )

data/lib/reap/task.rb

@@ -5,249 +5,183 @@ require 'fileutils'
 require 'facet/fileutils/safe_ln'
 require 'facet/string/tabto'
 require 'facet/module/basename'
-require 'facet/module/attr_setter'
 
-require 'facet/filelist' unless defined?( FileList )
-require 'facet/openobject'
+require 'carat/filelist'
 
 require 'reap/projectinfo'
 
-#  _____        _     ___                  ___ _
-# |_   _|_ _ __| |__ | _ ) __ _ ___ ___   / __| |__ _ ______
-#   | |/ _` (_-< / / | _ \/ _` (_-</ -_) | (__| / _` (_-<_-<
-#   |_|\__,_/__/_\_\ |___/\__,_/__/\___|  \___|_\__,_/__/__/
-#
-
 # Base class for reap tasks.
 #
-# Here's a simple example:
+# Here's an oh so simple example:
 #
 #   class MyTask < Reap::Task
 #
-#     task_desc 'this is a custom reap task'
+#     register 'mytask'
 #
-#     task_attr :mytask
+#     default_desc 'this is a custom reap task'
 #
-#     def run
+#     attr_accessor :message
 #
-#       mytask.message ||= 'None Found!'
+#     def init
+#       @message ||= master['default'] || 'None Found!'
+#     end
 #
-#       puts mytask.message  #=> Hello!
-#       puts master.default  #=> Yo!
-#       puts mytask.default  #=> Yo!   (inherited from master)
+#     def run
+#       puts @message
 #     end
 #   end
 #
-# With the corresponding settings in the ProjectInfo file as:
+# The corresponding settings in the ProjectInfo file will then be:
 #
-#   default: Yo!
+#   default: Default text, if any.
 #
-#   mytask:
-#     message: Hello!
+#   myname:
+#     TASK: mytask
+#     message: Message text, if any.
 #
-
 module Reap
 
-  def self.registry
-    Task.registry
-  end
-
-  # Task base class.
+  def self.registry ; @registry ; end
 
-  class Task
-
-    #include ::Config
-    include ::FileUtils
-
-    RUBY = ::Config::CONFIG['ruby_install_name']
-
-    class << self
-
-      # When this class is inherited the new task is registered.
-      def inherited( base )
-        registry << base
-        YAML.add_private_type( base.basename.downcase ) do |type, val|
-          base.new( val )
+  def self.register
+    @registry ||= {}
+    ObjectSpace.each_object(Class) { |klass|
+      if klass < ::Reap::Task
+        if klass.verify
+          @registry[klass.basename.downcase] = klass
         end
       end
+    }
+  end
 
-      # List of task classes.
-      def registry
-        @registry ||= []
-      end
+  def self.tasks ; @tasks ; end
 
-      # Task DSL
+  def self.initialize
+    @tasks ||= {}
+    registry.each do |name, klass|
+      @tasks[name] = klass.new
+    end
+  end
 
-      # Provides tasks type.
-      def task_class
-        basename.downcase
-      end
 
-      # Short one-line description of the task.
-      def task_desc( text=nil, &block )
-        return @task_desc = proc { text } if text
-        return @task_desc = block if block_given?
-        return @task_desc.call
-      end
-      alias_method :desc, :task_desc
-
-      # Takes a string or a block the evaluates to a string
-      # providing detailed help information about the task.
-      def task_help( text=nil, &block )
-        return @task_help = proc { text } if text
-        return @task_help = block if block_given?
-        return @task_help.call
-      end
-      alias_method :help, :task_help
+  class Task
 
-      # Set alias for 'task' attribute, which provides
-      # inherited (from master) access to section data.
-      # (Deprecate? You can use "alias_method name, :task")
-      def task_attr( name )
-        define_method(name) { @task }
-      end
+    include ::Config
+    include ::FileUtils
 
-      # How to determine if a task is available for use.
-      # By default a taks is only available if the Project
-      # file exists and the task's section also exists.
-      # Common was to loosen this resriction are to
-      # only require the file, not the seciton:
-      #
-      #   task_available { Reap.projectfile? }
-      #
-      # Or have no restrictions:
-      #
-      #   task_available true
-      #
-      def task_available( bool=false, &block )
-        if bool
-          (class << self; self; end).class_eval {
-            define_method( :available? ){ |app| true }
-          }
-        else
-          (class << self; self; end).class_eval {
-            define_method( :available?, &block )
-          }
-        end
-      end
+    RUBY = CONFIG['ruby_install_name']
 
-      # Is the task available for use? By default
-      # a task is only made available if the
-      # ProjectInfo file has a task for it.
+    # class methods
 
-     def available?(app)
-       false
-     end
+    def self.task_desc ; '(no desciption given)' ; end
+    def self.task_name ; basename.downcase ; end
 
-      # Class-level access to Project file's master data
-      # provided via a CascadingOpenObject.
-      def master
-        @master ||= ProjectInfo.instance.to_cascading_open_object
-      end
+    def self.section_required( val ) ; @section_required = val ;end
+    def self.section_required? ; @section_required ; end
 
-    end #<< class
+    def self.verify
+      assume = true
+      if section_required?
+        assume = ::ProjectInfo.info.key?(task_name)
+      end
+      assume
+    end
 
     # instance methods
 
-    attr_accessor :task_name
-    def name ; task_name ; end
-
-    def task_desc ; @section[:desc] || self.class.task_desc ; end
-    def task_help ; self.class.task_help ; end
+    def task_name ; self.class.task_name ; end
+    def task_desc ; self.class.task_desc ; end
 
-    def master    ; self.class.master  ; end
-    def setting   ; @task    ; end
+    def master ; ::ProjectInfo.info ; end
 
-    attr :section
+    def section ; @section ; end
 
-    def initialize( section )
-      case section when Hash, nil
-        @section = CascadingOpenObject.new( section || {} )
-      else
-        @section = section
-      end
-    end
-
-    # Run task.
+    def section_required? ; self.class.section_required? ; end
 
-    def execute( *args )
-      #@section = CascadingOpenObject.new( section )
-
-      task = section.dup
-      if task.respond_to?(:__parent__)
-        task.__parent__ = master
-      end
-      @task = task
-
-      # deprecate init ?
-      if respond_to?( :init )
-        if method(:init).arity == 0
+    def initialize
+      sect = master[task_name]
+      if sect.is_a?(Array)
+        sect.each do |s|
+          section_parameters_set( s )
           init
-        else
-          init( *args )
         end
-      end
-
-      if method(:run).arity == 0
-        run
       else
-        run( *args )
+        section_parameters_set( sect || {} )
+        init
       end
     end
 
-    # interface
-
-    #def init
-    #  raise "not implemented for '#{name}' task"
-    #end
-
-    def run
-      raise "no action defined for task #{task_name}"
+    def section_parameters_set( s )
+      @section = s
+      @section.each { |k,v| send("#{k}=", v) }
     end
 
-    # delegate to section hash
-    def method_missing( *args, &block )
-      @section.send( *args, &block )
+    def init
+      raise "not implemented for '#{task_name}' task"
     end
 
-    # Task support methods
-
-    def use_subsection( name )
-      subsection = @section.__send__(task_name)
-      if subsection
-        subsection.__parent__ = @section
-        @task = subsection
-      end
+    def run( *args )
+      raise "no action defined for task #{task_name}"
     end
 
+    # task support methods
+
     def sh( arg )
       puts arg
       system arg unless $PRETEND
     end
 
-    def ask( question, answers=nil )
-      print "#{question}"
-      print " [#{answers}] " if answers
-      until inp = $stdin.gets[0,1] ; sleep 1 ; end ; puts
-      inp
-    end
-
-    def tell( statement )
-      puts statement
-    end
-
-    def provide_setup_rb
-      return true if File.exists?( 'setup.rb')
-      # copy from data dir to current directory (Won't work with Gem!)
-      f = File.join( Config::CONFIG['datadir'], 'reap', 'setup_rb', 'setup.rb' )
-      if File.exists?(f)
-        File.cp( f, '.' )
-        true
-      else
-        nil
-      end
-    end
+#       o = nil
+#       o = yld.call(self) if yld
+#       if String === o
+#         begin
+#           section( o ).each { |k,v| send("#{k}=", v ) }
+#         end
+#       end
+# 
+#       init
+# 
+#       task_name ||= default_name
+#       task_desc = @desc || default_desc
+# 
+#       if subtask
+#         desc task_desc
+#         task task_name => subtask do
+#           run
+#         end
+#       else
+#         desc task_desc
+#         task task_name do
+#           run
+#         end
+#       end
+#     end
 
   end #class Task
 
 end #module Reap
+
+
+##
+# Convenience methods for built-in rake tasks
+##
+# module RakeTask
+#   extend self
+# 
+#   def gem_package_task(*args,&blk)
+#     ::Rake::GemPackageTask.new(*args,&blk)
+#   end
+# 
+#   def package_task(*args,&blk)
+#     ::Rake::PackageTask.new(*args,&blk)
+#   end
+# 
+#   def test_task(*args,&blk)
+#     ::Rake::TestTask.new(*args,&blk)
+#   end
+# 
+#   def rdoc_task(*args,&blk)
+#     ::Rake::RDocTask.new(*args,&blk)
+#   end
+# 
+# end

data/lib/reap/task/announce.rb

@@ -2,243 +2,155 @@
 require 'reap/task'
 
 require 'net/smtp'
-
 require 'facet/string/margin'
 require 'facet/string/tab'
 require 'facet/string/align_center'
 require 'facet/string/fold'
 require 'facet/string/word_wrap'
 
-
-#    _                                    _____        _
-#   /_\  _ _  _ _  ___ _  _ _ _  __ ___  |_   _|_ _ __| |__
-#  / _ \| ' \| ' \/ _ \ || | ' \/ _/ -_)   | |/ _` (_-< / /
-# /_/ \_\_||_|_||_\___/\_,_|_||_\__\___|   |_|\__,_/__/_\_\
-#
-
-# = Announcement Task
-#
-# The announce task is intended for sending out a nice
-# formated email message to a mailing address, especially
-# mailing-lists. ProjectInfo uses these parameters:
-#
-#   announce:
-#     server       Email server to route message.
-#     port         Email server's port.
-#     domain       Email server's domain name.
-#     account      Email account name.
-#     type         Login type, either plain, cram_md5 or login.
-#     secure       Uses TLS security, true or false?
-#     to           Email address to send announcemnt.
-#     from         Email address sent from.
-#     subject      Subject of email message.
-#     title        Project title.
-#     summary      Brief onl-liner description.
-#     description  Long description of project.
-#     homespage    Project homepage web address.
-#     links        Array of http links to related sites.
-#     file         File that contains announcement message.
-#     memo         Embedded announcement message.
-#     slogan:      Motto for you project.
-#
 class Reap::Announce < Reap::Task
 
-  task_desc "Email project announcement."
-
-  task_help %{
-
-    reap announce
-
-    Send an announcement to a mailaing list or other email address.
-
-    Server settings are
-
-      server       Email server to route message.
-      port         Email server's port.
-      domain       Email server's domain name.
-      account      Email account name.
-      type         Login type, either plain, cram_md5 or login.
-      secure       Uses TLS security, true or false?
-
-    Message settings are
-
-      to           Email address to send announcemnt.
-      from         Email address sent from.
-      subject      Subject of email message.
-      file         File that contains announcement message.
-      memo         Embedded announcement message.
-
-  }
-
-  task_attr :anc
-
-  def run
+  section_required true
 
-    # setup
-
-    anc.to       = (anc.to || 'ruby-talk@ruby-lang.org').to_s.strip
-    anc.from     = (anc.from || master['email']).to_s.strip
-    anc.server   = anc.server.to_s.strip
-    anc.port     = (anc.port || 25).to_i
-    anc.domain   = anc.domain.to_s.strip if anc.domain
-    anc.account  = anc.account.to_s.strip
-    anc.type     = (anc.type || 'plain').to_s.strip  #cram_md5 #plain #login
-
-    raise "server is a require announce field" if anc.server.empty?
-    raise "account is a require announce field" if anc.account.empty?
-
-    anc.title       ||= master.title
-    anc.version     ||= master.version || master.date
-    anc.links       ||= []
-    anc.subject     ||= "[ANN] #{anc.title}, v#{anc.version}"
-
-    anc.address = anc.to  # TODO
-
-    # validate
+  def task_desc
+    "Send announcement email to ruby-talk or other address."
+  end
 
-    #raise "DOMAIN is a required field" if anc.domain.empty?
+  attr_accessor :title, :version, :summary, :description, :subject
+  attr_accessor :to, :from, :server, :port, :domain, :account
+  attr_accessor :authtype, :sectype
+  attr_accessor :links, :slogan, :memo, :file
 
-    # announce
+  def init
+    @to       = (@to || 'ruby-talk@ruby-lang.org').to_s.strip
+    @from     = (@from || master['email']).to_s.strip
+    @server   = @server.to_s.strip
+    @port     = (@port || 25).to_i
+    @domain   = @domain.to_s.strip if @domain
+    @account  = @account.to_s.strip
+    @authtype = (@authtype || 'plain').to_s.strip  #cram_md5 #plain #login
+    #@sectype  = @sectype
 
-    message = build_message
+    raise "server is a require announce field" if @server.empty?
+    raise "account is a require announce field" if @account.empty?
 
-    puts "\n#{message}\n\n"
-    print "Send? [y/N] "
-    until inp = $stdin.gets[0,1] ; sleep 1 ; end
+    @title       ||= master['title']
+    @version     ||= master['version']
+    @summary     ||= master['summary']
+    @description ||= master['description']
+    @links       ||= []
+    @subject     ||= "[ANN] #{@title}, v#{@version}"
 
-    unless inp.downcase == 'y'
-      puts "Reap announce task canceled."
-      return nil
-    end
+    @address = @to  # TODO
 
-    # ask for password
-    print "Password for #{anc.account}: "
-    until passwd = $stdin.gets.strip ; sleep 1 ; end
-
-    mail = %Q{
-      |From: #{anc.from}
-      |To: #{anc.address}
-      |Subject: #{anc.subject}
-      |
-      |#{message}
-      }.margin
-    begin
-      # --- Send using SMTP object and an adaptor
-      Net::SMTP.enable_tls if Net::SMTP.respond_to?(:enable_tls) and anc.secure # == :tls
-      Net::SMTP.start(anc.server, anc.port, anc.domain, anc.account, passwd, anc.type) do |s|
-        s.send_message mail, anc.from, anc.address
-      end
-      puts "Email sent successfully to #{anc.address}."
-    rescue => e
-      puts "Email delivery failed."
-      puts e
-    end
-
-  end
-
-private
-
-  def build_message
+    #raise "DOMAIN is a required field" if @domain.empty?
 
     # header
     announce = %Q{
       |
       |A N N O U N C I N G
       |
-      |#{anc.title}, v#{anc.version}
+      |#{title}, v#{version}
       |
-      |#{anc.summary}
+      |#{summary}
       |
-      |#{anc.homepage}
       }.margin.align_center(66)
 
     # abstract
     abstract = ''
-    if anc.description
+    if @description
       abstract << "\n\n"
-      abstract << "ABSTRACT\n------------->\n\n#{anc.description}"
+      abstract << "ABSTRACT: #{@description}".word_wrap(72)
       abstract << "\n"
     end
 
     # more info
     info = ''
-    unless anc.links.empty?
-      info << "\n\n"
-      info << "\nRELATED LINKS\n------------------>\n\n" #.center(67)
-      anc.links.each{ |mi| info << "#{mi}" << "\n" } #.center(67) << "\n" }
+    unless @links.empty?
+      info << "\n"
+      info << "For More Information".center(67)
+      info << "\n"
+      @links.each{ |mi| info << "#{mi}".center(67) << "\n" }
       info << "\n"
     end
 
     # slogan
     slogan = ''
-    if anc.slogan
+    if @slogan
       slogan << "\n\n"
-      slogan << anc.slogan.center(67)
+      slogan << @slogan.center(67)
       slogan << "\n\n"
     end
 
     # memo
     memo = ''
-    if anc.memo
+    if @memo
       memo = ''
-      #memo << "\n---\n" #<< ('-' * 72) << "\n"
-      memo << "\nRELEASE MEMO\n----------------->\n\n"
-      memo << anc.memo.strip.fold(true) #.word_wrap(67)
+      memo << "\n" << ('-' * 72) << "\n"
+      memo << "(Memo)\n\n"
+      memo << @memo.fold.word_wrap(72)
       #memo << "\n"
     end
 
     # msg file
     msg = ''
-    if anc.file and File.file?( anc.file )
-      msg << "\nRELEASE MEMO\n----------------->\n\n"
-      #msg << "\n---\n" #<< ("-" * 68) << "\n"
-      #msg << "(from #{anc.file})\n\n"
-      mg = File.read( anc.file )
-      msg << mg.strip.fold(true) #.word_wrap(67)
+    if @file and File.file?( @file )
+      msg << "\n" << ("-" * 72) << "\n"
+      msg << "(from #{@file})\n\n"
+      mg = ''
+      File.open( @file ) { |f| mg << f.gets(nil) }
+      msg << mg.fold.word_wrap(72)
     end
 
     # stamp
-    stamp = "\n\n\n"
-    #stamp << "\n\n---\n" #<< ("-" * 68) << "\n"
+    stamp = ''
+    stamp << "\n" << ("-" * 72) << "\n"
     stamp << %Q{
-      |               Generated by
-      |
-      |     o)o)o)    o)o)o)o)    o)o)    o)o)o)
-      |    o)    o)  o)        o)    o)  o)    o)
-      |   o)o)o)    o)o)o)    o)o)o)o)  o)o)o)
-      |  o)    o)  o)        o)    o)  o)
-      | o)    o)  o)o)o)o)  o)    o)  o)
-      |
-      |       The Ruby Project Assistant
-      |
-      | Do you Ruby? (http://www.ruby-lang.org)
-      }.margin.indent(12)
-    stamp << "\n"
-
-    message = ''
-    message << announce
-    message << slogan
-    message << abstract
-    message << memo
-    message << msg
-    message << info
-    message << stamp
-
-    message
+      |Generated by Reap, a Rake-based Ruby Project Assistant.
+      |Do you Ruby?  (http://www.ruby-lang.org)
+      }.margin
+    stamp << "\n\n"
+
+    @message = ''
+    @message << announce
+    @message << abstract
+    @message << info
+    @message << slogan
+    @message << memo
+    @message << msg
+    @message << stamp
   end
 
-end
-
-
-# Rake interface.
-
-if defined?(Rake)
-
-  #require 'reap/rake/adapter'
-
-  module Rake
-    ReapAnnounce = ::Reap::RakeAdapter( ::Reap::Announce )
+  def run
+    puts "\n#{@message}\n\n"
+    print "Send? [Y/n] "
+    until inp = $stdin.gets[0,1] ; sleep 1 ; end
+    if (inp || 'y').downcase == 'y'
+      # ask for password
+      print "Password for #{@account}: "
+      until passwd = $stdin.gets.strip ; sleep 1 ; end
+      mail = %Q{
+        |From: #{@from}
+        |To: #{@address}
+        |Subject: #{@subject}
+        |
+        |#{@message}
+        }.margin
+      begin
+        # --- Send using SMTP object and an adaptor
+        Net::SMTP.enable_tls if Net::SMTP.respond_to?(:enable_tls) and @tls
+        Net::SMTP.start(@server, @port, @domain, @account, passwd, @authtype) do |s|
+          s.send_message mail, @from, @address
+        end
+        puts "Email sent successfully to #{@address}."
+      rescue => e
+        puts "Email delivery failed."
+        puts e
+      end
+    else
+      puts "Reap announce task canceled."
+      exit 0
+    end
   end
 
 end
-