raven 1.0

data/lib/raven/gem_init.rb

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+
+#  Copyright 2006 Matthieu Riou
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require 'rubygems'
+require 'fileutils'
+
+module Gem
+  # Adding Gems Java platform
+  module Platform
+    JAVA = 'java'
+  end
+  
+  # Unfortunately Maven artifacts have a rather free versioning scheme
+  class Version
+    def self.correct?(str)
+      true
+    end
+  end
+end
+
+begin
+  Gem.manage_gems
+rescue NoMethodError => ex
+  # Using rubygems prior to 0.6.1
+end
+
+# Let the user add or redefine his sources (hopefully we'll be
+# able to set a default one when a good soul will be able to
+# donate us space and bandwidth to host a Raven Gems repository).
+module Gem
+  def self.sources=(s) 
+    @sources = s
+  end 
+end
+require_gem("sources")
+def sources; Gem.sources; end
+def set_sources(s) Gem.sources = s; end
+set_sources(["http://localhost:2233"])
+
+# To avoid polluting the regular Gem repository, we store our gems 
+# under the user home directory.
+GEMS_IN_HOME = true
+USER_HOME = ENV['HOME'] ? ENV['HOME'] : ENV['USERPROFILE']
+FileUtils.mkdir(USER_HOME + '/.raven_gems') unless File.exist?(USER_HOME + '/.raven_gems')
+Dir.glob(USER_HOME + "/.raven_gems/specifications/*.gemspec").each do |file_name|
+  gemspec = Gem::SourceIndex.load_specification(file_name.untaint)
+  Gem::cache.add_spec(gemspec) if gemspec
+end
+
+module Gem
+  # Making the remote installer silent. Otherwise it always asks you to 
+  # choose the version you want to install.
+  class RemoteInstaller
+    def find_gem_to_install(gem_name, version_requirement, caches)
+      specs_n_sources = []
+      caches.each do |source, cache|
+        cache.each do |name, spec|
+          if /^#{gem_name}$/i === spec.name &&
+             version_requirement.satisfied_by?(spec.version) then
+            specs_n_sources << [spec, source]
+          end
+        end
+      end
+      if specs_n_sources.empty? then
+        raise GemNotFoundException.new("Could not find #{gem_name} (#{version_requirement}) in the repository")
+      end
+      specs_n_sources = specs_n_sources.sort_by { |gs,| gs.version }.reverse
+      specs_n_sources[0]
+    end
+  end
+end

data/lib/raven/index_gem_repository.rb

