reap 5.0.0 → 5.10.10

data/lib/reap/task/fileperm.rb

@@ -1,40 +1,27 @@
 
-# NOTE This task needs work!
-#      It needs to generalize more to give greater control
-#      over which files get what permissions.
-#      It also might be extended to do copyright tagging.
-
 require 'reap/task'
 
-#  ___               _       _               _____        _
-# | _ \___ _ _ _ __ (_)_____(_)___ _ _  ___ |_   _|_ _ __| |__
-# |  _/ -_) '_| '  \| (_-<_-< / _ \ ' \(_-<   | |/ _` (_-< / /
-# |_| \___|_| |_|_|_|_/__/__/_\___/_||_/__/   |_|\__,_/__/_\_\
 #
-
-# = File Permissions Task
-
+# File Permissions Task
+#
 class Reap::Perm < Reap::Task
 
-  task_desc "Normalize ownership and permissions of files."
-
-  task_help %{
+  attr_accessor :user, :group, :filemod, :dirmod
 
-    Normalizes file permissions.
+  section_required true
 
-      user          user name to use
-      group         group name to use
-
-  }
+  def task_desc
+    "Normalize ownership and permissions of package files."
+  end
 
-  task_attr :perm
+  def init
+    @user = section['user']
+    @group   ||= @user
+    @filemod ||= 644
+    @dirmod  ||= 755
+  end
 
   def run
-
-    perm.group   ||= perm.user
-    perm.filemod ||= 644
-    perm.dirmod  ||= 755
-
     puts "Reap is shelling out work to chmod..."
 
     # misc
@@ -68,15 +55,11 @@ class Reap::Perm < Reap::Task
     dirs, files = file_list.partition{ |l| File.directory?(l) }
     unless files.empty?
       fstr = '"' + files.join('" "') + '"'
