reap 4.3.2 → 4.3.3

data/lib/reap/task/fileperm.rb

@@ -1,21 +1,39 @@
 
 require 'reap/task'
 
+#  ___               _       _               _____        _
+# | _ \___ _ _ _ __ (_)_____(_)___ _ _  ___ |_   _|_ _ __| |__
+# |  _/ -_) '_| '  \| (_-<_-< / _ \ ' \(_-<   | |/ _` (_-< / /
+# |_| \___|_| |_|_|_|_/__/__/_\___/_||_/__/   |_|\__,_/__/_\_\
 #
-# File Permissions Task
-#
+
+# = File Permissions Task
+
 class Reap::Perm < Reap::Task
 
-  task_desc "Normalize ownership and permissions of package files."
   section_required true
 
-  attr_accessor :user, :group, :filemod, :dirmod
+  task_desc "Normalize ownership and permissions of package files."
+
+  task_help %{
+
+    reap perm
+
+    Normalizes file permissions.
+
+      user          user name to use
+      group         group name to use
+
+  }
+
+  #attr_accessor :user, :group, :filemod, :dirmod
+
+  task_attr :perm
 
   def init
-    @user = section['user']
-    @group   ||= @user
-    @filemod ||= 644
-    @dirmod  ||= 755
+    perm.group   ||= perm.user
+    perm.filemod ||= 644
+    perm.dirmod  ||= 755
   end
 
   def run
@@ -76,4 +94,3 @@ class Reap::Perm < Reap::Task
 
 end
 
-#Reap.register( Reap::Perm )

data/lib/reap/task/info.rb

@@ -1,17 +1,33 @@
 
 require 'reap/task'
 
+#  ___       __       _____        _
+# |_ _|_ _  / _|___  |_   _|_ _ __| |__
+#  | || ' \|  _/ _ \   | |/ _` (_-< / /
+# |___|_||_|_| \___/   |_|\__,_/__/_\_\
 #
-# Info Task - Displays the ProjectInfo file.
+
+# = Info Task
 #
+# Displays the ProjectInfo file.
+
 class Reap::Info < Reap::Task
 
   task_desc "Display ProjectInfo file."
 
-  def init
+  task_help %{
+
+    reap info
+
+    Display ProjectInfo file.
+
+  }
+
+  def init( na )
+    # no initialization
   end
 
-  def run
+  def run( na )
     puts $PROJECT_INFO.info_stream
   end
 

data/lib/reap/task/install.rb

@@ -3,17 +3,19 @@
 require 'reap/task'
 require 'reap/setup'
 
+#  ___           _        _ _   _____         _
+# |_ _|_ __  ___| |_ __ _| | | |_   _|_ _ ___| | __
+#  | || '_ \/ __| __/ _` | | |   | |/ _` / __| |/ /
+#  | || | | \__ \ || (_| | | |   | | (_| \__ \   <
+# |___|_| |_|___/\__\__,_|_|_|   |_|\__,_|___/_|\_\
 #
-# Install Task
-#
-class Reap::Install < Reap::Task
 
-  task_desc "Locally install package using setup.rb or install.rb."
+class Reap::Install < Reap::Task
 
-  attr_accessor :options #, :sudo
+  task_desc "Locally install package using built-in setup.rb."
 
   def init
-    @options ||= []
+    task.options ||= []
     #@sudo   ||= true
   end
 
@@ -27,7 +29,7 @@ class Reap::Install < Reap::Task
 
     ARGV.delete('install')
     ARGV << '-q' unless $VERBOSE
-    ARGV.concat(options)
+    ARGV.concat(task.options)
 
     $setup_pwd = $PROJECT_INFO.info_dir #Dir.pwd
 

data/lib/reap/task/noop.rb

@@ -15,13 +15,11 @@ class Reap::Noop < Reap::Task
 
   task_desc "A no-op task to help debug reap itself."
 
-  attr_accessor :message
-
-  def init
+  def init( msg )
   end
 
-  def run
-    puts ( message || 'No message field in noop section.' )
+  def run( msg )
+    puts ( msg.message || 'No message field in noop section.' )
   end
 
 end

data/lib/reap/task/package.rb

@@ -7,112 +7,154 @@ rescue LoadError
   # no rubygems
 end
 
