reap 5.10.10 → 6.0.0

data/lib/reap/class/manifest.rb

@@ -0,0 +1,72 @@
+#--
+#  __  __           _  __        _
+# |  \/  |__ _ _ _ (_)/ _|___ __| |_
+# | |\/| / _` | ' \| |  _/ -_|_-<  _|
+# |_|  |_\__,_|_||_|_|_| \___/__/\__|
+#
+#++
+
+require 'digest/md5'
+
+module Reap
+
+  # = Manifest
+  #
+  # Create a manifest file for the package. Presently it is a very simple
+  # md5 + filename manifest. In the future this will be exanded to build
+  # a varity of manifest formats.
+  #
+  # Task specific settings:
+  #
+  #    include       Files to include
+  #    exclude       Files to exclude
+  #
+
+  class Manifest
+
+    include TaskUtils
+
+    MUST_EXCLUDE = [ 'InstalledFiles', '**/CVS/**/*', '**/*~' ] #, 'dist', 'pkg' ]
+
+    # Note that ++dir++ is not offset by ++trunk++. But ++include++ and ++exclude++ are offset.
+
+    attr_accessor :trunk, :dir, :include, :exclude
+
+    def initialize( man )
+      @dir     = '.'
+      @include = ['**/*']
+      @exclude = []
+
+      super
+
+      @trunk = '.' unless @trunk
+      @exclude |= MUST_EXCLUDE
+    end
+
+    # Generate manifest file.
+
+    def generate #( type=nil )
+      manifest_file = File.join( File.expand_path( @dir ), 'MANIFEST' )
+      package_files = FileList.new
+      Dir.chdir( @trunk ) do
+        package_files.include(*@include)
+        package_files.exclude(*@exclude) #if @exclude and not @exclude.empty?
+        File.open( manifest_file, 'w+') do |f|
+          package_files.each do |pf|
+            f << "#{salt(pf)} #{pf}\n" if File.file?(pf)
+          end
+        end
+      end
+    end
+
+    alias_method :call, :generate
+
+  private
+
+    def salt( file )
+      Digest::MD5.new( File.read( file ) ).hexdigest
+    end
+
+  end
+
+end #module Reap

data/lib/reap/class/package.rb

