reap 5.0.0 → 5.10.10

data/lib/reap/task/publish.rb

@@ -1,175 +1,49 @@
-#!/usr/bin/env ruby
 
 require 'reap/task'
-require 'shellwords'
 
-#  ___      _    _ _    _      _____        _
-# | _ \_  _| |__| (_)__| |_   |_   _|_ _ __| |__
-# |  _/ || | '_ \ | (_-< ' \    | |/ _` (_-< / /
-# |_|  \_,_|_.__/_|_/__/_||_|   |_|\__,_/__/_\_\
 #
-
-# = Publish Task
-
+# Publish Task
+#
 class Reap::Publish < Reap::Task
 
-  task_desc "Publish documents to the web or host."
-
-  task_help %{
-
-    reap publish
-
-    Publish documents to hosting service. Three means of
-    publishing are current supported, ftp uploading, scp,
-    and web convenience option that recognizes particular
-    hosts (only RubyForge is currently supported).
-
-      type           Type of publishing, 'web', 'scp' or 'ftp'.
-      host           Host server, default is 'rubyforge.org'
-      username       Username for host.
-      dir            Directory of files to publish. Or,
-      copy           Files to publish using from and to.
-      project        Project name (used for Rubyforge)
-
-    If the type is 'scp' or 'ftp' you will also need to provide
-    the root directory parameter.
-
-      root           Document root directory at host.
-
-    The dir parameter allows you to simply specify a local
-    directory, the contents of which will be published to
-    host's document root location (directory tree intact).
-
-    If you need more control over which files to publish
-    where, you can use the copy parameter instead. Provide
-    an array of pattern strings in the form of "{from} {to}".
-    If the desitination is the host's document root you do
-    not need to specify the {to} part. For example:
-
-      copy: [ 'web/*', 'doc/api/* doc/api' ]
-
-    The first copies the files under your project's web directory
-    to the host's document root. The second copies your projects
-    doc/api files to the doc/api location on the host.
-
-    When using the 'scp' type the internal template used for
-    the outbound destination is 'username@host:root/'.
-
-  }
-
-  #attr_accessor :host, :type, :dir, :project, :username
-  #attr_accessor :exclude  # not using yet
-
-  task_attr :pub
-
-  # Run the publishing task.
-
-  def run( target=nil, copy_from=nil, copy_to=nil )
-
-    return nil if target and target != pub.target
-
-    # setup
-
-    pub.type     ||= 'web'
-    pub.host     ||= 'rubyforge.org'
-    pub.root     ||= 'var/www/gforge-projects/'
-    pub.project  ||= master.rubyforge.project || master.name
-    pub.username ||= master.rubyforge.username
-    pub.copy     ||= [ "#{pub.dir}/*" ]
-
-    if copy_from
-      pub.copy = [ "#{copy_from} #{copy_to}".strip ]
-    end
-
-    # validate
+  section_required true
 
-    unless pub.project
-      puts "Project not specified." ; return nil
-    end
-
-    unless pub.username
-      puts "Username not specified." ; return nil
-    end
+  def task_desc
+    "Publish documents to the web."
+  end
 
-    # publish
+  attr_accessor :host, :type, :dir, :project, :username
+  attr_accessor :exclude  # not using yet
 
-    puts "Reap is passing off publishing work..."
+  def init
+    @type     ||= 'www'
+    @host     ||= 'rubyforge.org'
+    @project  ||= master['rubyforge']['project'] || master['name']
+    @username ||= master['rubyforge']['username']
+    @exclude  ||= []
+  end
 
-    case pub.type
+  def run
+    cmd = ''; skip = false
 
