klaas1979-ivy4r 0.1.0 → 0.2.0

data/History.txt

@@ -1,5 +1,12 @@
+=== 0.2.0 / 2009-06-18
+
+* added the Buildr ivy_extension to include ivy in buildr for dependency managment
+* small improvements in documentation
+
+
 === 0.1.0 / 2009-06-17
 
 * initial release
   * support for nearly all basic IVY Ant targets
   * basic validation of parameters
+

data/Manifest.txt

@@ -2,6 +2,8 @@ History.txt
 Manifest.txt
 README.txt
 Rakefile
+bin/ivy4r
+lib/buildr/ivy_extension.rb
 lib/ivy/artifactproperty.rb
 lib/ivy/artifactreport.rb
 lib/ivy/buildlist.rb
@@ -32,4 +34,3 @@ test/ivy/ivytest.xml
 test/ivy/test_target.rb
 test/ivy/test_targets.rb
 test/test_ivy4r.rb
-

data/README.txt

@@ -1,11 +1,16 @@
 = ivy4r
 
 * http://github.com/klaas1979/ivy4r/tree/master
+* http://ivy4r.rubyforge.org/
 
 == DESCRIPTION:
 
-Apache Ivy dependency manager wrapper for ruby (see http://ant.apache.org/ivy/index.html for more information).Use Ivy via a ruby wrapper without the need to use Apache Ant.
-The wrapper uses Antwrap (see http://antwrap.rubyforge.org/) to interface with Ivy.
+Apache Ivy dependency manager wrapper for ruby (see {Apache Ivy}[http://ant.apache.org/ivy/index.html] for more information).
+Use {Apache Ivy}[http://ant.apache.org/ivy/index.html] via a ruby wrapper without the need to use Apache Ant.
+The wrapper uses Antwrap[http://antwrap.rubyforge.org/] to interface with Ivy.
+
+Includes a Extension for Buildr[http://buildr.apache.org/] to use {Apache Ivy}[http://ant.apache.org/ivy/index.html]
+for dependency management.
 
 == FEATURES/PROBLEMS:
 
@@ -46,19 +51,15 @@ Supports most standard Ivy Ant targets via Antwrap.
 == SYNOPSIS:
 
   To init a new Ivy4r instance set the ANT_HOME and the Ivy lib dir
-  <tt>
     ivy4r = Ivy4r.new
     ivy4r.ant_home = 'PATH TO YOUR ANTHME'
     ivy4r.lib_dir = 'PATH TO IVY LIB DIR'
-  </tt>
   as an alternative to setting the ANT_HOME you can set an +Antwrap+ instance directly:
-  <tt>
     ivy4r.ant = Buildr.ant('ivy')
-  </tt>
 
 == REQUIREMENTS:
 
-* Installed Apache Ant, to call Ivy via Antwrap.
+* Installed Apache Ant, to call Ivy via Antwrap
 * Ivy and dependencies in a single directory. Dependencies depends on used features, see the ivy homepage for more information.
 
 == INSTALL:

data/bin/ivy4r

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+abort "makes no sense for ivy4r!"

data/lib/buildr/ivy_extension.rb

@@ -0,0 +1,547 @@
+require 'ivy4r'
+
+module Buildr
+  module Ivy
+
+    # TODO extend extension to download ivy stuff with dependencies automatically
+#    VERSION = '2.1.0-rc1'
+
+    class << self
+
+      def setting(*keys)
+        setting = Buildr.settings.build['ivy']
+        keys.each { |key| setting = setting[key] unless setting.nil? }
+        setting
+      end
+
+#      def version
+#        setting['version'] || VERSION
+#      end
+#      def dependencies
+#        @dependencies ||= [
+#          "org.apache.ivy:ivy:jar:#{version}",
+#          'com.jcraft:jsch:jar:1.41',
+#          'oro:oro:jar:2.08'
+#        ]
+#      end
+    end
+    
+    class IvyConfig
+
+      attr_accessor :extension_dir, :resolved
+
+      # Store the current project and initialize ivy ant wrapper
+      def initialize(project)
+        @project = project
+        if project.parent.nil?
+          @extension_dir = File.join("#{@project.base_dir}", "#{ENV['BUILDR_EXT_DIR']}")
+        else
+          @extension_dir = @project.parent.ivy.extension_dir
+          @base_ivy = @project.parent.ivy unless own_file?
+        end
+      end
+      
+      def enabled?
+        @enabled ||= Ivy.setting('enabled') || true
+      end
+
+      def own_file?
+        @own_file ||= File.exists?(@project.path_to(file))
+      end
+
+      # Returns the correct ant instance to use, if project has its own ivy file uses the ivy file
+      # of project, if not uses the ivy file of parent project.
+      def ant
+        unless @ant
+          if own_file?
+            @ant = ::Ivy4r.new(@project.ant('ivy'))
+            @ant.lib_dir = lib_dir
+            @ant.project_dir = @extension_dir
+          else
+            @ant = @project.parent.ivy.ant
+          end
+        end
+        @ant
+      end
+
+      # Returns name of publish target to use for this project
+      def file_project
+        own_file? ? @project : @base_ivy.file_project
+      end
+
+      # Returns the artifacts for given configurations as array
+      def deps(*confs)
+        configure
+        pathid = "ivy.deps." + confs.join('.')
+        ant.cachepath :conf => confs.join(','), :pathid => pathid
+      end
+
+      # Returns ivy info for configured ivy file.
+      def info
+        if @base_ivy
+          @base_ivy.info
+        else
+          ant.settings :id => 'ivy.info.settingsref'
+          ant.info :file => file, :settingsRef => 'ivy.info.settingsref'
+        end
+      end
+
+      # Configures the ivy instance with additional properties and loading the settings file if it was provided
+      def configure
+        if @base_ivy
+          @base_ivy.configure
+        else
+          unless @configured
+            ant.property['ivy.status'] = status
+            ant.property['ivy.home'] = home
+            properties.each {|key, value| ant.property[key.to_s] = value }
+            @configured = ant.settings :file => settings if settings
+          end
+        end
+      end
+
+      # Resolves the configured file once.
+      def resolve
+        if @base_ivy
+          @base_ivy.resolve
+        else
+          unless @resolved
+            @resolved = ant.resolve :file => file
+          end
+        end
+      end
+
+      # Returns the additional infos for the manifest file.
+      def manifest
+        if @base_ivy
+          @base_ivy.manifest
+        else
+          {
+            'organisation' => @resolved['ivy.organisation'],
+            'module' => @resolved['ivy.organisation'],
+            'revision' => revision
+          }
+        end
+      end
+
+      # Creates the standard ivy dependency report
+      def report
+        ant.report :todir => report_dir
+      end
+
+      # Publishs the project as defined in ivy file if it has not been published already
+      def publish
+        if @base_ivy
+          @base_ivy.publish
+        else
+          unless @published
+            options = {:status => status, :pubrevision => revision, :artifactspattern => "#{publish_from}/[artifact].[ext]"}
+            options = publish_options * options
+            ant.publish options
+            @published = true
+          end
+        end
+      end
+
+      def home
+        @ivy_home_dir ||= Ivy.setting('home.dir') || "#{@extension_dir}/ivy-home"
+      end
+
+      def lib_dir
+        @lib_dir ||= Ivy.setting('lib.dir') || "#{home}/jars"
+      end
+      
+      def settings
+        @settings ||= Ivy.setting('settings.file') || "#{@extension_dir}/ant-scripts/ivysettings.xml"
+      end
+
+      def file
+        @ivy_file ||= Ivy.setting('ivy.file') || 'ivy.xml'
+      end
+
+      # Sets the revision to use for the project, this is useful for development revisions that
+      # have an appended timestamp or any other dynamic revisioning.
+      #
+      # To set a different revision this method can be used in different ways.
+      # 1. project.ivy.revision(revision) to set the revision directly
+      # 2. project.ivy.revision { |ivy| [calculate revision] } use the block for dynamic
+      #    calculation of the revision. You can access ivy4r via <tt>ivy.ant.[method]</tt>
+      def revision(*revision, &block)
+        raise "Invalid call with parameters and block!" if revision.size > 0 && block
+        if revision.empty? && block.nil?
+          if @revision_calc
+            @revision ||= @revision_calc.call(self)
+          else
+            @revision ||= @project.version
+          end
+        elsif block.nil?
+          raise "revision value invalid #{revision.join(', ')}" unless revision.size == 1
+          @revision = revision[0]
+          self
+        else
+          @revision_calc = block
+          self
+        end
+      end
+
+      # Sets the status to use for the project, this is useful for custom status handling
+      # like integration, alpha, gold.
+      #
+      # To set a different status this method can be used in different ways.
+      # 1. project.ivy.status(status) to set the status directly
+      # 2. project.ivy.status { |ivy| [calculate status] } use the block for dynamic
+      #    calculation of the status. You can access ivy4r via <tt>ivy.ant.[method]</tt>
+      def status(*status, &block)
+        raise "Invalid call with parameters and block!" if status.size > 0 && block
+        if status.empty? && block.nil?
+          if @status_calc
+            @status ||= @status_calc.call(self)
+          else
+            @status ||= Ivy.setting('status') || 'integration'
+          end
+        elsif status.empty? && block.nil?
+          raise "status value invalid #{status.join(', ')}" unless status.size == 1
+          @status = status[0]
+          self
+        else
+          @status_calc = block
+          self
+        end
+      end
+
+      # Sets the publish options to use for the project. The options are merged with the default
+      # options including value set via #publish_from and overwrite all of them.
+      #
+      # To set the options this method can be used in different ways.
+      # 1. project.ivy.publish_options(options) to set the options directly
+      # 2. project.ivy.publish_options { |ivy| [calculate options] } use the block for dynamic
+      #    calculation of options. You can access ivy4r via <tt>ivy.ant.[method]</tt>
+      def publish_options(*options, &block)
+        raise "Invalid call with parameters and block!" if options.size > 0 && block
+        if options.empty? && block.nil?
+          if @publish_options_calc
+            @publish_options ||= @publish_options_calc.call(self)
+          else
+            @publish_options ||= Ivy.setting('publish.options')
+          end
+        else
+          raise "Could not set 'publish_options' for '#{@project.name}' without own ivy file!" unless own_file?
+          if options.size > 0 && block.nil?
+            raise "publish options value invalid #{options.join(', ')}" unless options.size == 1
+            @publish_options = options[0]
+            self
+          else
+            @publish_options_calc = block
+            self
+          end
+        end
+      end
+
+      # Sets the additional properties for the ivy process use a Hash with the properties to set.
+      def properties(*properties)
+        if properties.empty?
+          @properties ||= {}
+        else
+          raise "properties value invalid #{properties.join(', ')}" unless properties.size == 1
+          @properties = properties[0]
+          self
+        end
+      end
+
+      # Sets the local repository for ivy files
+      def local_repository(*local_repository)
+        if local_repository.empty?
+          if own_file?
+            @local_repository ||= Ivy.setting('local.repository.dir') || "#{home}/repository"
+          else
+            @project.parent.ivy.local_repository
+          end
+        else
+          raise "Could not set 'local_repository' for '#{@project.name}' without own ivy file!" unless own_file?
+          raise "local_repository value invalid #{local_repository.join(', ')}" unless local_repository.size == 1
+          @local_repository = local_repository[0]
+          self
+        end
+      end
+
+      # Maps a package to a different name for publishing. This name is used instead of the default name
+      # for publishing use a hash with the +package+ as key and the newly mapped name as value. I.e.
+      # <tt>ivy.name(package(:jar) => 'new_name_without_version_number.jar')</tt>
+      # Note that this method is additive, a second call adds the names to the first.
+      def name(*name_mappings)
+        if name_mappings.empty?
+          @name_mappings ||= {}
+        else
+          raise "name_mappings value invalid #{name_mappings.join(', ')}" unless name_mappings.size == 1
+          @name_mappings = @name_mappings ? @name_mappings + name_mappings[0] : name_mappings[0].dup
+          self
+        end
+      end
+
+      # Sets the directory to publish artifacts from.
+      def publish_from(*publish_dir)
+        if publish_dir.empty?
+          if own_file?
+            @publish_from ||= Ivy.setting('publish.from') || @project.path_to(:target)
+          else
+            @project.parent.ivy.publish_from
+          end
+        else
+          raise "Could not set 'publish_from' for '#{@project.name}' without own ivy file!" unless own_file?
+          raise "publish_from value invalid #{publish_dir.join(', ')}" unless publish_dir.size == 1
+          @publish_from = publish_dir[0]
+          self
+        end
+      end
+
+      # Sets the directory to create dependency reports in.
+      def report_dir(*report_dir)
+        if report_dir.empty?
+          if own_file?
+            @report_dir ||= Ivy.setting('report.dir') || @project.path_to(:reports, 'ivy')
+          else
+            @project.parent.ivy.report_dir
+          end
+        else
+          raise "Could not set 'report_dir' for '#{@project.name}' without own ivy file!" unless own_file?
+          raise "publish_from value invalid #{report_dir.join(', ')}" unless report_dir.size == 1
+          @report_dir = report_dir[0]
+          self
+        end
+      end
+
+      # Set the configuration artifacts to use in package tasks like +:war+ or +:ear+.
+      # <tt>project.ivy.package_conf('server', 'client')</tt>
+      # or
+      # <tt>project.ivy.package_conf(['server', 'client'])</tt>
+      def package_conf(*package_conf)
+        if package_conf.empty?
+          @package_conf ||= [Ivy.setting('package.conf') || 'prod'].flatten.uniq
+        else
+          @package_conf = [package_conf].flatten.uniq
+          self
+        end
+      end
+
+      # Sets the includes pattern(s) to use for packages. I.e.
+      # <tt>project.ivy.package_include(/\.jar/, /\.gz/)</tt>
+      def package_include(*includes)
+        if includes.empty?
+          @package_include ||= [Ivy.setting('package.include') || /\.jar/].flatten.uniq
+        else
+          @package_include = [includes].flatten.uniq
+          self
+        end
+      end
+
+      # Sets the exclude pattern(s) to use for packages. I.e.
+      # <tt>project.ivy.package_exclude(/\.zip/, /\.tar/)</tt>
+      def package_exclude(*excludes)
+        if excludes.empty?
+          @package_exclude ||= [Ivy.setting('package.exlude') || ''].flatten.uniq
+        else
+          @package_exclude = [excludes].flatten.uniq
+          self
+        end
+      end
+
+      # Set the configuration artifacts to use for compile tasks, added to <tt>compile.with</tt>
+      # <tt>project.ivy.compile_conf('server', 'client')</tt>
+      def compile_conf(*compile_conf)
+        if compile_conf.empty?
+          @compile_conf ||= [Ivy.setting('compile.conf') || 'compile'].flatten.uniq
+        else
+          @compile_conf = [compile_conf].flatten.uniq
+          self
+        end
+      end
+
+      # Set the configuration artifacts to use for test tasks, added to <tt>test.compile.with</tt>
+      # and <tt>test.with</tt>. Note that all artifacts from #compile_conf are added automatically.
+      # <tt>project.ivy.test_conf('server', 'test')</tt>
+      def test_conf(*test_conf)
+        if test_conf.empty?
+          @test_conf ||= [Ivy.setting('test.conf') || 'test'].flatten.uniq
+        else
+          @test_conf = [test_conf].flatten.uniq
+          self
+        end
+      end
+    end
+
+    # The Ivy Buildr extension adding the new tasks for ivy.
+    module IvyExtension
+      include Buildr::Extension
+
+      class << self
+        def add_ivy_deps_to_java_tasks(project)
+          resolve_target = project.ivy.file_project.task('ivy:resolve')
+          project.task :compiledeps => resolve_target do
+            compile_conf = [project.ivy.compile_conf].flatten
+            project.compile.with project.ivy.deps(compile_conf)
+            info "Ivy adding compile dependencies '#{compile_conf.join(', ')}' to project '#{project.name}'"
+          end
+          project.task :compile => "#{project.name}:compiledeps"
+
+          project.task :testdeps => resolve_target do
+            confs = [project.ivy.test_conf, project.ivy.compile_conf].flatten.uniq
+            project.test.with project.ivy.deps(confs)
+            info "Ivy adding test dependencies '#{confs.join(', ')}' to project '#{project.name}'"
+          end
+          project.task "test:compile" => "#{project.name}:testdeps"
+
+          project.task :javadocdeps => resolve_target do
+            confs = [project.ivy.test_conf, project.ivy.compile_conf].flatten.uniq
+            project.javadoc.with project.ivy.deps(confs)
+            info "Ivy adding javadoc dependencies '#{confs.join(', ')}' to project '#{project.name}'"
+          end
+          project.task :javadoc => "#{project.name}:javadocdeps"
+        end
+
+        def add_manifest_to_distributeables(project)
+          pkgs = project.packages.find_all { |pkg| [:jar, :war, :ear].member? pkg.type }
+          pkgs.each do |pkg|
+            name = "#{pkg.name}manifest"
+            task = project.task name => project.ivy.file_project.task('ivy:resolve') do
+              pkg.with :manifest => project.manifest.merge(project.ivy.manifest)
+              info "Adding manifest entries to package '#{pkg.name}'"
+            end
+            project.task :build => task
+          end
+        end
+
+        def add_prod_libs_to_distributeables(project)
+          includes = project.ivy.package_include
+          excludes = project.ivy.package_exclude
+          pkgs = project.packages.find_all { |pkg| [:war, :ear].member? pkg.type }
+          pkgs.each do |pkg|
+            name = "#{pkg.name}deps"
+            task = project.task name => project.ivy.file_project.task('ivy:resolve') do
+              confs = project.ivy.package_conf
+              libs =  project.ivy.deps(confs).find_all do |lib|
+                lib = File.basename(lib)
+                use = includes.any? {|include| include === lib } && !excludes.any? {|exclude| exclude === lib}
+                verbose "Including '#{lib}' from package '#{pkg}' in project '#{project.name}'" if use
+                info "Excluding '#{lib}' from package '#{pkg}' in project '#{project.name}'" unless use
+                use
+              end
+              pkg.with :libs => libs
+              info "Adding production libs from conf '#{confs.join(', ')}' to package '#{pkg.name}' in project '#{project.name}'"
+            end
+            project.task :build => task
+          end
+        end
+
+        def add_copy_tasks_for_publish(project)
+          if project.ivy.own_file?
+            Buildr.projects.each do |current|
+              current.packages.each do |pkg|
+                target_file = current.ivy.name[pkg] || File.basename(pkg.name).gsub(/-#{project.version}/, '')
+                taskname = current.path_to(project.ivy.publish_from, target_file)
+                if taskname != pkg.name
+                  project.file taskname => pkg.name do
+                    verbose "Ivy copying '#{pkg.name}' to '#{taskname}' for publishing"
+                    FileUtils.mkdir File.dirname(taskname) unless File.directory?(File.dirname(taskname))
+                    FileUtils.cp pkg.name, taskname
+                  end
+                end
+                project.task 'ivy:publish' => taskname
+              end
+            end
+          end
+        end
+      end
+
+      # Returns the +ivy+ configuration for the project. Use this to configure Ivy.
+      # see IvyConfig for more details about configuration options.
+      def ivy
+        @ivy_config ||= IvyConfig.new(self)
+      end
+
+      first_time do
+        namespace 'ivy' do
+          desc 'Resolves the ivy dependencies'
+          task :resolve
+
+          desc 'Publish the artifacts to ivy repository as defined by environment'
+          task :publish
+
+          desc 'Creates a dependency report for the project'
+          task :report
+      
+          desc 'Clean the local Ivy cache and the local ivy repository'
+          task :clean
+        end
+      end
+
+      before_define do |project|
+        if project.parent.nil? && project.ivy.enabled?
+          info = project.ivy.info
+          project.version = info['ivy.revision']
+          project.group = "#{info['ivy.organisation']}.#{info['ivy.module']}"
+        end
+      end
+
+      after_define do |project|
+        if project.ivy.enabled?
+          IvyExtension.add_ivy_deps_to_java_tasks(project)
+          IvyExtension.add_manifest_to_distributeables(project)
+          IvyExtension.add_prod_libs_to_distributeables(project)
+          IvyExtension.add_copy_tasks_for_publish(project)
+
+          task :clean do
+            # TODO This is redundant, refactor ivy_ant_wrap and this to use a single config object
+            info "Cleaning ivy reports"
+            rm_rf project.path_to(:reports, 'ivy')
+          end
+
+          namespace 'ivy' do
+            task :configure do
+              project.ivy.configure
+            end
+
+            task :resolve => "#{project.name}:ivy:configure" do
+              project.ivy.resolve
+            end
+
+            task :report => "#{project.name}:ivy:resolve" do
+              project.ivy.report
+            end
+
+            task :publish => "#{project.name}:ivy:resolve" do
+              project.ivy.publish
+            end
+          end
+        end
+      end
+    end
+
+    # Global targets that are not bound to a project
+    namespace 'ivy' do
+      task :clean do
+        info "Cleaning local ivy cache"
+        Buildr.projects.find_all{ |p| p.ivy.own_file? }.each do |project|
+          project.ivy.ant.clean
+        end
+      end
+
+      task :resolve do
+        info "Resolving all distinct ivy files"
+        Buildr.projects.find_all{ |p| p.ivy.own_file? }.each do |project|
+          project.task('ivy:resolve').invoke
+        end
+      end
+      
+      task :publish => :package do
+        info "Publishing all distinct ivy files"
+        Buildr.projects.find_all{ |p| p.ivy.own_file? }.each do |project|
+          project.task('ivy:publish').invoke
+        end
+      end
+    end
+
+    class Buildr::Project # :nodoc:
+      include IvyExtension
+    end
+  end
+end

data/lib/ivy/target.rb

@@ -2,19 +2,7 @@ require 'facets'
 
 module Ivy
 
-  COMMA_SPLITTER = Proc.new {|value| value.to_s.split(',').map(&:strip)}
-
-  Parameter = Struct.new(:symbol, :mandatory) do
-    def mandatory?
-      mandatory
-    end
-  end
-
-  ResultValue = Struct.new(:matcher, :parser) do
-    def parse(value)
-      parser ? parser.call(value) : value
-    end
-  end
+  # Base class with general logic to call a Ivy ant target
   class Target
     attr_reader :params
 
@@ -22,11 +10,16 @@ module Ivy
       @ant = ant
     end
 
-    # Executes this ivy target with given parameters returning a result where appropriate
+    # Executes this ivy target with given parameters returning a result.
+    # __params__ can be a single Hash or an Array with or without a Hash as last value.
+    # every value in array will be converted to string and set to __true__.
+    # 
+    # I.e. <tt>[:force, 'validate', {'name' => 'Blub'}]</tt>
+    # results in parameters <tt>{'force'=>true, 'validate' => true, 'name'=>'Blub'}</tt>
     def execute(*params)
       @params = {}
       params.pop.each { |key, value| @params[key] = value } if Hash === params.last
-      params.each { |key| @params[key] = true }
+      params.each { |key| @params[key.to_s] = true }
 
       validate
       before_hook
@@ -118,5 +111,18 @@ module Ivy
       @ant.project.references
     end
   end
-  
+
+    COMMA_SPLITTER = Proc.new {|value| value.to_s.split(',').map(&:strip)}
+
+  Parameter = Struct.new(:symbol, :mandatory) do
+    def mandatory?
+      mandatory
+    end
+  end
+
+  ResultValue = Struct.new(:matcher, :parser) do
+    def parse(value)
+      parser ? parser.call(value) : value
+    end
+  end
 end

data/lib/ivy4r.rb

@@ -2,7 +2,7 @@ require 'antwrap'
 require 'ivy/targets'
 
 class Ivy4r
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 
   # Set the ant home directory to load ant classes from if no custom __antwrap__ is provided
   attr_accessor :ant_home

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: klaas1979-ivy4r
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Klaas Prause
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-17 00:00:00 -07:00
+date: 2009-06-18 00:00:00 -07:00
 default_executable: ivy4r
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,7 +32,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 2.1.0
     version: 
-description: Apache Ivy dependency manager wrapper for ruby (see http://ant.apache.org/ivy/index.html for more information).Use Ivy via a ruby wrapper without the need to use Apache Ant. The wrapper uses Antwrap (see http://antwrap.rubyforge.org/) to interface with Ivy.
+description: Apache Ivy dependency manager wrapper for ruby (see {Apache Ivy}[http://ant.apache.org/ivy/index.html] for more information). Use {Apache Ivy}[http://ant.apache.org/ivy/index.html] via a ruby wrapper without the need to use Apache Ant. The wrapper uses Antwrap[http://antwrap.rubyforge.org/] to interface with Ivy.  Includes a Extension for Buildr[http://buildr.apache.org/] to use {Apache Ivy}[http://ant.apache.org/ivy/index.html] for dependency management.
 email: 
 - klaas.prause@googlemail.com
 executables: 
@@ -48,6 +48,8 @@ files:
 - Manifest.txt
 - README.txt
 - Rakefile
+- bin/ivy4r
+- lib/buildr/ivy_extension.rb
 - lib/ivy/artifactproperty.rb
 - lib/ivy/artifactreport.rb
 - lib/ivy/buildlist.rb
@@ -105,7 +107,7 @@ rubyforge_project: ivy4r
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 3
-summary: Apache Ivy dependency manager wrapper for ruby (see http://ant.apache.org/ivy/index.html for more information).Use Ivy via a ruby wrapper without the need to use Apache Ant
+summary: Apache Ivy dependency manager wrapper for ruby (see {Apache Ivy}[http://ant.apache.org/ivy/index.html] for more information)
 test_files: 
 - test/test_ivy4r.rb
 - test/ivy/test_target.rb