@@ -0,0 +1,468 @@
+#--
+#  ___         _
+# | _ \__ _ __| |____ _ __ _ ___
+# |  _/ _` / _| / / _` / _` / -_)
+# |_| \__,_\__|_\_\__,_\__, \___|
+#                      |___/
+#++
+
+require 'facet/fileutils/safe_ln.rb'
+require 'facet/filelist.rb' unless defined?( FileList ) # prevent overlap with Rake's
+
+module Reap
+
+  # = Package
+  #
+  # This class creates standard .zip, .tgz, or .tbz
+  # packages, plus .gem or .deb distributions.
+  #
+  # Builds distribution packages. The package task supports
+  # tar.gz, tar.bz2, zip source packages and gem, pacman and
+  # debian ditribution packages.
+  #
+  # Task specific settings:
+  #
+  #   dir             Directory in which to store distributions.
+  #   include         Files to include in distribution.
+  #   exclude         Files to exclude from those.
+  #   distribute      List of distribution types desired.
+  #                     (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.
+  #
+  # RubyGems specific settings:
+  #
+  #   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 they in some way differ. Possible subsections are:
+  #
+  #   gems
+  #   pacman
+  #   debian
+  #
+
+  class Package
+
+    include TaskUtils
+
+    MUST_EXCLUDE = [ 'InstalledFiles', '**/CVS/**/*', '**/*~', 'dist', 'pkg', 'release' ]
+    LOCATIONS = [ 'dist', 'pkg', 'release', 'package', 'distribution' ]
+
+    attr :pkg
+
+    # Setup package task settings.
+
+    def initialize( pkg )
+      @pkg = pkg
+
+      #pkg.name         ||= master.name
+      #pkg.title        ||= master.title
+      #pkg.version      ||= master.version
+      #pkg.project      ||= master.project || master.rubyforge.project
+      #pkg.homepage     ||= master.homepage || master.rubyforge.homepage
+
+      pkg.trunk        ||= '.'  # '.' probably will become the mater default.
+
+      pkg.status       ||= 'development'
+      pkg.series       ||= '1'
+      pkg.author       ||= "Anonymous"
+      pkg.maintainer   ||= pkg.author
+      pkg.email        ||= ''
+      pkg.summary      ||= ''
+      pkg.architecture ||= 'any'
+      pkg.license      ||= 'Ruby/GPL'
+
+      pkg.dir          ||= LOCATIONS.find { |f| File.directory?(f)  } || 'dist'
+      pkg.date         ||= Time.now.strftime("%Y-%m-%d")
+
+      d = pkg.date.split('-').collect{ |e| e.to_i }
+      #d[0] = d[0] - 2000  # No need to keep the 2000
+      pkg.version      ||= d.join('.')
+
+      if $BUILD_VERSION
+        pkg.buildno = Time.now.strftime("%H*60+%M")
+        pkg.version += ".#{pkg.buildno}"
+      end
+
+      pkg.package_name ||= "#{pkg.name}-#{pkg.version}"
+
+      pkg.exclude      ||= []
+      pkg.exclude      |= MUST_EXCLUDE
+
+      pkg.include      ||= ['**/*']
+
+      # distribute types include 'tgz', 'tbz', 'zip', 'tar.gz' 'tar.bz2', 'gem', 'pac' and 'deb'.
+
+      pkg.distribute   ||= [ 'gem', 'tar.bz2', 'zip' ]
+      pkg.distribute = [pkg.distribute].flatten.collect { |t| t.to_s.strip.downcase }
+
+      pkg.dependencies ||= []
+      pkg.executables  ||= []
+      pkg.requirements ||= []
+      pkg.recommends   ||= []
+      pkg.conflicts    ||= []
+      pkg.replaces     ||= []
+
+      # Gem specific
+
+      # load rubygems if available
+      # (only do this if need be in future?)
+      begin
+        require 'rubygems'
+      rescue LoadError
+        # no rubygems
+      end
+
+      if defined?(::Gem) and pkg.gem
+        if pkg.gem.platform
+          begin
+            pkg.gem.platform = ::Gem::Platform.const_get(pkg.gem.platform.upcase)
+          rescue NameError
+            pkg.gem.platform = ::Gem::Platform::RUBY
+          end
+        else
+          pkg.gem.platform = ::Gem::Platform::RUBY
+        end
+        #@autorequire
+      end
+    end
+
+    # Generate packages.
+
+    def generate_packages
+
+      release_folder = File.join( pkg.dir, pkg.package_name )
+      mirror_folder = File.join( pkg.dir, pkg.package_name, pkg.package_name )
+
+      @release_path = File.expand_path( release_folder )
+      @mirror_path = File.expand_path( mirror_folder )
+
+      if FileTest.directory?(release_folder)
+        if $FORCE
+          puts "Removing old directory '#{File.expand_path(release_folder)}'..."
+          FileUtils.rm_r(release_folder)
+        else
+          puts "Package directory '#{pkg.package_name}' already exists. Use -f option to overwrite."
+          return nil
+        end
+      end
+
+      puts "Creating #{pkg.distribute.join(',')} packages..."
+
+      # First we make a copy of the files to be distributed.
+
+      FileUtils.mkdir_p( mirror_folder ) #pkg.dir #rescue nil
+      @package_files = nil
+      Dir.chdir( pkg.trunk ) do
+        @package_files = ::FileList.new(*pkg.include)
+        #package_files.include(*pkg.include)
+        @package_files.exclude(*pkg.exclude) if pkg.exclude #and not pkg.exclude.empty?
+        @package_files.resolve # reslove FileList here to be sure we get the right files!
+
+        @package_files.each do |f|
+          from = f #pkg.trunk ? File.join( pkg.trunk, f ) : f
+          to = File.join( @mirror_path, f )
+          to_dir = File.dirname( to )
+          FileUtils.mkdir_p( to_dir ) if not File.exist?(to_dir)
+          if File.directory?( from )
+            FileUtils.mkdir_p( to )
+          else
+            FileUtils.rm_f( to )
+            FileUtils.safe_ln( from, to )
+          end
+        end
+      end
+
+      # Now we create standard packages from the copy.
+
+      FileUtils.chdir( @release_path ) do
+        pkg.distribute.each do |t|
+          sh_cmd = nil
+          prefix = 'ERROR' # in case of unforseen bug
+          case t
+          when 'tbz', 'bz2', 'bzip2', 'tar.bz2'
+            prefix = ( t == 'tbz' ? 'tbz' : 'tar.bz2' )
+            sh_cmd = 'tar --bzip2 -cvf'
+            puts "\n[SHELL #{prefix.upcase}]"
+          when 'tgz', 'tar.gz'
+            prefix = ( t == 'tgz' ? 'tgz' : 'tar.gz' )
+            sh_cmd = 'tar --gzip -cvf'
+            puts "\n[SHELL #{prefix.upcase}]"
+          when 'zip'
+            prefix = 'zip'
+            sh_cmd = 'zip -r'
+            puts "\n[SHELL #{prefix.upcase}]"
+          when 'gem', 'deb', 'pac'
+            sh_cmd = nil
+          else
+            puts "WARNING: Unknown package type '#{t}' skipped"
+            sh_cmd = nil
+          end
+          sh %{#{sh_cmd} #{pkg.package_name}.#{prefix} #{pkg.package_name}} if sh_cmd
+        end
+        puts
+      end
+
+      # create gem package
+
+      if pkg.distribute.include?('gem')
+        if defined?(::Gem)
+          run_gem
+        else
+          tell "WARNING: Package .gem requested, but rubygems not found (skipped)."
+        end
+      end
+
+      # create debian package
+
+      if pkg.distribute.include?('deb')
+        if true # TODO ensure required debian tools here
+          run_deb
+        else
+          tell "WARNING: Package .deb requested, but debian tools not found (skipped)."
+        end
+      end
+
+      # create PKGBUILD (pacman, archlinux)
+
+      if pkg.distribute.include?('pac')
+        if true # TODO ensure required tools here
+          run_pacman
+        else
+          tell "WARNING: Pacman package requested, but required tools not found (skipped)."
+        end
+      end
+
+      # we can remove mirror folder now
+
+      #FileUtils.rm_r(mirror_folder)
+
+      return true
+    end
+
+  private
+
+    # This builds the gem package.
+
+    def run_gem
+
+      # use subsection if given
+      if pkg.gem
+        pkg = pkg().__merge__( pkg.gem )
+      else
+        pkg = pkg()
+      end
+
+      spec = Gem::Specification.new { |s|
+        s.name = pkg.name
+        s.version = pkg.version
+
+        pkg.dependencies.each { |d,v|
+          if v
+            s.add_dependency(d, v)
+          else
+            s.add_dependency(d)
+          end
+        }
+
+        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(*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.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
+      }
+
+      tell "[RUBYGEMS]"
+
+      Dir.chdir( @mirror_path ) {
+        Gem.manage_gems
+        Gem::Builder.new(spec).build
+        gems = Dir.glob( './*.gem' )
+        gems.each{ |f| FileUtils.mv( f, @release_path ) }
+      }
+
+      puts
+    end
+
+    # This build the Debiam package.
+
+    def run_deb
+
+      # use subsection if given
+      if pkg.debian
+        pkg = pkg().__merge__( pkg.debian )
+      else
+        pkg = pkg()
+      end
+
+      # build the debian control file
+
+      dep = pkg.dependencies.collect{ |d, v|
+        if v
+          "#{d} (#{v})"
+        else
+          d
+        end
+      }.join(', ')
+
+      # Some debian fields not yet used:
+      # Installed-Size: 1024
+      # Replaces: sam-sheepdog
+      # Pre-Depends: perl, ...
+      # Suggests: docbook
+
+      arch = pkg.architecture.downcase
+      arch = (arch == 'any' ? 'all' : arch)
+
+      ctrl = %{
+        Package: #{pkg.name}
+        Version: #{pkg.version}
+        Priority: optional
+        Architecture: #{arch}
+        Essential: no
+      }.tabto(0)
+      ctrl << "Section: #{pkg.category}\n" if pkg.category
+      ctrl << "Depends: #{dep}\n" unless dep.empty?
+      ctrl << "Recommends: #{pkg.recommends.join(' | ')}\n" unless pkg.recommends.empty?
+      ctrl << "Conflicts: #{pkg.conflicts.join(', ')}\n" unless pkg.conflicts.empty?
+      ctrl << "Maintainer: #{pkg.maintainer} <#{pkg.email}>\n"
+      ctrl << "Provides: #{pkg.name}\n"
+      ctrl << "Description: #{pkg.summary}\n"
+      ctrl << " #{pkg.description}\n"
+
+      if arch == 'all'
+        debname = "#{pkg.name}-ruby_#{pkg.version}.deb"
+      else
+        debname = "#{pkg.name}-ruby_#{pkg.version}_#{pkg.architecture}.deb"
+      end
+      pkgdir = @release_path #File.join( pkg.dir, pkg.package_name )
+      debdir = File.join( pkgdir, 'debian' )
+
+      #debdebdir = File.join( debdir, 'DEBIAN' )
+      debfile = File.join( pkgdir, debname )
+
+      puts "[SHELL DEB]"
+
+      FileUtils.mkdir_p(debdir)
+
+      Dir.chdir( @mirror_path ) do
+        unless provide_setup_rb
+          puts "Setup.rb is missing. Forced to skip debian package creation."
+          return nil
+        end
+
+        cmd = %{ruby setup.rb }
+        cmd << '-q ' unless $VERBOSE
+        cmd << %{all --installdirs=std --root=#{debdir}}
+
+        sh cmd
+
+        FileUtils.mkdir_p( File.join(debdir, 'DEBIAN') )
+        File.open( File.join(debdir, 'DEBIAN', 'control'), 'w') { |f| f << ctrl }
+
+        sh %{dpkg-deb -b #{debdir} #{debfile}}
+      end
+
+      puts
+    end
+
+    # This builds a pacman (archlinux) PKGBUILD script.
+
+    def run_pacman
+      # use subsection if it exists
+      if pkg.pacman
+        pkg = pkg().__merge__( pkg.pacman )
+      else
+        pkg = pkg()
+      end
+
+      unless pkg.source
+        tell "SOURCE, a URL to the source package, is a required field"
+        return nil
+      end
+
+      _dep = pkg.dependencies.collect{ |d| "'#{d}'" }.join(' ')
+      _rep = pkg.replaces.collect{ |d| "'#{d}'" }.join(' ')
+      _con = pkg.conflicts.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
+        proto << %{
+          makedepends=()"
+          build() {
+            cd $startdir/src/$pkgname-$pkgver
+            ./ruby setup.rb --prefix=/usr
+            make || return 1
+            make DESTDIR=$startdir/pkg install
+          }
+        }.tabto(0)
+      else
+        proto << %{
+          build() {
+            cd $startdir/src/$pkgname-$pkgver
+            ./ruby setup.rb --prefix=/usr
+          }
+        }.tabto(0)
+      end
+
+      pacdir = File.join( @release_path, 'pacman' )
+      #pacpacdir = File.join( pacdir, 'PACMAN' )
+      pacfile = File.join( pacdir, 'PKGBUILD' )
+
+      tell "[PACMAN PKGBUILD]"
+      FileUtils.mkdir_p( pacdir )
+      File.open( pacfile, 'w') { |f| f << proto }
+      tell "Created #{pacfile}"
+      puts
+    end
+
+  end #class Package
+
+end #module Reap