-    when 'web', 'www'
-      case pub.host
-      when 'rubyforge', 'rubyforge.org'
-        pub.host = "rubyforge.org"
-        pub.root = "/var/www/gforge-projects/#{pub.project}"
-        run_scp
+    case @host
+    when 'rubyforge', 'rubyforge.org'
+      case @type
+      when 'www', 'web'
+        cmd = %{scp -r #{@dir}/* #{@username}@rubyforge.org:/var/www/gforge-projects/#{@project}/}
       else
-        puts %{Unrecognized publishing host '#{pub.host}'. Skipped.}
-        return nil
+        puts %{Unrecognized publishing kind '#{@type}' for host '#{@host}'. Skipped.}
+        skip = true
       end
-
-    when 'scp'
-      run_scp
-
-    when 'ftp'
-      run_ftp
-
     else
-      puts %{Unrecognized publishing type '#{pub.type}'. Skipped.}
-      return nil
+      puts %{Unrecognized publishing host '#{@host}'. Skipped.}
+      skip = true
     end
 
-  end
-
-private
-
-  #--
-  # SHELL OUT! Need a net/ssh library to fix.
-  #++
-
-  def run_scp
-    pub.copy.each { |c|
-      from, to = *Shellwords.shellwords(c)
-      to = '' if to.nil?
-      to = to[1..-1] if to[0,1] == '/'
-      cmd = "scp -r #{from} #{pub.username}@#{pub.host}:#{pub.root}/#{to}"
-      sh( cmd )
-    }
-  end
-
-  def run_ftp
-    require 'net/ftp'
-    return if $PRETEND
-    Net::FTP.open( pub.host ) do |ftp|
-      ftp.login( pub.username )
-      ftp.chdir( pub.root )
-
-      pub.copy.each { |c|
-        from, to = *Shellwords.shellwords(c)
-        to = '' if to.nil?
-        to = to[1..-1] if to[0,1] == '/'
-        from.sub('*', '**/*') unless from =~ /\*\*/
-        files = FileList.new( from )
-        files.each { |f|
-          t = File.join( to, f.basename )
-          ftp.putbinaryfile( f, t, 1024 )
-        }
-      }
+    unless skip
+      puts "Reap is shelling out publishing work..."
+      sh(cmd) unless $PRETEND
     end
   end
 
 end
-
-
-# Rake interface.
-
-if defined?(Rake)
-
-  #require 'reap/rake/adapter'
-
-  module Rake
-    ReapPublish = ::Reap::RakeAdapter( ::Reap::Publish )
-  end
-
-end
-

data/lib/reap/task/rdoc.rb

@@ -1,84 +1,50 @@
 
 require 'reap/task'
 
-#  ___    _           _____        _
-# | _ \__| |___  __  |_   _|_ _ __| |__
-# |   / _` / _ \/ _|   | |/ _` (_-< / /
-# |_|_\__,_\___/\__|   |_|\__,_/__/_\_\
 #
-
-# = RDoc Task
-#
-# This task generates RDoc API documentation trom source
-# comments.
+# RDoc Task
 #
-#   rdoc:
-#     dir        Directory to store documentation [doc].
-#     main       File to use as main page of RDocs.
-#     title      Project title to use in RDocs.
-#     template   Which RDoc template to use.
-#     include    Files to include in RDocs.
-#     exclude    Files to exclude from those.
-#     options    Pass-thru extra options to RDoc command.
-#
-
 class Reap::RDoc < Reap::Task
 
-  MUST_EXCLUDE = [ 'InstalledFiles', 'CVS/**/*', '_darcs/**/*' ]
-
-  task_desc "Generate RDoc API documentation."
-
-  task_help %{
-
-    Generate RDoc doumentation.
-
-      dir          Directory to store documentation [doc].
-      main         File to use as main page of RDocs.
-      title        Project title to use in RDocs.
-      template     Which RDoc template to use.
-      include      Files to include in RDocs.
-      exclude      Files to exclude from those.
-      options      Pass-thru extra options to RDoc command.
-
-  }
+  def task_desc
+     "Generate RDocs (in #{dir})."
+  end
 
-  task_attr :doc
+  attr_accessor :dir, :main, :title, :template,
+                :include, :exclude, :options
+
+  def init
+    @dir      ||= 'doc'
+    @main     ||= 'README'
+    @title    ||= master["title"]
+    @template ||= 'html' # 'jamis'
+    @include  ||= [ 'A-Z*', 'lib/**/*', 'ext/**/*' ]
+    @exclude  ||= [ 'demo/**/*', 'example/**/*', 'sample/**/*' ]
+    @options  ||= ['--merge', '--all']
+  end
 
   def run
+    must_exclude = [ 'InstalledFiles', 'CVS/**/*' ]
 
-    # setup
-
-    doc.dir      ||= 'doc'
-    doc.main     ||= 'README'
-    doc.title    ||= master.title
-    doc.template ||= 'html' # 'jamis'
-    doc.include  ||= [ 'A-Z*', 'lib/**/*', 'ext/**/*', doc.main ]
-    doc.exclude  ||= [ 'demo/**/*', 'example/**/*', 'sample/**/*' ]
-    doc.options  ||= ['--merge', '--all']
-
-    doc.include = [ doc.include ].flatten
-    doc.exclude = [ doc.exclude ].flatten
-    doc.options = [ doc.options ].flatten
-
-    # document
-
-    if !File.exists?(doc.main) or File.directory?(doc.main)
-      warn "WARNING! Specified RDoc Main file #{doc.main} not found."
-      doc.main = nil
+    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(doc.dir)
-
-    if FileTest.directory?(doc.dir)
-      q = "Directory '#{doc.dir}' already exists. Clobber?"
-      #until inp = $stdin.gets[0,1] ; sleep 1 ; end ; puts
-      inp = ask( q, 'yN' )
-      case inp.downcase
-      when 'y', 'yes', 'okay'
-        tell "Removing old directory '#{rdoc_dir}'..."
-        FileUtils.rm_r(doc.dir) unless $PRETEND
+    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) unless $PRETEND
       else