@@ -0,0 +1,284 @@
+#!/usr/bin/env ruby
+
+# This file has been copied from the RubyGems distribution and
+# included in Raven for users convenience. See the RubyGems
+# site for license and more.
+
+#
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#
+
+
+# Generate the yaml/yaml.Z index files for a gem server directory.
+#
+# Usage:  generate_yaml_index.rb --dir DIR [--verbose]
+
+$:.unshift '~/rubygems' if File.exist? "~/rubygems"
+
+require 'optparse'
+require 'rubygems'
+require 'zlib'
+require 'digest/sha2'
+
+Gem.manage_gems
+
+######################################################################
+# Mixin that provides a +compress+ method for compressing files on
+# disk.
+#
+module Compressor
+  # Compress the given file.
+  def compress(filename, ext="rz")
+    File.open(filename + ".#{ext}", "w") do |file|
+      file.write(zip(File.read(filename)))
+    end
+  end
+
+  # Return a compressed version of the given string.
+  def zip(string)
+    Zlib::Deflate.deflate(string)
+  end
+
+  # Return an uncompressed version of a compressed string.
+  def unzip(string)
+    Zlib::Inflate.inflate(string)
+  end
+end
+
+######################################################################
+# Announcer provides a way of announcing activities to the user.
+#
+module Announcer
+  # Announce +msg+ to the user.
+  def announce(msg)
+    puts msg if @options[:verbose]
+  end
+end
+
+######################################################################
+# Abstract base class for building gem indicies.  Uses the template
+# pattern with subclass specialization in the +begin_index+,
+# +end_index+ and +cleanup+ methods.
+#
+class AbstractIndexBuilder
+  include Compressor
+  include Announcer
+
+  # Build a Gem index.  Yields to block to handle the details of the
+  # actual building.  Calls +begin_index+, # +end_index+ and +cleanup+
+  # at appropriate times to customize basic operations.
+  def build
+    if ! @enabled
+      yield
+    else
+      unless File.exist?(@directory)
+	FileUtils.mkdir_p(@directory)
+      end
+      fail "not a directory: #{@directory}" unless File.directory?(@directory)
+      File.open(File.join(@directory, @filename), "w") do |file|
+	@file = file
+	start_index
+	yield
+	end_index
+      end
+      cleanup
+    end
+  ensure
+    @file = nil
+  end
+
+  # Called immediately before the yield in build.  The index file is
+  # open and availabe as @file.
+  def start_index
+  end
+
+  # Called immediately after the yield in build.  The index file is
+  # still open and available as @file.
+  def end_index
+  end
+
+  # Called from within builder after the index file has been closed.
+  def cleanup
+  end
+end
+
+######################################################################
+# Construct the master Gem index file.
+#
+class MasterIndexBuilder < AbstractIndexBuilder
+  def initialize(filename, options)
+    @filename = filename
+    @options = options
+    @directory = options[:directory]
+    @enabled = true
+  end
+
+  def start_index
+    super
+    @file.puts "--- !ruby/object:Gem::Cache"
+    @file.puts "gems:"
+  end
+
+  def cleanup
+    super
+    index_file_name = File.join(@directory, @filename)
+    compress(index_file_name, "Z")
+    # Sometimes being paranoid isn't that good: there's a bug on Windows causing
+    # the failing of unzip.
+    # paranoid(index_file_name, "#{index_file_name}.Z")
+  end
+
+  def add(spec)
+    @file.puts "  #{spec.full_name}: #{nest(spec.to_yaml)}"
+  end
+
+  def nest(yaml_string)
+    yaml_string[4..-1].gsub(/\n/, "\n    ")
+  end
+
+  private
+
+  def paranoid(fn, compressed_fn)
+    data = File.read(fn)
+    compressed_data = File.read(compressed_fn)
+    if data != unzip(compressed_data)
+      fail "Compressed file #{compressed_fn} does not match uncompressed file #{fn}"
+    end
+  end
+end
+
+######################################################################
+# Construct a quick index file and all of the individual specs to
+# support incremental loading.
+#
+class QuickIndexBuilder < AbstractIndexBuilder
+  def initialize(filename, options)
+    @filename = filename
+    @options = options
+    @directory = options[:quick_directory]
+    @enabled = options[:quick]
+  end
+
+  def cleanup
+    compress(File.join(@directory, @filename))
+  end
+
+  def add(spec)
+    return unless @enabled
+    @file.puts spec.full_name
+    fn = File.join(@directory, "#{spec.full_name}.gemspec.rz")
+    File.open(fn, "w") do |gsfile|
+      gsfile.write(zip(spec.to_yaml))
+    end
+  end
+end
+
+######################################################################
+# Top level class for building the repository index.  Initialize with
+# an options hash and call +build_index+.
+#
+class Indexer
+  include Compressor
+  include Announcer
+
+  # Create an indexer with the options specified by the options hash.
+  def initialize(options)
+    @options = options.dup
+    @directory = @options[:directory]
+    @options[:quick_directory] = File.join(@directory, "quick")
+    @master_index = MasterIndexBuilder.new("yaml", @options)
+    @quick_index = QuickIndexBuilder.new("index", @options)
+  end
+
+  # Build the index.
+  def build_index
+    announce "Building Server Index"
+    FileUtils.rm_r(@options[:quick_directory]) rescue nil
+    @master_index.build do
+      @quick_index.build do 
+	gem_file_list.each do |gemfile|
+	  spec = Gem::Format.from_file_by_path(gemfile).spec
+	  abbreviate(spec)	  
+	  announce "   ... adding #{spec.full_name}"
+	  @master_index.add(spec)
+	  @quick_index.add(spec)
+	end
+      end
+    end
+  end
+
+  # List of gem file names to index.
+  def gem_file_list
+    Dir.glob(File.join(@directory, "gems", "*.gem"))
+  end
+
+  # Abbreviate the spec for downloading.  Abbreviated specs are only
+  # used for searching, downloading and related activities and do not
+  # need deployment specific information (e.g. list of files).  So we
+  # abbreviate the spec, making it much smaller for quicker downloads.
+  def abbreviate(spec)
+    spec.files = []
+    spec.test_files = []
+    spec.rdoc_options = []
+    spec.extra_rdoc_files = []
+    spec.cert_chain = []
+    spec
+  end
+end
+
+######################################################################
+# Top Level Functions 
+######################################################################
+
+def handle_options(args)
+  # default options
+  options = {
+    :directory => '.',
+    :verbose => false,
+    :quick => true,
+  }
+  
+  args.options do |opts|
+    opts.on_tail("--help", "show this message") do
+      puts opts
+      exit
+    end
+    opts.on(
+      '-d', '--dir=DIRNAME', '--directory=DIRNAME',
+      "repository base dir containing gems subdir",
+      String) do |value|
+      options[:directory] = value
+    end
+    opts.on('--[no-]quick', "include quick index") do |value|
+      options[:quick] = value
+    end
+    opts.on('-v', '--verbose', "show verbose output") do |value|
+      options[:verbose] = value
+    end
+    opts.on('-V', '--version',
+      "show version") do |value|
+      puts Gem::RubyGemsVersion
+      exit
+    end
+    opts.parse!
+  end
+  
+  if options[:directory].nil?
+    puts "Error, must specify directory name. Use --help"
+    exit
+  elsif ! File.exist?(options[:directory]) ||
+      ! File.directory?(options[:directory])
+    puts "Error, unknown directory name #{directory}."
+    exit
+  end
+  options
+end
+
+# Main program.
+def main_index(args)
+  options = handle_options(args)
+  Indexer.new(options).build_index
+end
+