-##
-# Package Task
+#  ___         _                   _____        _
+# | _ \__ _ __| |____ _ __ _ ___  |_   _|_ _ __| |__
+# |  _/ _` / _| / / _` / _` / -_)   | |/ _` (_-< / /
+# |_| \__,_\__|_\_\__,_\__, \___|   |_|\__,_/__/_\_\
+#                      |___/
+
+# = Package Task
 #
 # This task creates standard .zip, .tgz, or .tbz
 # packages, plus .gem distributions.
-#
+
+
 class Reap::Package < Reap::Task
 
+  MUST_EXCLUDE = [ 'InstalledFiles', '**/CVS/**/*', '**/*~', 'dist', 'pkg' ]
+  LOCATIONS = [ '../leaf', '../dist', '../pkg', 'dist', 'pkg' ]
+
+  # Task line description
+
   task_desc do
     disttypes = $PROJECT_INFO['distribute'] || [ 'gem', 'tar.bz2', 'zip' ]
     "Build distribution packages (#{disttypes.join(', ')})."
   end
 
-  MUST_EXCLUDE = [ 'InstalledFiles', '**/CVS/**/*', '**/*~', 'dist', 'pkg' ]
-  LOCATIONS = [ '../leaf', '../dist', '../pkg', 'dist', 'pkg' ]
+  # Help information
+
+  task_help %{
+
+    reap package
+
+    Builds distribution packages. The package task supports
+    tar.gz, tar.bz2, zip source packages and gem, pacman and
+    debian ditribution packages.
+
+      dir             Directory in which to store distributions.
+      include         Files to include in distribution.
+      exclude         Files to exclude from those.
+      distribute      Distribution types.
+                        tgz, tar.gz, tbz, tar.bz2, zip
+                        gem, deb, pac
+      project         Project name.
+      category        Software category.
+      architecture    Can be any, i368, i686, ppc, etc.
+      dependencies    List of packages this program depends.
+      recommends      List of packages that can be used with this package.
+      replaces        List of packages this one replaces.
+      executables     Executable files in this distribution.
+      source          URL of source package (typically a tar.gz file).
+      md5             MD% checksum of source file.
 
-  attr_master :name, :version, :date, :series, :status,
-              :author, :maintainer, :email, :homepage,
-              :summary, :description,
-              :dependencies, :executables, :requirements, :architecture,
-              :category, :recommends
+                      These are RubyGems specific.
+      autorequire
+      platform
+      require_paths
 
-  attr_accessor :dir, :project, :exclude, :include, :format,
-                :autorequire, :platform, :require_paths
+    The package task also has subsection for each type of distribution.
+    These can be used to override settings in the package information
+    if it in some way differs. Possible subsections are:
 
-  attr_reader :package_name, :series_versioning
+      gems
+      pacman
+      debian
 
+  }
 
-  def init( options={} )
-    @dir ||= LOCATIONS.find { |f| File.directory?(f)  } || 'dist'
+  # Alternate for task properties accessor.
 
-    #@name         ||= master['name']
-    #@status       ||= master['status'] || 'beta/stable'
-    #@date         ||= master['date'] || Time.now.strftime("%Y-%m-%d")
-    #@series       ||= master['series'] || '1'
+  task_attr :pkg
 
-    @maintainer   ||= @author
-    @status       ||= 'beta/stable'
-    @date         ||= Time.now.strftime("%Y-%m-%d")
-    @series       ||= '1'
-    @architecture ||= 'any'
+  # Setup package task.
 
-    d = @date.split('-').collect{ |e| e.to_i }
+  def init
+
+    # Do not look in master information for this
+
+    pkg.dir = section.dir || LOCATIONS.find { |f| File.directory?(f)  } || 'dist'
+
+    # Set defaults
+
+    pkg.status       ||= 'beta/stable'
+    pkg.date         ||= Time.now.strftime("%Y-%m-%d")
+    pkg.series       ||= '1'
+    pkg.author       ||= "Anonymous"
+    pkg.maintainer   ||= pkg.author
+    pkg.email        ||= ""
+    pkg.summary      ||= ""
+    pkg.architecture ||= 'any'
+    pkg.license      ||= 'Ruby/GPL'
+    pkg.project      ||= master.rubyforge.project
+    pkg.homepage     ||= master.rubyforge.homepage
+
+    d = pkg.date.split('-').collect{ |e| e.to_i }
     #d[0] = d[0] - 2000  # No need to keep the 2000
-    @version     ||= d.join('.')
+    pkg.version      ||= d.join('.')
 
     if $BUILD_VERSION
-      buildno = eval(Time.now.strftime("%H*60+%M"))
-      @version += ".#{buildno}"
+      pkg.buildno = Time.now.strftime("%H*60+%M")
+      pkg.version += ".#{pkg.buildno}"
     end
 
