pepijnve-ivy4r 0.12.11

data/lib/ivy4r.rb

@@ -0,0 +1,252 @@
+require 'ivy4r/version'
+require 'ivy4r_jars'
+require 'antwrap'
+require 'ivy/targets'
+
+=begin rdoc
+Simple wrapper that maps the ant ivy targets one to one to ruby. See the {Apache Ivy}[http://ant.apache.org/ivy/index.html]
+for more informations about the parameters for a call. All ivy ant targets have the equivalent
+name in this class.
+
+The standard parameters are provided as Hash, i.e.:
+  <ivy:configure file="settings.xml" settingsId="my.id" />
+is
+  ivy4r.configure :file => "settings.xml", :settingsId => 'my.id'
+
+You can use nested options via the nested attribute:
+  <ivy:buildlist reference="testpath">
+    <fileset dir="target/p1" includes="buildfile" />
+  </ivy:buildlist>
+is
+  @ivy4r.buildlist :reference => 'testpath', :nested => {
+    :fileset => {:dir => 'target/p1', :includes => 'buildfile'}
+  }
+
+you can nest more than on element of the same type using an array:
+  <ivy:buildlist reference="testpath">
+    <fileset dir="target/sub" includes="**/buildfile" />
+    <fileset dir="target/p1" includes="buildfile" />
+  </ivy:buildlist>
+is
+  @ivy4r.buildlist :reference => 'testpath', :nested => {
+    :fileset => [
+      {:dir => 'target/sub', :includes => '**/buildfile'},
+      {:dir => 'target/p1', :includes => 'buildfile'}
+    ]
+  }
+=end
+class Ivy4r
+  
+  # Set the ant home directory to load ant classes from if no custom __antwrap__ is provided
+  # and the default provided ant version 1.7.1 should not be used.
+  # Must be set before any call to method that uses the ivy is made.
+  attr_accessor :ant_home
+  
+  # Defines the directory to load ivy libs and its dependencies from
+  attr_accessor :lib_dir
+  
+  # Optional ant variable <tt>ivy.project.dir</tt> to add to ant environment before loading ivy
+  # defaults to the __lib_dir__
+  attr_accessor :project_dir
+  
+  # The ant property name to use for references to environment properties in ant and ivy,
+  # defaults to 'env'
+  attr_accessor :environment_property
+  
+  # To provide a custom __antwrap__ to use instead of default one
+  attr_accessor :ant
+  
+  # Access to ivy settings set via configure or settings method.
+  attr_accessor :settings_file
+  
+  # Donates the base directory for the cached files, if nil no caching is enabled
+  attr_accessor :cache_dir
+  
+  # Initalizes ivy4r with optional ant wrapper object. Sets ant home dir and ivy lib dir
+  # to default values from __Ivy4rJars__ gem.
+  def initialize(ant_instance = nil, &block)
+    @ant_home = ::Ivy4rJars.ant_home_dir
+    @lib_dir = ::Ivy4rJars.lib_dir
+    @project_dir = @lib_dir
+    @environment_property = 'env'
+    @ant = ant_instance
+    
+    if block
+      if block.arity > 1
+        raise ArgumentError, "To many arguments expected=1 given=#{block.arity}"
+      elsif block.arity == 1
+        yield self
+      else
+        instance_eval(&block)
+      end
+    end
+  end
+  
+  # Calls the __cleancache__ ivy target with given parameters.
+  def cleancache(*params)
+    Ivy::Cleancache.new(ant, cache_dir).execute(*params)
+  end
+  
+  # Calls the __settings__ ivy target with given parameters.
+  def settings(*params)
+    settings_task = Ivy::Settings.new(ant, nil) # do not cache settings
+    result = settings_task.execute(*params)
+    @settings_file = settings_task.params[:file]
+    result
+  end
+  
+  # Calls the __configure__ ivy target with given parameters.
+  def configure(*params)
+    configure_task = Ivy::Configure.new(ant, nil) # do not cache configure
+    result = configure_task.execute(*params)
+    @settings_file = configure_task.params[:file]
+    result
+  end
+  
+  # Calls the __info__ ivy target with given parameters and returns info as hash.
+  def info(*params)
+    Ivy::Info.new(ant, cache_dir).execute(*params)
+  end
+  
+  # Calls the __buildnumber__ ivy target with given parameters and returns info as hash.
+  def buildnumber(*params)
+    Ivy::Buildnumber.new(ant, cache_dir).execute(*params)
+  end
+  
+  # Calls the __listmodules__ ivy target with given parameters and returns info as hash.
+  def listmodules(*params) #:nodoc:
+    Ivy::Listmodules.new(ant, cache_dir).execute(*params)
+  end
+  
+  # Calls the __makepom__ ivy target with given parameters and returns pom content.
+  def makepom(*params)
+    Ivy::Makepom.new(ant, cache_dir).execute(*params)
+  end
+  
+  # Calls the __resolve__ ivy target with given parameters and returns info as hash.
+  def resolve(*params)
+    Ivy::Resolve.new(ant, cache_dir).execute(*params)
+  end
+  
+  # Calls the __retrieve__ ivy target with given parameters.
+  def retrieve(*params)
+    Ivy::Retrieve.new(ant, cache_dir).execute(*params)
+  end
+  
+  # Calls the __publish__ ivy target with given parameters.
+  def publish(*params)
+    Ivy::Publish.new(ant, cache_dir).execute(*params)
+  end
+  
+  # Calls the __cachepath__ ivy target with given parameters and returns
+  # array containing absolute file paths to all artifacts contained in result
+  def cachepath(*params)
+    Ivy::Cachepath.new(ant, cache_dir).execute(*params)
+  end
+  
+  # Calls the __findrevision__ ivy target with given parameters and returns
+  # array containing absolute file paths to all artifacts contained in result
+  def findrevision(*params)
+    Ivy::Findrevision.new(ant, cache_dir).execute(*params)
+  end
+
+  # Calls the __install__ ivy target with given parameters always returns nil
+  def install(*params)
+    Ivy::Install.new(ant, cache_dir).execute(*params)
+  end
+  
+  # Calls the __artifactproperty__ ivy target with given parameters and returns
+  # map with all defined properties
+  def artifactproperty(*params)
+    Ivy::Artifactproperty.new(ant, cache_dir).execute(*params)
+  end
+  
+  # Calls the __buildlist__ ivy target with given parameters and returns
+  # the resulting buildlist
+  def buildlist(*params)
+    Ivy::Buildlist.new(ant, cache_dir).execute(*params)
+  end
+  
+  # Calls the __artifactreport__ ivy target with given parameters and returns
+  # the created xml.
+  def artifactreport(*params)
+    Ivy::Artifactreport.new(ant, cache_dir).execute(*params)
+  end
+  
+  # Calls the __report__ ivy target with given parameters
+  def report(*params)
+    Ivy::Report.new(ant, cache_dir).execute(*params)
+  end
+  
+  # Used to get or set ant properties.
+  # [set] <tt>property['name'] = value</tt> sets the ant property with name to given value no overwrite
+  # [get] <tt>property[matcher]</tt> gets property that is equal via case equality operator (<tt>===</tt>)
+  def property
+    AntPropertyHelper.new(ant, ant_properties)
+  end
+  
+  # Returns the __antwrap__ instance to use for all internal calls creates a default
+  # instance if no instance has been set before.
+  def ant
+    @ant ||= ::Antwrap::AntProject.new(:ant_home => ant_home,
+      :name => "ivy-ant", :basedir => Dir.pwd, :declarative => true)
+    init(@ant) if should_init?
+    @ant
+  end
+  
+  private
+  def should_init?
+    @init_done.nil? || @init_done == false
+  end
+  
+  def init(ant)
+    @init_done = true
+    ant.property :environment => environment_property
+    ant.property :name => 'ivy.project.dir', :value => project_dir
+    ant.path :id => 'ivy.lib.path' do
+      ant.fileset :dir => lib_dir, :includes => '*.jar'
+    end
+    
+    ant.typedef :name => "ivy_settings", :classname => "org.apache.ivy.ant.IvyAntSettings", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader', :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_configure", :classname => "org.apache.ivy.ant.IvyConfigure", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_resolve", :classname => "org.apache.ivy.ant.IvyResolve", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_retrieve", :classname => "org.apache.ivy.ant.IvyRetrieve", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_deliver", :classname => "org.apache.ivy.ant.IvyDeliver", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_publish", :classname => "org.apache.ivy.ant.IvyPublish", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_extract", :classname => "org.apache.ivy.ant.IvyExtractFromSources", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_cachepath", :classname => "org.apache.ivy.ant.IvyCachePath", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_cachefileset", :classname => "org.apache.ivy.ant.IvyCacheFileset", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_report", :classname => "org.apache.ivy.ant.IvyReport", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_repreport", :classname => "org.apache.ivy.ant.IvyRepositoryReport", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_var", :classname => "org.apache.ivy.ant.IvyVar", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_check", :classname => "org.apache.ivy.ant.IvyCheck", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_artifactproperty", :classname => "org.apache.ivy.ant.IvyArtifactProperty", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_buildlist", :classname => "org.apache.ivy.ant.IvyBuildList", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_install", :classname => "org.apache.ivy.ant.IvyInstall", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_convertpom", :classname => "org.apache.ivy.ant.IvyConvertPom", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_makepom", :classname => "org.apache.ivy.ant.IvyMakePom", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_artifactreport", :classname => "org.apache.ivy.ant.IvyArtifactReport", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_info", :classname => "org.apache.ivy.ant.IvyInfo", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_addpath", :classname => "org.apache.ivy.ant.AddPathTask", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_listmodules", :classname => "org.apache.ivy.ant.IvyListModules", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_findrevision", :classname => "org.apache.ivy.ant.IvyFindRevision", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_buildnumber", :classname => "org.apache.ivy.ant.IvyBuildNumber", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+    ant.taskdef :name => "ivy_cleancache", :classname => "org.apache.ivy.ant.IvyCleanCache", :classpathref => "ivy.lib.path", :loaderRef => 'ivy.lib.path.loader'
+  end
+  
+  # Returns the ant properties, note that this are java objects.
+  def ant_properties
+    ant.project.properties
+  end
+end
+
+AntPropertyHelper = Struct.new(:ant, :ant_properties) do #:nodoc:
+  def []=(name, value) #:nodoc:
+    ant.property :name => name, :value => value
+  end
+  
+  def [](matcher) #:nodoc:
+    property = ant_properties.find {|p| matcher === p[0] }
+    property ? property[1] : nil
+  end
+end

data/lib/ivy4r/version.rb

@@ -0,0 +1,3 @@
+class Ivy4r
+  VERSION = "0.12.11"
+end

data/lib/ivy4r_java_extensions.rb

@@ -0,0 +1,42 @@
+# basic stuff
+require 'ivy4r'
+
+# java extensions
+Dir[Ivy4rJars.lib_dir + "/*.jar"].each {|jar| require jar}
+require 'ivy/java/all_version_matcher'
+
+class Ivy4r
+  # Returns the ivy instance for underlying ant project with the current ivy settings.
+  def ivy_instance
+    unless @ivy_instance
+      variable_container = Java::OrgApacheIvyAnt::IvyAntVariableContainer.new(ant.project)
+      settings_file = find_settings_file(variable_container) unless settings_file
+      raise "no settings file set and no default settings found, cannot create ivy instance" unless settings_file
+      raise "settings file does not exist: #{settings_file}" unless File.exists? settings_file
+
+      settings = Java::OrgApacheIvyCoreSettings::IvySettings.new(variable_container)
+      settings.base_dir = ant.project.base_dir
+      @ivy_instance = Java::OrgApacheIvy::Ivy.new_instance(settings)
+      @ivy_instance.configure(Java::JavaIo::File.new(settings_file))
+    end
+
+    @ivy_instance
+  end
+
+  # Returns the ant references, note that this are java objects.
+  def ant_references
+    ant.project.references
+  end
+
+  private
+  def find_settings_file(variable_container)
+    settings_file_name = variable_container.get_variable("ivy.conf.file") || variable_container.get_variable("ivy.settings.file")
+    setting_locations = [
+      File.join(ant.project.base_dir.absolute_path, settings_file_name),
+      File.join(ant.project.base_dir.absolute_path, 'ivyconf.xml'),
+      settings_file_name,
+      'ivyconf.xml'
+    ]
+    setting_locations.find {|path| File.exists? path }
+  end
+end

data/lib/rake/ivy_extension.rb

@@ -0,0 +1,349 @@
+require 'ivy4r'
+
+class Rake::Application
+  attr_accessor :ivy
+end
+
+module Rake
+  module Ivy
+    class IvyConfig
+      
+      # The directory to load ivy jars and its dependencies from, leave __nil__ to use default
+      attr_accessor :lib_dir
+      
+      # The extension directory containing ivy settings, the local repository and cache
+      attr_accessor :extension_dir
+      
+      # Returns the resolve result
+      attr_reader :resolved
+      
+      attr_reader :post_resolve_tasks
+      
+      # Store the current rake application and initialize ivy ant wrapper
+      def initialize(application)
+        @application = application
+        @extension_dir = File.join("#{@application.original_dir}", "#{ENV['IVY_EXT_DIR']}")
+        @post_resolve_tasks = []
+      end
+      
+      # Returns the correct ant instance to use.
+      def ivy4r
+        unless @ivy4r
+          @ivy4r = ::Ivy4r.new do |i|
+            i.cache_dir = result_cache_dir if caching_enabled?
+          end
+          @ivy4r.lib_dir = lib_dir if lib_dir
+          @ivy4r.project_dir = @extension_dir
+        end
+        @ivy4r
+      end
+      
+      # Returns if ivy result caching is enabled by existence of the marker file.
+      def caching_enabled?
+        File.exists? caching_marker
+      end
+      
+      # Returns the use ivy result caching marker file
+      def caching_marker
+        File.expand_path 'use_ivy_caching'
+      end
+      
+      # Returns the dir to store ivy caching results in.
+      def result_cache_dir
+        dir = File.expand_path('ivycaching')
+        FileUtils.mkdir_p dir
+        dir
+      end
+      
+      # Returns the artifacts for given configurations as array
+      # this is a post resolve task.
+      # the arguments are checked for the following:
+      # 1. if an Hash is given :conf is used for confs and :type is used for types
+      # 2. if exactly two arrays are given args[0] is used for confs and args[1] is used for types
+      # 3. if not exactly two arrays all args are used as confs
+      def deps(*args)
+        if args.size == 1 && args[0].kind_of?(Hash)
+          confs, types = [args[0][:conf]].flatten, [args[0][:type]].flatten
+        elsif args.size == 2 && args[0].kind_of?(Array) && args[1].kind_of?(Array)
+          confs, types = args[0], args[1]
+        else
+          confs, types = args.flatten, []
+        end
+        
+        [confs, types].each do |t|
+          t.reject! {|c| c.nil? || c.empty? }
+        end
+        
+        unless confs.empty?
+          pathid = "ivy.deps." + confs.join('.') + '.' + types.join('.')
+          params = {:conf => confs.join(','), :pathid => pathid}
+          params[:type] = types.join(',') unless types.nil? || types.size == 0
+          
+          ivy4r.cachepath params
+        end
+      end
+      
+      # Returns ivy info for configured ivy file.
+      def info
+        ivy4r.settings :id => 'ivy.info.settingsref'
+        ivy4r.info :file => file, :settingsRef => 'ivy.info.settingsref'
+      end
+      
+      # Configures the ivy instance with additional properties and loading the settings file if it was provided
+      def configure
+        unless @configured
+          ivy4r.property['ivy.status'] = status if status
+          ivy4r.property['ivy.home'] = home if home
+          properties.each {|key, value| ivy4r.property[key.to_s] = value }
+          @configured = ivy4r.settings :file => settings if settings
+        end
+      end
+      
+      # Resolves the configured file once.
+      def __resolve__
+        unless @resolved
+          @resolved = ivy4r.resolve :file => file
+          post_resolve_tasks.each { |p| p.call(self) }
+        end
+        @resolved
+      end
+      
+      # Creates the standard ivy dependency report
+      def report
+        ivy4r.report :todir => report_dir
+      end
+      
+      # Publishs the project as defined in ivy file if it has not been published already
+      def __publish__
+        unless @published
+          options = {:artifactspattern => "#{publish_from}/[artifact].[ext]"}
+          options[:pubrevision] = revision if revision
+          options[:status] = status if status
+          options = publish_options * options
+          ivy4r.publish options
+          @published = true
+        end
+      end
+      
+      def home
+        @ivy_home_dir
+      end
+      
+      def settings
+        @settings ||= "#{@extension_dir}/ivysettings.xml"
+      end
+      
+      def file
+        @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.ivy4r.[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
+          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.ivy4r.[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
+          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.ivy4r.[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 ||= {}
+          end
+        else
+          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?
+          @local_repository ||= "#{home}/repository"
+        else
+          raise "local_repository value invalid #{local_repository.join(', ')}" unless local_repository.size == 1
+          @local_repository = local_repository[0]
+          self
+        end
+      end
+      
+      # Sets the directory to publish artifacts from.
+      def publish_from(*publish_dir)
+        if publish_dir.empty?
+          @publish_from ||= @application.original_dir
+        else
+          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?
+          @report_dir ||= @application.original_dir
+        else
+          raise "publish_from value invalid #{report_dir.join(', ')}" unless report_dir.size == 1
+          @report_dir = report_dir[0]
+          self
+        end
+      end
+    end
+    
+    # Adds given block as post resolve action that is executed directly after #resolve has been called.
+    # Yields this ivy config object into block.
+    # <tt>project.ivy.post_resolve { |ivy| p "all deps:" + ivy.deps('all').join(", ") }</tt>
+    def post_resolve(&block)
+      post_resolve_tasks << block if block
+    end
+    
+    # Filter artifacts for given configuration with provided filter values, this is a post resolve
+    # task like #deps.
+    # <tt>project.ivy.filter('server', 'client', :include => /b.*.jar/, :exclude => [/a\.jar/, /other.*\.jar/])</tt>
+    def filter(*confs)
+      filter = confs.last.kind_of?(Hash) ? confs.pop : {}
+      unless (filter.keys - (TYPES - [:conf])).empty?
+        raise ArgumentError, "Invalid filter use :include and/or :exclude only: given #{filter.keys.inspect}"
+      end
+      includes, excludes, types = filter[:include] || [], filter[:exclude] || [], filter[:type] || []
+      
+      artifacts = deps(confs.flatten, types.flatten)
+      if artifacts
+        artifacts = artifacts.find_all do |lib|
+          lib = File.basename(lib)
+          includes = includes.reject {|i| i.nil? || (i.respond_to?(:empty?) && i.empty?) || (i.respond_to?(:source) && i.source.empty?) }
+          should_include = includes.empty? || includes.any? {|include| include === lib }
+          should_include && !excludes.any? {|exclude| exclude === lib}
+        end
+      end
+      
+      artifacts
+    end
+    
+    class Tasks < ::Rake::TaskLib
+      def initialize(ivy = nil, &block)
+        @ivy = ivy || Rake::Ivy::IvyConfig.new(Rake.application)
+        yield @ivy if block_given?
+        Rake.application.ivy = @ivy
+        
+        define
+      end
+      
+      private
+      def define
+        namespace 'ivy' do
+          task :configure do
+            Rake.application.ivy.configure
+          end
+          
+          desc 'Resolves the ivy dependencies'
+          task :resolve => "ivy:configure" do
+            Rake.application.ivy.__resolve__
+          end
+          
+          desc 'Publish the artifacts to ivy repository'
+          task :publish => "ivy:resolve" do
+            Rake.application.ivy.__publish__
+          end
+          
+          desc 'Creates a dependency report for the project'
+          task :report => "ivy:resolve" do
+            Rake.application.ivy.report
+          end
+          
+          desc 'Clean the local Ivy cache and the local ivy repository'
+          task :clean do
+            Rake.application.ivy.ivy4r.clean
+          end
+          
+          desc 'Clean the local Ivy result cache to force execution of ivy targets'
+          task :clean_result_cache do
+            puts "Deleting IVY result cache dir '#{Rake.application.ivy.result_cache_dir}'"
+            rm_rf Rake.application.ivy.result_cache_dir
+          end
+          
+          desc 'Enable the local Ivy result cache by creating the marker file'
+          task :enable_result_cache do
+            puts "Creating IVY caching marker file '#{Rake.application.ivy.caching_marker}'"
+            touch Rake.application.ivy.caching_marker
+          end
+          
+          desc 'Disable the local Ivy result cache by removing the marker file'
+          task :disable_result_cache do
+            puts "Deleting IVY caching marker file '#{Rake.application.ivy.caching_marker}'"
+            rm_f Rake.application.ivy.caching_marker
+          end
+        end
+      end
+    end
+  end
+end