data/lib/raven/java_tasks.rb

@@ -0,0 +1,399 @@
+#!/usr/bin/env ruby
+
+#  Copyright 2006 Matthieu Riou
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require 'rake'
+require 'fileutils'
+require 'set'
+
+# Monkey patching FileUtils to support filtering in copy.
+module FileUtils
+  class Entry_
+    alias original copy
+    def copy(dest)
+      unless path['.svn'] || path['.cvs']
+        original(dest)
+      end
+    end
+  end
+end
+
+module Raven
+  CP_SEP = PLATFORM['mswin'] ? ';'  : ':'
+  
+  # Executes Javac by passing it everything it needs. Stuff like a
+  # classpath and sources. The classpath is built by checking the
+  # prerequisites of the javac task. When a prerequisite is a dependency
+  # declaration (dependency task), it takes each declared Gems and
+  # adds the jar files found in them to the classpath.
+  # 
+  # Can be customized by adding directories to the <em>build_path</em>
+  # using the << operator (if none defined, default is src/main/java). 
+  class JavacTask < Rake::Task
+    
+    def execute
+      super
+      classpath = Raven.build_cp(prerequisites)
+      classpath << "target/classes"
+      @build_path = ["src/main/java"] unless @build_path
+      
+      puts "Building path #{@build_path.join(' ')}" if RakeFileUtils.verbose_flag
+      
+      Dir.mkdir("target") unless File.exist?("target")
+      Dir.mkdir("target/classes")  unless File.exist?("target/classes")
+      # Getting the source files to compile. Filtrating sources already
+      # compiled having a fresh enough class
+      source_files = @build_path.collect do |d|
+        Dir.glob("#{d}/**/*.java").select do |java|
+          classfile = 'target/classes/' + java[d.length, (java.length - 5 - d.length)] + '.class'
+          File.exist?(classfile) ? File.stat(java).ctime > File.stat(classfile).ctime : true
+        end
+      end.flatten
+      
+      if (source_files.size > 0)
+        # Getting only package names, it shortens the command line
+        source_pkg = Set.new
+        source_files.each { |src| source_pkg << File.join(File.dirname(src), '*.java') }
+        # Executing javac
+        puts "javac -cp #{classpath.join(CP_SEP)} -sourcepath #{@build_path.join(CP_SEP)} -d target/classes #{source_pkg.to_a.join(' ')}" if RakeFileUtils.verbose_flag
+        `javac -cp #{classpath.join(CP_SEP)} -sourcepath #{@build_path.join(CP_SEP)} -d target/classes #{source_pkg.to_a.join(' ')}`
+        unless $? == 0
+          puts "Build failed, see above errors."
+          exit
+        end
+      else
+        puts 'All class files are up to date.' if RakeFileUtils.verbose_flag
+      end
+    end
+    
+    def build_path
+      @build_path ||= []
+    end
+  end
+  
+  # Builds a jar file from your compiled sources. The jarfile produced
+  # will have the same name as your jar task.
+  class JarTask < Rake::Task
+    def execute
+      super      
+      latest = Raven.latest_file('target/classes')
+      
+      if !File.exist?("target/#{name}") || File.stat("target/#{name}").ctime < latest
+        `jar -cf target/#{name} -C target/classes .`
+      else
+        puts 'Nothing to do, jar is fresh enough.' if RakeFileUtils.verbose_flag
+      end
+    end
+  end
+  
+  # Builds a jar file from your sources. Customized by adding directories
+  # to the <em>source_path</em> just like the JavacTask.
+  class JarSourceTask < Rake::Task
+    def execute
+      super
+      # Checking if any of our prerequisites is a JavacTask, if
+      # so we'll just use the build path to construct the jar.
+      Raven.prereq_filter(prerequisites, :build_path) do |javac_task|
+       (@source_path ||= []) << javac_task.build_path
+      end
+      
+      # Initializing source path
+      @source_path = ["src/main/java"] unless @source_path
+      @source_path.flatten!
+            
+      latest = Time.at(0)
+      @source_path.each do |dir|
+        dir_latest = Raven.latest_file(dir)
+        latest = dir_latest if dir_latest > latest
+      end
+      
+      # Building the jar from all sources
+      if !File.exist?("target/#{name}") || File.stat("target/#{name}").ctime < latest
+        `jar -cf target/#{name} -C #{@source_path.pop} .`
+        while (p = @source_path.pop)
+          `jar -uf target/#{name} -C #{p} .`
+        end
+      end
+    end
+    
+    def source_path
+      @source_path ||= []
+    end
+  end
+  
+  # Produces a WAR from a web application directory. Includes the libraries
+  # needed in WEB-INF/lib (as long as the corresponding dependency task is
+  # declared as a prerequisite) and the compiled classes (if there are).
+  # 
+  # Can be customized by setting <em>webapp_dir</em> to the directory
+  # containing your web application resources (web.xml, jsp, images, ...).
+  # The default is src/main/webapp.
+  class WarTask < Rake::Task
+    DEFAULT_TARGET = 'target/webapp/'
+    LIB_SUBDIR = 'WEB-INF/lib/'
+    CLASSES_SUBDIR = 'WEB-INF/classes/'
+    
+    def execute
+      super
+            
+      # Build target structure
+      @webapp_dir = @webapp_dir || 'src/main/webapp'
+      Raven.mkdir_recurse(DEFAULT_TARGET)
+      
+      puts "Using web application directory #{@webapp_dir}" if RakeFileUtils.verbose_flag
+
+      FileUtils.cp_r(@webapp_dir, DEFAULT_TARGET)
+      
+      # Eventually add classes compiled by javac
+      if (File.exist?('target/classes'))
+        Raven.mkdir_recurse(DEFAULT_TARGET + CLASSES_SUBDIR)
+        FileUtils.cp_r('target/classes/.', DEFAULT_TARGET + CLASSES_SUBDIR)
+      end
+      
+      # Make lib directory with all dependencies
+      Raven.mkdir_recurse(DEFAULT_TARGET + LIB_SUBDIR)
+      Raven.mk_libs(DEFAULT_TARGET + LIB_SUBDIR, prerequisites)
+      
+      # Build the war
+      `jar -cf target/#{name} -C #{DEFAULT_TARGET} .`
+    end
+    
+    def webapp_dir=(param)
+      @webapp_dir = param
+    end
+  end
+  
+  # Places all the dependencies in a given directory (useful mostly to
+  # build a distribution). The dependencies are selected from the 
+  # prerequisites (using declared dependency tasks). The  default 
+  # directory is lib. Can be customized by setting <em>target</em>.
+  class LibDirTask < Rake::Task
+    def execute
+      super
+      puts "Copying libraries in #{@target}" if RakeFileUtils.verbose_flag
+      @target = @target || 'lib'
+      Raven.mk_libs(@target, prerequisites)
+    end
+    
+    def target=(param)
+      @target = param
+    end
+  end
+  
+  # Executes JavaDoc by passing it everything it needs. Stuff like a
+  # classpath and sources. The result is generated in target/jdoc. Can
+  # be customized exactly in the same way as the javac task.
+  class JavaDocTask < Rake::Task
+    
+    def execute
+      super
+      classpath = Raven.build_cp(prerequisites)
+      classpath << "target/classes"
+      @build_path = ["src/main/java"] unless @build_path
+      
+      puts "Executing JavaDoc using source path #{@build_path.join(' ')}" if RakeFileUtils.verbose_flag
+      
+      Dir.mkdir("target") unless File.exist?("target")
+      Dir.mkdir("target/jdoc")  unless File.exist?("target/jdoc")
+      
+      packages = Set[]
+      @build_path.each do |d|
+        Dir.glob("#{d}/**/*.java").each do |java| 
+          packages << java[(d.length + 1)..(java.rindex('/') - 1)].gsub(%r{[\\/]}, '.')
+        end
+      end
+      packages = packages.to_a
+      
+      if (packages.size > 0)
+        puts "javadoc -classpath #{classpath.join(CP_SEP)} -sourcepath #{@build_path.join(CP_SEP)} -d target/jdoc #{packages.join(' ')}" if RakeFileUtils.verbose_flag
+        `javadoc -classpath #{classpath.join(CP_SEP)} -sourcepath #{@build_path.join(CP_SEP)} -d target/jdoc #{packages.join(' ')}`
+        unless $? == 0
+          puts "Build failed, see above errors."
+          exit
+        end
+      end
+    end
+    
+    def build_path
+      @build_path ||= []
+    end
+  end
+  
+  # Wraps a jar file around a Gem. Useful for distributing it around.
+  # The jar is taken from the target directory. You must at least
+  # specify <em>version</em> to produce the Gem. The artifact name and 
+  # group name default to the current directory name and its parent 
+  # directory name respectively. Convenient if you follow the classic
+  # project/module directory structure. Otherwise, just set the
+  # <em>artifact</em> and <em>group</em> to any value that suits you.
+  class GemWrapTask < Rake::Task
+    attr_writer :version, :artifact, :group
+    
+    def execute
+      super
+      puts "Wrapping jar in a Gem" if RakeFileUtils.verbose_flag
+      unless @version
+        puts "A version must be provided to produce a Gem!"
+      end
+      pwd = Dir.pwd
+      @artifact = pwd[(pwd.rindex('/') + 1)..pwd.length] unless @artifact
+      pwd = pwd[0..pwd.rindex('/') - 1]
+      @group = pwd[(pwd.rindex('/') + 1)..pwd.length] unless @group
+      Raven.mkdir_recurse('target/gem/ext')
+      FileUtils.cp(Dir.glob('target/*.jar'), 'target/gem/ext')
+      
+      Dir.chdir('target/gem') do
+        spec = Gem::Specification.new do |s|
+          s.platform = Gem::Platform::JAVA
+          s.summary = "Raven wrapped library #{@artifact} from project #{@group}."
+          s.name = "#{@group}-#{@artifact}"
+          s.version = @version
+          s.requirements << 'none'
+          s.require_path = 'ext'
+          s.autorequire = 'rake'
+          s.files = Dir.glob("{ext}/**/*")
+        end
+        Gem::Builder.new(spec).build
+      end
+      FileUtils.mv("target/gem/#{@group}-#{@artifact}-#{@version}-java.gem", 'target')  
+    end  
+  end
+  
+  # Wraps a jar file around a Gem and automatically installs it in your
+  # local Gem repository. See the gem wrap task for more info (same rules
+  # apply).
+  class GemInstallTask < GemWrapTask
+    def execute
+      super
+      params = [false]
+      params << USER_HOME + "/.raven_gems" if defined?(GEMS_IN_HOME)
+      Gem::Installer.new("target/#{@group}-#{@artifact}-#{@version}-java.gem").install(*params)
+    end
+  end
+  
+  private
+  
+  # Builds the classpath by getting the path to the jars bundled
+  # in each gem dependency.
+  def self.build_cp(prerequisites)
+    classpath = []
+    Raven.prereq_filter(prerequisites, :gem_deps) do |dep_task|
+      dep_task.gem_deps.each do |gempath|
+        Dir.foreach(gempath + '/ext') do |file|
+          next if file == '.' || file == '..'
+          classpath << gempath + '/ext/' + file
+        end
+      end
+    end
+    classpath
+  end
+  
+  # Copies the jars corresponding to each Gem dependency to a given
+  # directory.
+  def self.mk_libs(target, prereq)
+    Raven.mkdir_recurse(target)
+    Raven.prereq_filter(prereq, :gem_deps) do |dep_task|
+      dep_task.gem_deps.each do |gempath|
+        Dir.foreach(gempath + '/ext') do |file|
+          next if file == '.' || file == '..'
+          FileUtils.copy(gempath + '/ext/' + file, target)
+        end
+      end
+    end
+  end
+  
+  # Duck typing selection of prerequisites
+  def self.prereq_filter(prerequisites, respond_to)
+    prerequisites.each do |prereq|
+      prereq_task = Rake::Task[prereq]
+      if prereq_task.respond_to?(respond_to)
+        yield(prereq_task)
+      end
+    end
+  end
+  
+  # Recursively creates a directory
+  def self.mkdir_recurse(dir)
+    if dir.rindex('/')
+      parent = dir[0, dir.rindex('/')]
+      mkdir_recurse(parent) unless File.exist?(parent)
+    end
+    Dir.mkdir(dir) unless File.exist?(dir)
+  end
+  
+  # Receursively browse a directory yielding on each file found.
+  def self.browse_files(root)
+    queue = [root]
+    while !queue.empty?
+      filename = queue.pop
+      if File.file?(filename)
+        yield(filename)
+      else
+        Dir.new(filename).each do |child|
+          unless ['..', '.', '.svn', '.cvs'].include?(child)
+            queue.push(filename + "/" + child)
+          end
+        end
+      end
+    end
+  end
+  
+  # Returns the latest file timestamp in a directory structure
+  def self.latest_file(dir)
+    latest = Time.at(0)
+    Raven.browse_files(dir) do |f|
+      change = File.stat(f).ctime
+      latest = change if change > latest
+    end
+    latest
+  end
+  
+end
+
+
+# Shortcut to the Javac task creation. Makes it handy.
+def javac(args, &block)
+  Raven::JavacTask.define_task(args, &block)
+end
+
+# Shortcut to jar. Only 3 letters, isn't that beautiful?
+def jar(args, &block)
+  Raven::JarTask.define_task(args, &block)
+end
+
+# I think you've got it now.
+def jar_source(args, &block)
+  Raven::JarSourceTask.define_task(args, &block)
+end
+
+def lib_dir(args, &block)
+  Raven::LibDirTask.define_task(args, &block)
+end
+
+def war(args, &block)
+  Raven::WarTask.define_task(args, &block)
+end
+
+def javadoc(args, &block)
+  Raven::JavaDocTask.define_task(args, &block)
+end
+
+def gem_wrap(args, &block)
+  Raven::GemWrapTask.define_task(args, &block)
+end
+
+def gem_wrap_inst(args, &block)
+  Raven::GemInstallTask.define_task(args, &block)
+end