-    unless @series
-      puts "Series is required."
-      exit 0
-    end
+    pkg.package_name ||= "#{pkg.name}-#{pkg.version}"
 
-    @package_name ||= @name + '-' + @version
-    #@package_name ||= @name + ',' + @date  # rubyforge doesn't allow commas
+    pkg.exclude      ||= []
+    pkg.exclude      |= MUST_EXCLUDE
 
-    #@author       ||= master['author']
-    #@email        ||= master['email']
-    #@summary      ||= master['summary']
-    @project      ||= master['rubyforge']['project']
-    #@homepage     ||= master['homepage'] || master['rubyforge']['homepage']
-    @homepage     ||= master['rubyforge']['homepage']
+    pkg.include      ||= ['**/*']
 
-    @exclude      ||= []
-    @exclude      |= MUST_EXCLUDE
+    # distribute types include 'tgz', 'tbz', 'zip', 'tar.gz' 'tar.bz2', 'gem', 'pac' and 'deb'.
 
-    @include      ||= ['**/*']
+    pkg.distribute   ||= [ 'gem', 'tar.bz2', 'zip' ]
+    pkg.distribute = [pkg.distribute].flatten.collect { |t| t.to_s.strip.downcase }
 
-    # format types include 'tgz', 'tbz', 'zip', 'tar.gz' 'tar.bz2', 'gem' and 'deb'.
-    @format        ||= master['distribute'] || [ 'gem', 'tar.bz2', 'zip' ]
-    @format = [@format].flatten
-    @format.collect! { |t| t.to_s.strip.downcase }
+    pkg.dependencies ||= []
+    pkg.executables  ||= []
+    pkg.requirements ||= []
+    pkg.recommends   ||= []
+    pkg.conflicts    ||= []
+    pkg.replaces     ||= []
 
-    @dependencies ||= []
-    @executables  ||= []
-    @requirements ||= []
-    @recommends   ||= []
+    # Gem specific properties
 
-    # gem specific (at least in this context)
-    if defined?(Gem)
-      if @platform
+    if defined?(::Gem) and pkg.gem
+      if pkg.gem.platform
         begin
-          @platform = ::Gem.const_get(@platform)
+          pkg.gem.platform = ::Gem::Platform.const_get(pkg.gem.platform.upcase)
         rescue NameError
-          @platform = ::Gem::Platform::RUBY
+          pkg.gem.platform = ::Gem::Platform::RUBY
         end
       else
-        @platform ||= ::Gem::Platform::RUBY
+        pkg.gem.platform = ::Gem::Platform::RUBY
       end
       #@autorequire
     end
 
   end
 
-  def run( options={} )
-    puts "Creating #{@format.join(',')} packages..."
+  # Run package task.
+
+  def run
+
+    puts "Creating #{pkg.distribute.join(',')} packages..."
 
     # create package image
-    group_dir_path = File.join( @dir, @package_name )
-    package_dir_path = File.join( @dir, @package_name, @package_name )
+    group_dir_path = File.join( pkg.dir, pkg.package_name )
+    package_dir_path = File.join( pkg.dir, pkg.package_name, pkg.package_name )
 
     if FileTest.directory?(group_dir_path)
-      print "Package directory '#{package_name}' already exists. Conitnue anyway or [R]emove and continue? [y/r/N] "
+      print "Package directory '#{pkg.package_name}' already exists. Continue or [R]emove and continue? [y/r/N] "
       until inp = $stdin.gets[0,1] ; sleep 1 ; end
       inp = inp.to_s.downcase
       case inp
@@ -127,9 +169,9 @@ class Reap::Package < Reap::Task
       end
     end
     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.include(*pkg.include)
+    package_files.exclude(*pkg.exclude) if pkg.exclude and not pkg.exclude.empty?
+    FileUtils.mkdir_p pkg.dir #rescue nil
     package_files.each do |f|
       pkgf = File.join(package_dir_path, f)
       fdir = File.dirname(pkgf)
@@ -143,8 +185,8 @@ class Reap::Package < Reap::Task
     end
 
     # create standard package files
-    FileUtils.chdir( File.join( @dir, @package_name ) ) do
-      @format.each do |t|
+    FileUtils.chdir( File.join( pkg.dir, pkg.package_name ) ) do
+      pkg.distribute.each do |t|
         sh_cmd = nil
         prefix = 'ERROR' # in case of unforseen bug
         case t