-        tell "Reap rdoc task canceled."
+        puts "Reap rdoc task canceled."
         return nil
       end
     end
@@ -86,13 +52,13 @@ class Reap::RDoc < Reap::Task
     rdoc_target = "#{rdoc_dir}/index.html"
 
     exc = []
-    (doc.exclude + MUST_EXCLUDE).each{ |e|
+    (@exclude + must_exclude).each{ |e|
       exc << e
       exc |= Dir.glob(e+'/**/*')
     }
 
     inc = Dir.glob('[A-Z]*')
-    doc.include.each{ |i| inc |= Dir.glob(i) }
+    @include.each{ |i| inc |= Dir.glob(i) }
     inc -= exc
 
     inc = inc.select{ |f| File.file?(f) }
@@ -102,33 +68,15 @@ class Reap::RDoc < Reap::Task
 
     # build options string
     build = []
-    build += doc.options
-    build << "--main '#{doc.main}'" if doc.main
-    build << "--title '#{doc.title}'" if doc.title
-    build << "-T '#{doc.template}'" if doc.template
+    build += @options
+    build << "--main '#{@main}'" if @main
+    build << "--title '#{@title}'" if @title
+    build << "-T '#{@template}'" if @template
     rdoc_opts = build.join(' ')
 
-    #--
-    # SHELL OUT! Can RDoc be called from code?
-    #++
-
     # do it!
-    tell "Reap is shelling work out to RDoc..."
+    puts "Reap is shelling work out to RDoc..."
     sh %{rdoc -o #{rdoc_dir} #{rdoc_opts} #{rdoc_files}}
   end
 
 end
-
-
-# Rake interface.
-
-if defined?(Rake)
-
-  #require 'reap/rake/adapter'
-
-  module Rake
-    ReapRDoc = ::Reap::RakeAdapter( ::Reap::RDoc )
-  end
-
-end
-

data/lib/reap/task/scaffold.rb

@@ -1,57 +1,114 @@
-require 'reap/task'
-require 'facet/gem/self/gempath'
 
-class Reap::Scaffold < Reap::Task
+#require 'rbconfig'
+#require 'reap/projectinfo'
 
-  task_desc "Generate a project directory layout."
+module Scaffold
+  extend self
 
-  task_help %{
+  SCMPaths => %w{
+    trunk
+    branch
+    tag
+    scrap
+    package
+  }
 
-    reap scaffold [type]
+  TrunkPaths = %w{
+    bin
+    lib
+    ext
+    dev
+    data
+    test
+    demo
+  }
 
-    Generates a project directory layout within the current
-    directory. The scaffolding includes all the standard
-    features such as directories lib/ bin/ doc/
-    and files such as README.
+  TrunkFiles = %w{
+    README
+    INSTALL
+    COPYING
+    ProjectInfo
+    ChangeLog
+    Todo
+    RakeFile
+    setup.rb
+  }
 
-    To use this task you should first create an empty
-    directory and than change into it. It will not generate
-    a scaffolding into a directory with any files already in
-    it unless you use the -f (force) option. Also, the scaffold
-    task is not available if a ProjectInfo file exists.
+  def go(name) ; scaffold(name) ; end
 
-    There are currently two types of supported scaffoldings:
-    'standard', which is the default if no type is given,
-    and 'subversion' which creates a "trunk" hierarchy.
+  # Main method.
+  def scaffold(name=nil)
+    name ||= 'yourlib.projectdomain.org'
+    t = Time.now.strftime("%Y-%m-%d")
+    libdir = File.join( 'lib', "#{@name},#{t}" )
 
-  }
+    if @scm
+      SCMPaths.each { |d| makedir( d ) }
+      Dir.chdir 'trunk'
+    end
+    TrunkPaths.each { |d| makedir( d ) }
+    makedir_with_check( libdir )
+    TrunkFiles.each { |f| temlpate( f ) }
+  end
 
-  task_available { |app| ! app.projectfile? }
+  private
 
-  def run( type=nil )
-    content = Dir.entries('.') - [ '.', '..' ]
-    if not content.empty? and not $FORCE
-      tell "Directory already has content. Use -f option to force scaffolding."
-      return nil
-    end
-    type ||= 'standard'
-    type = 'standard' if type == 'std'
-    type = 'subversion' if type == 'svn'
-    # gems workaround
-    if dir = Gem.gempath('reap')
-      dir = File.join( dir, 'data', 'reap', 'scaffold', type )
-    else
-      dir = File.join( ::Config::CONFIG['datadir'], 'reap', 'scaffold', type )
+  # Copy a file from lib/data to the current dir.
+  def template( filename )
+    dir = File.join(File.dirname(__FILE__), 'data' )
+    #dir = File.join( ::Config::CONFIG['datadir'], DATA_DIR )
+    f = File.join( dir, filename )
+    unless File.file?( f )
+      puts f
+      raise "Tempfile is missing."
     end
-    #
-    unless File.directory?( dir )
-      tell "Unrecognized project type."
-    else
-      #FileUtils.mkdir_p( name )
-      FileUtils.cp_r( File.join( dir, '.'), '.' )
-      tell "Project ready."
+
+    if File.exists?(filename)
+      puts "#{filename} already exists."
+      return
     end
+    # copy tmpf to Reapfile
+    FileUtils.cp( f, filename )
+    #puts "#{filename} created. You'll need to fill it out."
+  end
+
+  # Make a directory as long as it doesn't already exist.
+  def makedir( dir )
+    FileUtils.makedir_p( dir ) unless File.directory?( dir )
   end
 
 end
 
+
+
+=begin
+  def scaffold
+    require 'reap/scaffold'
+    name =
+    domain =
+    Scaffold.go( name, domain )
+  end
+
+  def template( file_name = ProjectInfo )
+    #dir = File.dirname(File.dirname(__FILE__))
+    dir = File.join( ::Config::CONFIG['datadir'], DATA_DIR )
+
+    tmpf = File.join( dir, 'template.yaml' )
+    unless File.file?( tmpf )
+      puts tmpf
+      raise "Tempfile is missing."
+    end
+
+    if File.directory?(filename)
+      puts "#{filename} a directory. Cannot comply."
+      return
+    elsif File.file?(filename)
+      puts "#{filename} already exists."
+      return
+    end
+    # copy tmpf to Reapfile
+    FileUtils.cp( tmpf, filename )
+    puts "#{filename} created. You'll need to fill it out."
+  end
+=end
+