lock_jar 0.6.2 → 0.7.0

data/Gemfile

@@ -1,6 +1,8 @@
+#require 'lib/lock_jar/bundler'
+
 source "http://rubygems.org"
 
-gem "naether", "~> 0.9.0"
+gem "naether", "~> 0.10.0"
 gem "thor",     "~> 0.14.6"
 
 # Add dependencies to develop your gem here.
@@ -9,6 +11,6 @@ group :development do
   gem "rspec", "~> 2.9.0"
   gem "jeweler", "~> 1.8.4"
   gem "yard", "~> 0.8.0"
-  gem 'solr_sail', '~>0.0.6'
+  gem 'solr_sail', '~>0.1.0',   :platforms => :jruby
   gem 'jruby-openssl',   :platforms => :jruby
 end

data/README.md

@@ -1,8 +1,14 @@
 # LockJar
 
-LockJar manages Java Jars for Ruby. Powered by [Naether](https://github.com/mguymon/naether) to create a frankenstein of Bundler and Maven. A Jarfile ([example](https://github.com/mguymon/lock_jar/blob/master/spec/Jarfile)) is used to generate a Jarfile.lock that contains all the resolved jar dependencies for scopes runtime, compile, and test. The Jarfile.lock can be used to populate the classpath.
+LockJar manages Java Jars for Ruby. Powered by [Naether](https://github.com/mguymon/naether) to
+ create a frankenstein of Bundler and Maven. A Jarfile ([example](https://github.com/mguymon/lock_jar/blob/master/spec/Jarfile)) is used to generate a Jarfile.lock that contains all the resolved jar dependencies. The Jarfile.lock can be used to populate the classpath.
 
-LockJar can be used directly, from the [command line](https://github.com/mguymon/lock_jar/blob/master/README.md#command-line), [triggered from a Gem install](https://github.com/mguymon/lock_jar/blob/master/README.md#gem-integration), and [integrates with Buildr](https://github.com/mguymon/lock_jar/blob/master/README.md#buildr-integration).
+LockJar can:
+* Be Use directly in MRI 1.8.7, 1.9.3, and JRuby 1.6.7, 1.6.8
+* From the [command line](https://github.com/mguymon/lock_jar/blob/master/README.md#command-line)
+* [Triggered from a Gem install](https://github.com/mguymon/lock_jar/blob/master/README.md#gem-integration)
+* [Integrated into Buildr](https://github.com/mguymon/lock_jar/blob/master/README.md#buildr-integration)
+* Experimental [tntegration with Bundler](https://github.com/mguymon/lock_jar/blob/master/README.md#bundler-integration)
 
 https://github.com/mguymon/lock_jar
 
@@ -14,31 +20,33 @@ https://github.com/mguymon/lock_jar
 
 ## Ruby Usage
 
+JRuby is natively supported. Ruby 1.8.7 and 1.9.3 uses [Rjb](http://rjb.rubyforge.org/) to proxy over JNI.
+
 ### Jarfile
 
 A Jarfile is a simple file using a Ruby DSL for defining a project's dependencies using the following 
 methods:
 
-* **local( path )**: Set the local Maven repository, this were dependencies are downloaded to. 
-* **repository( url )**: Add additional urlr of remote Maven repository.
-* **exclude( excludes )**: Add a artifact:group that will be excluded from resolved dependencies. A single or Array of excludes can be set.
-* **jar( notations, opts = {} )**: Add Jar dependency in artifact notation, artifact:group:version as the bare minimum. A single or Array of notations can be passed. Default scope is _compile_, can be specified by setting _opts = { :scope => ['new_scope'] }_
-* **pom( pom_path, opts = {} )**: Add a local Maven pom, default is to load dependencies for all scopes. To select the scopes to be loaded from the pom, set the _opts = { :scopes => ['new_scope'] }_
-* **scope( scopes )**: Set the scope for nested jar or pom. A single or Array of scopes can be set.
+* **local_repo( path )**: Set the local Maven repository, this were dependencies are downloaded to. 
+* **remote_repo( url )**: Add additional url of remote Maven repository.
+* **group( groups )**: Set the group for nested jar or pom. A single or Array of groups can be set.
+* **jar( notations, opts = {} )**: Add Jar dependency in artifact notation, artifact:group:version as the bare minimum. A single or Array of notations can be passed. Default group is _default_, can be specified by setting _opts = { :group => ['group_name'] }_
+* **pom( pom_path, opts = {} )**: Add a local Maven pom, default is to load dependencies for `runtime` and `compile` scopes. To select the scopes to be loaded from the pom, set the _opts = { :scopes => ['test'] }_
 
 #### Example Jarfile
 
     repository 'http://repository.jboss.org/nexus/content/groups/public-jboss'
   	
-    // Default scope is compile
+    // Default group is default
     jar "org.apache.mina:mina-core:2.0.4"
   
-    scope 'runtime' do
+    group 'runtime' do
       jar 'org.apache.tomcat:servlet-api:jar:6.0.35'
     end
   
-    jar 'junit:junit:jar:4.10', :scope => 'test'
-  
+    group 'test' do
+      jar 'junit:junit:jar:4.10', :group => 'test'
+    end
 	
 ### Resolving dependencies
 
@@ -58,60 +66,79 @@ Example of locking a Jarfile to a Jarfile.lock
  
 ### Jarfile.lock
 
-The _Jarfile.lock_ generated is a YAML file containing the scoped dependencies, their resolved dependencies, and the additional Maven repositories.
+The _Jarfile.lock_ generated is a YAML file containing information on how to handle the classpath for grouped dependencies and their nested transitive dependencies.
 
 #### The Jarfile.lock
+    
+    ---
+    version: 0.7.0
+    groups:
+      default:
+        dependencies:
+        - ch.qos.logback:logback-classic:jar:0.9.24
+        - ch.qos.logback:logback-core:jar:0.9.24
+        - com.metapossum:metapossum-scanner:jar:1.0
+        - com.slackworks:modelcitizen:jar:0.2.2
+        - commons-beanutils:commons-beanutils:jar:1.8.3
+        - commons-io:commons-io:jar:1.4
+        - commons-lang:commons-lang:jar:2.6
+        - commons-logging:commons-logging:jar:1.1.1
+        - junit:junit:jar:4.7
+        - org.apache.mina:mina-core:jar:2.0.4
+        - org.slf4j:slf4j-api:jar:1.6.1
+        artifacts:
+        - jar:org.apache.mina:mina-core:jar:2.0.4:
+            transitive:
+              org.slf4j:slf4j-api:jar:1.6.1: {}
+        - pom:spec/pom.xml:
+            scopes:
+            - runtime
+            - compile
+            transitive:
+              com.metapossum:metapossum-scanner:jar:1.0:
+                junit:junit:jar:4.7: {}
+                commons-io:commons-io:jar:1.4: {}
+              commons-beanutils:commons-beanutils:jar:1.8.3:
+                commons-logging:commons-logging:jar:1.1.1: {}
+              ch.qos.logback:logback-classic:jar:0.9.24:
+                ch.qos.logback:logback-core:jar:0.9.24: {}
+              commons-lang:commons-lang:jar:2.6: {}
+      development:
+        dependencies:
+        - com.typesafe:config:jar:0.5.0
+        artifacts:
+        - jar:com.typesafe:config:jar:0.5.0:
+            transitive: {}
+      test:
+        dependencies:
+        - junit:junit:jar:4.10
+        - org.hamcrest:hamcrest-core:jar:1.1
+        artifacts:
+        - jar:junit:junit:jar:4.10:
+            transitive:
+              org.hamcrest:hamcrest-core:jar:1.1: {}
+    ...
 
-    --- 
-    repositories: 
-      - http://repository.jboss.org/nexus/content/groups/public-jboss
-    scopes: 
-      compile: 
-        dependencies: 
-          - org.apache.mina:mina-core:2.0.4
-        resolved_dependencies: 
-          - org.apache.mina:mina-core:jar:2.0.4
-          - org.slf4j:slf4j-api:jar:1.6.1
-          - com.slackworks:modelcitizen:jar:0.2.2
-          - commons-lang:commons-lang:jar:2.6
-          - commons-beanutils:commons-beanutils:jar:1.8.3
-          - commons-logging:commons-logging:jar:1.1.1
-          - ch.qos.logback:logback-classic:jar:0.9.24
-          - ch.qos.logback:logback-core:jar:0.9.24
-          - com.metapossum:metapossum-scanner:jar:1.0
-          - commons-io:commons-io:jar:1.4
-          - junit:junit:jar:4.7
-      runtime: 
-        dependencies: 
-          - org.apache.tomcat:servlet-api:jar:6.0.35
-        resolved_dependencies: 
-          - org.apache.tomcat:servlet-api:jar:6.0.35
-      test: 
-        dependencies: 
-          - junit:junit:jar:4.10
-        resolved_dependencies: 
-          - junit:junit:jar:4.10
-          - org.hamcrest:hamcrest-core:jar:1.1
   
   
 ### Accessing Jars
 **LockJar.install(*args)**: Download Jars in the Jarfile.lock
 * _[String]_ will set the Jarfile.lock path, e.g. `'Better.lock'`. Default lock file is `'Jarfile.lock'`.
-* _[Array<String>]_ will set the scopes, e.g. `['compile','test']`. Defaults scopes are _compile_ and _runtime_.
+* _[Array<String>]_ will set the groups, e.g. `['compile','test']`. Defaults group is _default_.
 * _[Hash]_ will set the options, e.g. `{ :local_repo => 'path' }`
   * **:local_repo** _[String]_ sets the local repo path. Defaults to `ENV['M2_REPO']` or `'~/.m2/repository'`
   
-**LockJar.list(*args)**: Lists all dependencies as notations for scopes from the Jarfile.lock.  Depending on the type of arg, a different configuration is set.  
+**LockJar.list(*args)**: Lists all dependencies as notations for groups from the Jarfile.lock.  Depending on the type of arg, a different configuration is set.  
 * _[String]_ will set the Jarfile.lock path, e.g. `'Better.lock'`. Default lock file is `'Jarfile.lock'`.
-* _[Array<String>]_ will set the scopes, e.g. `['compile','test']`. Defaults scopes are _compile_ and _runtime_.
+* _[Array<String>]_ will set the groups, e.g. `['default', 'runtime']`. Defaults group is _default_.
 * _[Hash]_ will set the options, e.g. `{ :local_repo => 'path' }`
   * **:local_repo** _[String]_ sets the local repo path. Defaults to `ENV['M2_REPO']` or `'~/.m2/repository'`
   * **:local_paths** _[Boolean]_ converts the notations to paths of jars in the local repo
   * **:resolve** _[Boolean]_ to true will make transitive dependences resolve before returning list of jars
   
-**LockJar.load(*args)**: Loads all dependencies to the classpath for scopes from the Jarfile.lock. Defaults scopes are _compile_ and _runtime_. Default lock file is _Jarfile.lock_.
+**LockJar.load(*args)**: Loads all dependencies to the classpath for groups from the Jarfile.lock. Default group is _default_. Default lock file is _Jarfile.lock_.
 * _[String]_ will set the Jarfile.lock, e.g. `'Better.lock'`
-* _[Array<String>]_ will set the scopes, e.g. `['compile','test']`
+* _[Array<String>]_ will set the groups, e.g. `['default', 'runtime']`
 * _[Hash]_ will set the options, e.g. `{ :local_repo => 'path' }`
   * **:local_repo** _[String]_ sets the local repo path
   * **:resolve** _[Boolean]_ to true will make transitive dependences resolve before loading to classpath 
@@ -176,7 +203,7 @@ _lockjar_ _--help_ will give you list of all commands and their options.
 
 ## Gem Integration
 
-### Installing
+### Installing Jars with a Gem
 
 LockJar can be triggered when a Gem is installed by using a [Gem extension](http://docs.rubygems.org/read/chapter/20#extensions)
 of type _Rakefile_. The cavaet is the task to install the jars must be the default for the Rakefile.
@@ -208,16 +235,30 @@ point at the task to download the jars (from the example Rakefile,
 _PostInstallRakefile_ to handle the `task :prepare`. When packaging the gem, _PostInstallRakefile_ is
 renamed to `Rakefile`.
 
+### Manually installing Jars
+
+Instead of rely in a Rakefile to install Jars when the Gem is installed, Jars can be manually installed. The following
+Ruby needs to be called before calling `LockJar.load`. Only Jars that are missing are downloaded.
+
+      #get jarfile relative the gem dir
+      lockfile = File.expand_path( "../Jarfile.lock", __FILE__ ) 
+      
+      # Download any missing Jars
+      LockJar.install( lockfile )
+
 ### Loading
 
-With the Jars already installed, loading the classpath for the Gem is simple. 
+With the Jars installed, loading the classpath for the Gem is simple. 
 As part of the load process for the Gem (an entry file that is required, etc) use the following:
 
       #get jarfile relative the gem dir
       lockfile = File.expand_path( "../Jarfile.lock", __FILE__ ) 
       
+      # Loads the ClassPath with Jars from the lockfile
       LockJar.load( :lockfile => lockfile )
 
+See also [loading Jars into a custom ClassLoader](https://github.com/mguymon/lock_jar/wiki/ClassLoader).
+
 ## Buildr Integration
 
 LockJar integrates with [Buildr](http://buildr.apache.org/) using an [Addon](https://github.com/mguymon/lock_jar/blob/master/lib/lock_jar/buildr.rb). This allows the Jarfile to be defined directly into a _buildfile_. A global LockJar definition can be set and is inherited to all projects. Each project may have its own LockJar definition. A lock file is generated per project based on the project name.
@@ -235,7 +276,7 @@ In a project, you can access an Array of notations using the **lock_jars** metho
     lock_jars()
 
 
-The _compile_ scoped dependencies are automatically added to the classpath for compiling. The test scoped dependencies are automatically added to the classpath for tests. Do not forget, if you change the LockJar definitions, you have to rerun the **lock_jar:lock** task.
+The _default_ group dependencies are automatically added to the classpath for compiling. The _test_ group dependencies are automatically added to the classpath for tests. Do not forget, if you change the LockJar definitions, you have to rerun the **lock_jar:lock** task.
 
 
 ### Example
@@ -247,7 +288,7 @@ Sample buildfile with LockJar
     # app definition, inherited into all projects
     lock_jar do
 
-         scope 'test' do
+         group 'test' do
            jar 'junit:junit:jar:4.10'
          end
     end
@@ -275,8 +316,14 @@ Generated the following lock files using **lock_jar:lock**
   
 ## Bundler Integration
 
-Direct Bundler integration has been deprecated to https://github.com/mguymon/lock_jar/tree/bundler_support. 
-Waiting for [Bundler plugin support](https://github.com/carlhuda/bundler/issues/1945)
+Bundler integration is **experimental** right now. [LockJar patches Bundler](https://github.com/mguymon/lock_jar/blob/master/lib/lock_jar/bundler.rb) 
+to allow creation of a _Jarfile.lock_ when Bundler calls `install` and `update`. The dependencies from the _Jarfile.lock_ are automatically loaded when
+Bundler  calls `setup` and `require`. To enable this support, add this require to your _Gemfile_
+
+    require 'lock_jar/bundler'
+
+You can optionally create a _Jarfile_ that will automatically be included when you `bundle install` or `bundle update`. Otherwise
+Gems with a Jarfile will be merge to generate a _Jarfile.lock_. The Jarfile.lock will be loaded when Bundler calls `setup` or `require`.
 
 ## License
 

data/VERSION

@@ -1 +1 @@
-0.6.2
+0.7.0

data/lib/lock_jar/buildr.rb

@@ -64,7 +64,7 @@ module Buildr
       def lock_jars( *args )
         lockfile = Buildr.project_to_lockfile(project)
         opts = {}
-        scopes = ['compile','runtime']
+        groups = ['default']
           
         args.each do |arg|
           if arg.is_a?(Hash)
@@ -72,11 +72,11 @@ module Buildr
           elsif arg.is_a?( String )
             lockfile = arg
           elsif arg.is_a?( Array )
-            scopes = arg
+            groups = arg
           end
         end
           
-        ::LockJar.list( lockfile, scopes, opts )
+        ::LockJar.list( lockfile, groups, opts )
       end
       
       def lockjar_dsl
@@ -101,7 +101,7 @@ module Buildr
                 end
                 ::LockJar.lock( dsl, :lockfile => "#{project.name}.lock" )
               else
-                # XXX: output that there were not dependencies to lock
+                # XXX: output that there were no dependencies to lock
                 puts "No lock_jar dependencies to lock for #{project.name}" 
               end              
             end      
@@ -110,7 +110,7 @@ module Buildr
               if project.lockjar_dsl && !File.exists?( Buildr.project_to_lockfile(project) )
                 raise "#{project.name}.lock does not exist, run #{project.name}:lockjar:lock first"
               end
-              jars = ::LockJar.list( Buildr.project_to_lockfile(project), ['compile', 'runtime'] )
+              jars = ::LockJar.list( Buildr.project_to_lockfile(project), ['default'] )
               project.compile.with( jars )
             end
             
@@ -118,7 +118,7 @@ module Buildr
               if project.lockjar_dsl && !File.exists?( Buildr.project_to_lockfile(project) )
                 raise "#{Buildr.project_to_lockfile(project)} does not exist, run #{project.name}:lockjar:lock first"
               end
-              jars = ::LockJar.list( Buildr.project_to_lockfile(project), ['compile', 'test', 'runtime'] )
+              jars = ::LockJar.list( Buildr.project_to_lockfile(project), ['test'] )
               
               project.test.compile.with( jars )
               project.test.with( jars )
@@ -128,10 +128,10 @@ module Buildr
               if project.lockjar_dsl && !File.exists?( Buildr.project_to_lockfile(project) )
                 raise "#{Buildr.project_to_lockfile(project)} does not exist, run #{project.name}:lockjar:lock first"
               end
-              jars = ::LockJar.list( Buildr.project_to_lockfile(project), ['compile', 'runtime'] )
+              jars = ::LockJar.list( Buildr.project_to_lockfile(project), ['default'] )
               project.compile.with( jars )
               
-              jars = ::LockJar.list( Buildr.project_to_lockfile(project), ['compile', 'test', 'runtime'] )
+              jars = ::LockJar.list( Buildr.project_to_lockfile(project), ['test'] )
               project.test.compile.with( jars )
             end
         end

data/lib/lock_jar/bundler.rb

@@ -0,0 +1,155 @@
+require 'lock_jar'
+require 'lock_jar/registry'
+require 'lock_jar/domain/lockfile'
+require 'lock_jar/domain/dsl'
+require 'lock_jar/domain/gem_dsl'
+require 'lock_jar/domain/jarfile_dsl'
+require 'lock_jar/domain/dsl_helper'
+
+module LockJar
+  
+  class Bundler
+      
+    class << self
+      
+      attr_accessor :skip_lock
+    
+      def load(*groups)
+        if groups && !groups.empty?  && File.exists?( 'Jarfile.lock')
+          
+          lockfile = LockJar::Domain::Lockfile.read( 'Jarfile.lock' )
+          
+          # expand merged paths to include gem base path
+          unless lockfile.merged.empty?
+            lockfile.merged = LockJar::Bundler.expand_gem_paths( lockfile.merged )
+          end
+          
+          LockJar.load( lockfile, groups )
+          
+          if ENV["DEBUG"]
+            puts "[LockJar] Loaded Jars  for #{groups.inspect}: #{LockJar::Registry.instance.loaded_jars.inspect}"
+          end
+        end
+      end
+      
+      def expand_gem_paths(merged)
+        
+        merged_gem_paths = []
+        Gem.path.each do |gem_root|
+          merged.each do |merge|
+            # merged gems follow the notation: gem:gemname:path
+            if merge.start_with? 'gem:'
+              gem_path = merge.gsub(/^gem:.+:/, '')
+              gem_path = File.join( gem_root, gem_path )
+              if File.exists? gem_path
+                merged_gem_paths << gem_path
+              end
+            end
+          end
+        end
+        
+        merged_gem_paths
+      end
+    end
+  end
+  
+end
+
+module Bundler
+  class << self
+    alias :_lockjar_extended_require :require
+    def require(*groups)
+      LockJar::Bundler.load(*groups)
+      
+      LockJar::Bundler.skip_lock = true
+      
+      _lockjar_extended_require
+    end
+    
+    alias :_lockjar_extended_setup :setup
+    def setup(*groups)
+      LockJar::Bundler.load(*groups)
+      
+      LockJar::Bundler.skip_lock = true
+      
+      _lockjar_extended_setup
+    end
+  end
+  
+  class Runtime
+    
+    alias :_lockjar_extended_require :require
+    def require(*groups)
+      LockJar::Bundler.load(*groups)
+      
+      LockJar::Bundler.skip_lock = true
+      
+      _lockjar_extended_require
+    end
+    
+    alias :_lockjar_extended_setup :setup
+    def setup(*groups)
+      LockJar::Bundler.load(*groups)
+      
+      LockJar::Bundler.skip_lock = true
+      
+      _lockjar_extended_setup
+    end
+  end
+  
+  class Definition
+    alias :_lockjar_extended_to_lock :to_lock
+    def to_lock
+      to_lock = _lockjar_extended_to_lock
+   
+      if LockJar::Bundler.skip_lock != true
+        definition = Bundler.definition
+        #if !definition.send( :nothing_changed? )
+          gems_with_jars = []
+          
+          # load local Jarfile
+          if File.exists?( 'Jarfile' )
+            dsl = LockJar::Domain::JarfileDsl.create( File.expand_path( 'Jarfile' ) )
+            gems_with_jars << 'jarfile:Jarfile'
+          # Create new Dsl
+          else
+            dsl = LockJar::Domain::Dsl.new
+          end
+          
+          definition.groups.each do |group|
+            if ENV["DEBUG"]
+              puts "[LockJar] Group #{group}:"
+            end
+              
+            definition.specs_for( [group] ).each do |spec|
+              gem_dir = spec.gem_dir
+      		
+              jarfile = File.join( gem_dir, "Jarfile" )
+             	
+              if File.exists?( jarfile )
+                gems_with_jars << "gem:#{spec.name}"
+             	  
+                if ENV["DEBUG"]
+                  puts "[LockJar]   #{spec.name} has Jarfile"
+                end
+                
+                spec_dsl = LockJar::Domain::GemDsl.create( spec, "Jarfile" )
+                
+                dsl = LockJar::Domain::DslHelper.merge( dsl, spec_dsl )
+              end 
+            end
+            
+          end
+    
+          puts "[LockJar] Locking Jars for: #{gems_with_jars.inspect}"
+          LockJar.lock( dsl )
+        #elsif ENV["DEBUG"]
+        #  puts "[LockJar] Locking skiped, Gemfile has not changed"
+        #end   
+      end
+      
+      to_lock
+    end
+    
+  end
+end

data/lib/lock_jar/domain/artifact.rb

@@ -0,0 +1,117 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership. The ASF
+# licenses this file to you 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 'set'
+require 'lock_jar/maven'
+require 'naether/notation'
+
+module LockJar
+  module Domain
+    
+    
+    class Artifact
+      include Comparable
+      attr_reader :type
+      
+      def <=>(another_artifact)
+        if another_artifact.is_a? Artifact
+          to_urn <=> another_artifact.to_urn
+        else
+          to_urn <=> another_artifact.to_s
+        end
+      end
+      
+    end
+    
+    class Jar < Artifact
+      attr_reader :notation
+      
+      def initialize( notation )
+        @type = 'jar'
+        @notation = Naether::Notation.new( notation ).to_notation
+      end
+      
+      def to_urn
+        "jar:#{notation}"
+      end
+      
+      def to_dep
+        notation
+      end
+    end
+    
+    class Local < Artifact
+      attr_reader :path
+      def initialize( path )
+        @type = 'local'
+        @path = path
+      end
+      
+      def to_urn
+        "local:#{path}"
+      end
+      
+      def to_dep
+        path
+      end
+    end
+    
+    class Pom < Artifact
+      attr_reader :path, :scopes
+      
+      def initialize( _path, _scopes = ['compile','runtime'] )
+        @type = 'pom'
+        @path = _path
+        @scopes = _scopes
+      end
+      
+      def to_urn
+        "pom:#{path}"
+      end
+      
+      def to_dep
+        { path => scopes }
+      end
+      
+      def notations
+        LockJar::Maven.dependencies( path, scopes )  
+      end
+      
+      def ==(another_artifact)
+        self.<=>(another_artifact) == 0
+      end
+      
+      def <=>(another_artifact)
+        if another_artifact.is_a? Pom
+          if to_urn == another_artifact.to_urn
+            return 0 if Set.new(scopes) == Set.new(another_artifact.scopes)
+            
+            # XXX: this is not a reliable way to compare. 
+            if scopes.size > another_artifact.scopes.size
+              return 1
+            else
+              return -1
+            end
+          else
+            to_urn <=> another_artifact.to_urn
+          end
+        else
+          super
+        end
+      end
+    end
+    
+  end
+end