@@ -160,20 +202,21 @@ class Reap::Package < Reap::Task
           prefix = 'zip'
           sh_cmd = 'zip -r'
           puts "\nReap is shelling out work to zip..."
-        when 'gem', 'deb'
+        when 'gem', 'deb', 'pac'
           sh_cmd = nil
         else
           puts "Unknown package type '#{t}' skipped."
           sh_cmd = nil
         end
-        sh %{#{sh_cmd} #{@package_name}.#{prefix} #{@package_name}} if sh_cmd
+        sh %{#{sh_cmd} #{pkg.package_name}.#{prefix} #{pkg.package_name}} if sh_cmd
       end
       puts
     end
 
     # create gem package
-    if @format.include?('gem')
-      if defined?(Gem)
+
+    if pkg.distribute.include?('gem')
+      if defined?(::Gem)
         run_gem
       else
         puts "Package .gem requested, but rubygems not found (skipped)."
@@ -181,7 +224,8 @@ class Reap::Package < Reap::Task
     end
 
     # create debian package
-    if @format.include?('deb')
+
+    if pkg.distribute.include?('deb')
       if true # TODO ensure required debian tools here
         run_deb
       else
@@ -189,21 +233,33 @@ class Reap::Package < Reap::Task
       end
     end
 
+    # create PKGBUILD (pacman, archlinux)
+
+    if pkg.distribute.include?('pac')
+      if true # TODO ensure required tools here
+        run_pacman
+      else
+        puts "Pacman package requested, but required tools not found (skipped)."
+      end
+    end
+
     return true
   end
 
-  # support methods -------------------------------------------
-
-  private
+private
 
   # This builds the gem package.
 
   def run_gem
+
+    use_subsection :gem
+    #pkg = sub ? sub : pkg
+
     spec = Gem::Specification.new { |s|
-      s.name = @name
-      s.version = @version
+      s.name = pkg.name
+      s.version = pkg.version
 
-      @dependencies.each { |d,v|
+      pkg.dependencies.each { |d,v|
         if v
           s.add_dependency(d, v)
         else
@@ -211,26 +267,30 @@ class Reap::Package < Reap::Task
         end
       }
 
-      s.platform = @platform
-      s.summary = @summary
-      s.requirements = @requirements
+      s.summary = pkg.summary
+      s.requirements = pkg.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?
+      package_files.include(*pkg.include)
+      package_files.exclude(*pkg.exclude) if pkg.exclude and not pkg.exclude.empty?
       s.files = package_files.to_a
 
+      s.author            = pkg.author
+      s.email             = pkg.email
+      s.rubyforge_project = pkg.project
+      s.homepage          = pkg.homepage
+
       s.require_path = 'lib'
-      s.autorequire = @autorequire if @autorequire
-      s.author = @author
-      s.email = @email
-      s.rubyforge_project = @project
-      s.homepage = @homepage
-      s.executables = @executables
-      s.require_paths = @require_paths if @require_paths
+      s.require_paths = pkg.require_paths if pkg.require_paths
+
+      s.autorequire = pkg.autorequire if pkg.autorequire
+      s.platform = pkg.platform
+
+      s.executables = pkg.executables
       s.bindir = "bin"
+
       s.has_rdoc = true
     }
 
@@ -239,7 +299,7 @@ class Reap::Package < Reap::Task
     Gem::Builder.new(spec).build
     gems = Dir.glob( './*.gem' )
     gems.each{ |f|
-      FileUtils.mv( f, File.join( @dir, @package_name ) )
+      FileUtils.mv( f, File.join( pkg.dir, pkg.package_name ) )
     }
     #sh %{mv ./*.gem #{@dir}/}
   end
@@ -249,9 +309,11 @@ class Reap::Package < Reap::Task
 
   def run_deb
 
+    use_subsection :deb
+
     # build the debian control file
 
-    dep = dependencies.collect{ |d, v|
+    _dep = pkg.dependencies.collect{ |d, v|
       if v
         "#{d} (#{v})"
       else
@@ -261,31 +323,35 @@ class Reap::Package < Reap::Task
 
     # Some debian fields not yet used:
     # Installed-Size: 1024
-    # Conflicts: wile-e-coyote, ...
     # Replaces: sam-sheepdog
     # Pre-Depends: perl, ...
     # Suggests: docbook
 
     ctrl = %{
-      Package: #{name}
-      Version: #{version}
+      Package: #{pkg.name}
+      Version: #{pkg.version}
       Priority: optional
-      Architecture: #{architecture}
+      Architecture: #{pkg.architecture}
       Essential: no
     }.tabto(0)
-    ctrl << "Section: #{category}" if category
-    ctrl << "Depends: #{dep}" unless dep.empty?
-    ctrl << "Recommends: #{recommends.join(' | ')}" unless recommends.empty?
+    ctrl << "Section: #{pkg.category}" if pkg.category
+    ctrl << "Depends: #{pkg.dep}" unless _dep.empty?
+    ctrl << "Recommends: #{pkg.recommends.join(' | ')}" unless pkg.recommends.empty?
+    ctrl << "Conflicts: #{pkg.conflicts.join(', ')}" unless pkg.conflicts.empty?
     ctrl << %{
-      Maintainer: #{maintainer} [#{email}]
-      Provides: #{name}
-      Description: #{summary}
+      Maintainer: #{pkg.maintainer} [#{pkg.email}]
+      Provides: #{pkg.name}
+      Description: #{pkg.summary}
       .
-      #{description}
+      #{pkg.description}
     }.tabto(0)
 
-    debname = architecture == 'any' ? "ruby_#{name}_#{version}.deb" : "ruby_#{name}_#{version}_#{architecture}.deb"
-    debdir = File.join( @dir, @package_name, 'debian' )
+    if pkg.architecture == 'any'
+      debname = "ruby_#{pkg.name}_#{pkg.version}.deb"
+    else
+      debname = "ruby_#{pkg.name}_#{pkg.version}_#{pkg.architecture}.deb"
+    end
+    debdir = File.join( pkg.dir, pkg.package_name, 'debian' )
     debdebdir = File.join( debdir, 'DEBIAN' )
     debfile = File.join( debdir, debname )
 
@@ -297,4 +363,80 @@ class Reap::Package < Reap::Task
     #sh %{dpkg-deb -b #{debdir} #{debfile}}
   end
 
+
+  # This builds a pacman (archlinux) PKGBUILD script.
+
+  def run_pacman
+
+    use_subsection :pacman
+
+    unless @source
+      puts "URL 'source' is require for proto package."
+      return nil
+    end
+
+#     if section.key?('pac')
+#       _dep = pkg.pac.dependenciers || pkg.dependencies
+#       _rep = pkg.pac.replaces || pkg.replaces
+#       _con = pkg.pac.conflicts || pkg.conflicts
+#     else
+      _dep = pkg.dependencies
+      _rep = pkg.replaces
+      _con = pkg.conflicts
+#     end
+
+    _dep = _dep.collect{ |d| "'#{d}'" }.join(' ')
+    _rep = _rep.collect{ |d| "'#{d}'" }.join(' ')
+    _con = _rep.collect{ |d| "'#{d}'" }.join(' ')
+
+    proto = %{
+      pkgname=#{pkg.name}
+      pkgver=#{pkg.version}
+      pkgrel=#{pkg.series}
+      pkgdesc="#{pkg.summary}"
+      url="#{pkg.homepage}"
+      license="#{pkg.license}"
+      depends=(#{_dep})
+      conflicts=(#{_con})
+      replaces=(#{_rep})
+      source=(#{pkg.source})
+      md5sums=(#{pkg.md5})
+    }.tabto(0)
+
+    # What are these for?
+    # install=
+    # backup=()
+
+    if pkg.usemake
+      s << %{
+        makedepends=()"
+        build() {
+          cd $startdir/src/$pkgname-$pkgver
+          ./ruby setup.rb --prefix=/usr
+          make || return 1
+          make DESTDIR=$startdir/pkg install
+        }
+      }.tabto(0)
+    else
+      s << %{
+        build() {
+          cd $startdir/src/$pkgname-$pkgver
+          ./ruby setup.rb --prefix=/usr
+        }
+      }
+    end
+
+    pacdir = File.join( pkg.dir, pkg.package_name, 'pacman' )
+    pacpacdir = File.join( pacdir, 'PACMAN' )
+    pacfile = File.join( pacdir, 'PKGBUILD' )
+
+    puts "Reap is shelling out work to the pacman..."
+    FileUtils.mkdir_p(pacdir)
+    #sh %{ruby setup.rb all --prefix=#{debdir}}
+    #FileUtils.mkdir_p(pacpacdir)
+    File.open( pacfile, 'w') { |f| f << proto }
+    #sh %{dpkg-deb -b #{debdir} #{debfile}}
+
+  end
+
 end