-      #sh %{chmod #{file_mode} #{fstr}}
-      tell %{chmod #{file_mode} #{fstr}}
-      File.chmod( file_mode, fstr ) unless $PRETEND
+      sh %{chmod #{file_mode} #{fstr}}
     end
     unless dirs.empty?
       fstr = '"' + dirs.join('" "') + '"'
-      #sh %{chmod #{dir_mode} #{fstr}}
-      tell %{chmod #{dir_mode} #{fstr}}
-      File.chmod( dir_mode, fstr ) unless $PRETEND
+      sh %{chmod #{dir_mode} #{fstr}}
     end
   end
 
@@ -96,17 +79,4 @@ class Reap::Perm < Reap::Task
 
 end
 
-
-# Rake interface.
-
-if defined?(Rake)
-
-  #require 'reap/rake/adapter'
-
-  module Rake
-    ReapPerm = ::Reap::RakeAdapter( ::Reap::Perm )
-  end
-
-end
-
-
+#Reap.register( Reap::Perm )

data/lib/reap/task/info.rb

@@ -1,46 +1,20 @@
 
 require 'reap/task'
 
-#  ___       __       _____        _
-# |_ _|_ _  / _|___  |_   _|_ _ __| |__
-#  | || ' \|  _/ _ \   | |/ _` (_-< / /
-# |___|_||_|_| \___/   |_|\__,_/__/_\_\
 #
-
-# = Info Task
+# Info Task - Displays the ProjectInfo file.
 #
-# Displays the ProjectInfo file.
-
 class Reap::Info < Reap::Task
 
-  task_desc "Display ProjectInfo file."
-
-  task_help %{
-
-    reap info
-
-    Display ProjectInfo file.
-
-  }
-
-  task_available { |app| app.projectfile? }
-
-  def run
-    puts ProjectInfo.instance.info_stream
+  def task_desc
+    "Display ProjectInfo file."
   end
 
-end
-
-
-# Rake interface.
-
-if defined?(Rake)
-
-  #require 'reap/rake/adapter'
+  def init
+  end
 
-  module Rake
-    ReapInfo = ::Reap::RakeAdapter( ::Reap::Info )
+  def run
+    puts ProjectInfo.info_stream
   end
 
 end
-

data/lib/reap/task/install.rb

@@ -1,68 +1,33 @@
-#!/usr/bin/env ruby
 
 require 'reap/task'
 
-#  ___           _        _ _   _____         _
-# |_ _|_ __  ___| |_ __ _| | | |_   _|_ _ ___| | __
-#  | || '_ \/ __| __/ _` | | |   | |/ _` / __| |/ /
-#  | || | | \__ \ || (_| | | |   | | (_| \__ \   <
-# |___|_| |_|___/\__\__,_|_|_|   |_|\__,_|___/_|\_\
 #
-
+# Install Task
+#
 class Reap::Install < Reap::Task
 
-  task_desc "Locally install package using built-in setup.rb."
-
-  task_help %{
-
-    reap install
-
-    This task manually installs a project using setup.rb.
-    If setup.rb doesn't exist it will be created.
-
-  }
-
-  task_attr :ins
-
-  def run
-
-    ins.options ||= []
-
-    #exe = %w{ setup.rb install.rb }.find{ |f| File.exists?(f) }
-    #raise "setup.rb or install.rb not found" if exe == nil
-
-    unless provide_setup_rb
-      puts "Setup.rb is missing. Forced to skip debian package creation."
-      return nil
-    end
-
-    puts "Reap is shelling out work to setup.rb..."
-
-    #--
-    # SHELL OUT! This will be fixed with swtich to package.rb instead of setup.rb.
-    #++
-
-    exe = %{ruby setup.rb}
-    exe << ' -q ' unless $VERBOSE
-    exe << ins.options.join(' ')
-    exe << ' all'
-    sh exe
-
-    puts "Setup complete!"
+  def task_desc
+    "Locally install package using setup.rb or install.rb."
   end
 
-end
+  attr_accessor :options, :quiet #, :sudo
 
+  def init
+    @quiet   ||= !$VERBOSE
+    @options ||= []
+    #@sudo   ||= true
+  end
 
-# Rake interface.
+  def run
+    exe = %w{ setup.rb install.rb }.find{ |f| File.exists?(f) }
+    raise "setup.rb or install.rb not found" if exe == nil
 
-if defined?(Rake)
+    puts "Reap is shelling out work to #{exe}..."
 
-  #require 'reap/rake/adapter'
+    options << '-q' if @quiet
 
-  module Rake
-    ReapInstall = ::Reap::RakeAdapter( ::Reap::Install )
+    c = "sudo ruby #{exe} #{options.join(' ')}"
+    sh c
   end
 
 end
-

data/{task → lib/reap/task}/noop.rb

@@ -1,7 +1,7 @@
-#!/usr/bin/env ruby
 
 require 'reap/task'
 
+#
 # Noop Task
 #
 # This task doesn't do anything except
@@ -10,12 +10,17 @@ require 'reap/task'
 #
 class Reap::Noop < Reap::Task
 
-  task_desc "A no-op task to help debug reap itself."
+  def task_desc
+    "A no-op task to help debug reap itself."
+  end
+
+  attr_accessor :message
 
-  task_attr :msg
+  def init
+  end
 
   def run
-    puts ( msg.message || 'No message field in noop section.' )
+    puts ( message || 'No message field in noop section.' )
   end
 
 end

data/lib/reap/task/package.rb

@@ -1,173 +1,110 @@
 
 require 'reap/task'
 
-#  ___         _                   _____        _
-# | _ \__ _ __| |____ _ __ _ ___  |_   _|_ _ __| |__
-# |  _/ _` / _| / / _` / _` / -_)   | |/ _` (_-< / /
-# |_| \__,_\__|_\_\__,_\__, \___|   |_|\__,_/__/_\_\
-#                      |___/
+begin
+  require 'rubygems'
+rescue
+  # no rubygems
+end
 
-# = Package Task
+##
+# Package Task
 #
 # This task creates standard .zip, .tgz, or .tbz
-# packages, plus .gem or .deb distributions.
-
-
+# packages, plus .gem distributions.
+#
 class Reap::Package < Reap::Task
 
-  MUST_EXCLUDE = [ 'InstalledFiles', '**/CVS/**/*', '**/*~', 'dist', 'pkg' ]
-  LOCATIONS = [ 'dist', 'pkg', '../packages', '../dist', '../pkg' ]
-
-  #section_required true
-
-  # Task line description
-
-  task_desc "Create distribution packages."
-#     if master.package
-#       disttypes = master.package.distribute || master.distribute || [ 'gem', 'tar.bz2', 'zip' ]
-#     else
-#       disttypes = master.distribute || [ 'gem', 'tar.bz2', 'zip' ]
-#     end
-#     "Build distribution packages (#{disttypes.join(', ')})."
-#   end
-
-  # 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.
-
-                      These are RubyGems specific.
-      autorequire
-      platform
-      require_paths
+  attr_accessor :dir, :name, :date, :series, :status,
+                :author, :email, :summary, :project, :homepage,
+                :exclude, :types, :platform, :autorequire,
+                :dependencies, :requirements, :executables
 
-    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:
+  attr_reader :package_name, :include
 
-      gems
-      pacman
-      debian
+  MUST_EXCLUDE = [ 'InstalledFiles', '**/CVS/**/*', '**/*~' ]
 
-  }
-
-  # Alternate for task properties accessor.
+  def task_desc
+    "Build distribution packages (#{(types||[]).join(', ')})."
+  end
 
-  task_attr :pkg
+  def init
+    @dir          ||= ( File.directory?('../leaf') ? '../leaf' : 'pkg')
 
-  def run
+    @name         ||= master['name']
+    @status       ||= master['status'] || 'beta/stable'
+    @date         ||= master['date'] || Time.now.strftime("%Y-%m-%d")
 
-    # load rubygems if available
-    # (only do this if need be in future?)
+    @series       ||= master['series']
+    @version      ||= master['version']
 
-    begin
-      require 'rubygems'
-    rescue LoadError
-      # no rubygems
+    unless @series || @version
+      puts "Series or Version is a required field."
+      exit 0
     end
 
-    # setup package defaults
-
-    # Do not look in master information for this
-    pkg.dir = section.dir || LOCATIONS.find { |f| File.directory?(f)  } || 'dist'
-
-    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
-    pkg.version      ||= d.join('.')
-
-    if $BUILD_VERSION
-      pkg.buildno = Time.now.strftime("%H*60+%M")
-      pkg.version += ".#{pkg.buildno}"
+    if @version
+      @package_name ||= @name + '-' + @version
+    else
+      @package_name ||= @name + ',' + @date
     end
 
-    pkg.package_name ||= "#{pkg.name}-#{pkg.version}"
-
-    pkg.exclude      ||= []
-    pkg.exclude      |= MUST_EXCLUDE
-
-    pkg.include      ||= ['**/*']
+    @author       ||= master['author']
+    @email        ||= master['email']
+    @summary      ||= master['summary']
+    @project      ||= master['rubyforge']['project']
+    @homepage     ||= master['homepage'] || master['rubyforge']['homepage']
 
-    # distribute types include 'tgz', 'tbz', 'zip', 'tar.gz' 'tar.bz2', 'gem', 'pac' and 'deb'.
+    @exclude      ||= []
+    @exclude      |= MUST_EXCLUDE
 
-    pkg.distribute   ||= [ 'gem', 'tar.bz2', 'zip' ]
-    pkg.distribute = [pkg.distribute].flatten.collect { |t| t.to_s.strip.downcase }
+    # types include 'tgz', 'tbz', 'zip', 'tar.gz' 'tar.bz2' and 'gem'.
+    @types        ||= master['distribute'] || [ 'gem', 'tar.gz', 'zip' ]
+    @types.collect! { |t| t.to_s.strip.downcase }
 
-    pkg.dependencies ||= []
-    pkg.executables  ||= []
-    pkg.requirements ||= []
-    pkg.recommends   ||= []
-    pkg.conflicts    ||= []
-    pkg.replaces     ||= []
+    # not setable
+    @include      ||= ['**/*']
 
-    # Gem specific properties
-
-    if defined?(::Gem) and pkg.gem
-      if pkg.gem.platform
+    # gem specific (at least in this context)
+    if defined?(Gem)
+      if @platform
         begin
-          pkg.gem.platform = ::Gem::Platform.const_get(pkg.gem.platform.upcase)
+          @gem_platform = ::Gem.const_get(@platform)
         rescue NameError
-          pkg.gem.platform = ::Gem::Platform::RUBY
+          @platform = nil
         end
-      else
-        pkg.gem.platform = ::Gem::Platform::RUBY
       end
+      @platform = ::Gem::Platform::RUBY unless @plaform
       #@autorequire
+      @requirements ||= master['requirements'] || []
+      @dependencies ||= master['dependencies'] || []
+      @executables  ||= master['executables']  || []
     end
+  end
 
-    # package it up
-
-    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)
-      if $FORCE
-        puts "Removing old directory '#{File.expand_path(group_dir_path)}'..."
-        FileUtils.rm_r(group_dir_path)
+  def run
+    # create package image
+    package_dir_path = "#{@dir}/#{@package_name}"
+
+    if FileTest.directory?(package_dir_path)
+      print "Package '#{package_name}' 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(package_dir_path)}'..."
+        FileUtils.rm_r(package_dir_path)
+        #FileUtils.rm("#{package_dir_path}/*")
+        #trash_dir = ".trash/#{File.basename(@dir)}"
+        #FileUtils.mkdir_p(".trash") unless FileTest.directory?(".trash")
+        #FileUtils.mv(@dir, trash_dir)
       else
-        puts "Package directory '#{pkg.package_name}' already exists. Use -f option to overwrite."
-        return nil
+        puts "Reap package task canceled."
+        exit 0
       end
     end
-
-    puts "Creating #{pkg.distribute.join(',')} packages..."
-
     package_files = FileList.new
-    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.include(*@include)
+    package_files.exclude(*@exclude) if @exclude and not @exclude.empty?
+    FileUtils.mkdir_p @dir #rescue nil
     package_files.each do |f|
       pkgf = File.join(package_dir_path, f)
       fdir = File.dirname(pkgf)
@@ -181,8 +118,8 @@ class Reap::Package < Reap::Task
     end
 
     # create standard package files
-    FileUtils.chdir( File.join( pkg.dir, pkg.package_name ) ) do
-      pkg.distribute.each do |t|
+    FileUtils.chdir(@dir) do
+      @types.each do |t|
         sh_cmd = nil
         prefix = 'ERROR' # in case of unforseen bug
         case t
@@ -198,63 +135,37 @@ class Reap::Package < Reap::Task
           prefix = 'zip'
           sh_cmd = 'zip -r'
           puts "\nReap is shelling out work to zip..."
-        when 'gem', 'deb', 'pac'
+        when 'gem'
           sh_cmd = nil
         else
           puts "Unknown package type '#{t}' skipped."
           sh_cmd = nil
         end
-        sh %{#{sh_cmd} #{pkg.package_name}.#{prefix} #{pkg.package_name}} if sh_cmd
+        sh %{#{sh_cmd} #{@package_name}.#{prefix} #{@package_name}} if sh_cmd
       end
       puts
     end
 
     # create gem package
-
-    if pkg.distribute.include?('gem')
-      if defined?(::Gem)
-        run_gem
-      else
-        tell "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 "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 "Pacman package requested, but required tools not found (skipped)."
-      end
-    end
+    run_gem if defined?(Gem) and @types.include?('gem')
 
     return true
   end
 
-private
-
-  # This builds the gem package.
-
   def run_gem
-
-    use_subsection :gems
-
     spec = Gem::Specification.new { |s|
-      s.name = pkg.name
-      s.version = pkg.version
 
-      pkg.dependencies.each { |d,v|
+      s.name = @name
+ 
+      if @version
+        s.version = @version
+      else
+        d = @date.split('-').collect{ |e| e.to_i }
+        d[0] = d[0] - 2000
+        s.version = d.join('.')
+      end
+
+      @dependencies.each{ |d,v|
         if v
           s.add_dependency(d, v)
         else
@@ -262,189 +173,32 @@ private
         end
       }
 
-      s.summary = pkg.summary
-      s.requirements = pkg.requirements
+      s.platform = @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(*pkg.include)
-      package_files.exclude(*pkg.exclude) if pkg.exclude and not pkg.exclude.empty?
+      package_files.include(*@include)
+      package_files.exclude(*@exclude) if @exclude and not @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.autorequire = @autorequire if @autorequire
+      s.author = @author
+      s.email = @email
+      s.rubyforge_project = @project
+      s.homepage = @homepage
+      s.executables = @executables
       s.bindir = "bin"
 
-      s.has_rdoc = true
     }
 
-    tell "Reap is shelling out work to the Gem Package Manager..."
+    puts "Reap is shelling out work to the Gem Package Manager..."
     Gem.manage_gems
     Gem::Builder.new(spec).build
-    gems = Dir.glob( './*.gem' )
-    gems.each{ |f|
-      FileUtils.mv( f, File.join( pkg.dir, pkg.package_name ) )
-    }
-    puts
-  end
-
-
-  # This build the Debiam package.
-
-  def run_deb
-
-    use_subsection :debian
-
-    # 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 = File.join( pkg.dir, pkg.package_name )
-    debdir = File.join( pkgdir, 'debian' )
-
-    #debdebdir = File.join( debdir, 'DEBIAN' )
-    debfile = File.join( pkgdir, debname )
-
-    unless provide_setup_rb
-      puts "Setup.rb is missing. Forced to skip debian package creation."
-      return nil
-    end
-
-    puts "Reap is shelling out work to the deb-pkg..."
-
-    cmd = %{ruby setup.rb }
-    cmd << '-q ' unless $VERBOSE
-    cmd << %{all --installdirs=std --root=#{debdir}}
-
-    FileUtils.mkdir_p(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}}
-    puts
-  end
-
-  # This builds a pacman (archlinux) PKGBUILD script.
-
-  def run_pacman
-
-    use_subsection :pacman
-
-    unless @source
-      tell "URL 'source' is require for proto package."
-      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
-      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' )
-
-    tell "Reap is shelling out work to the pacman..."
-    FileUtils.mkdir_p(pacdir)
-    File.open( pacfile, 'w') { |f| f << proto }
-    puts
-  end
-
-end
-
-
-# Rake interface.
-
-if defined?(Rake)
-
-  module Rake
-    ReapPackage = ::Reap::RakeAdapter( ::Reap::Package )
+    sh %{mv ./*.gem #{@dir}/}
   end
 
 end
-