buildr-dependency-extensions 0.2

data/buildr-dependency-extensions.gemspec

@@ -0,0 +1,30 @@
+unless defined?(BuildrDepenencyExtensions::VERSION)
+  require File.join(File.dirname(__FILE__), 'lib', 'buildr-dependency-extensions', 'version')
+end
+
+Gem::Specification.new do |spec|
+  spec.name           = 'buildr-dependency-extensions'
+  spec.version        = BuildrDependencyExtensions::VERSION.dup
+  spec.author         = 'John Shahid'
+  spec.email          = "jvshahid@gmail.com"
+  spec.homepage       = "https://github.com/jvshahid/transitive-buildr"
+  spec.summary        = "A Buildr extension that enables transitive dependency resolution by default"
+
+  # Rakefile needs to create spec for both platforms (ruby and java), using the
+  # $platform global variable.  In all other cases, we figure it out from RUBY_PLATFORM.
+  spec.platform       = $platform || RUBY_PLATFORM[/java/] || 'ruby'
+
+  spec.files                 = Dir['{lib,spec}/**/*', '*.{gemspec}']
+  spec.require_paths  = ['lib']
+
+  spec.has_rdoc         = false
+
+  # Tested against these dependencies.
+  spec.add_dependency 'rake',                 '0.8.7'
+  spec.add_dependency 'buildr',               '>= 1.4.5'
+  spec.add_dependency 'xml-simple',           '~> 1.0.12'
+  spec.add_dependency 'rspec-expectations',   '2.1.0'
+  spec.add_dependency 'rspec-mocks',          '2.1.0'
+  spec.add_dependency 'rspec-core',           '2.1.0'
+  spec.add_dependency 'rspec',                '2.1.0'
+end

data/lib/buildr-dependency-extensions.rb

@@ -0,0 +1,9 @@
+require 'buildr-dependency-extensions/helper'
+require 'buildr-dependency-extensions/resolver'
+require 'buildr-dependency-extensions/transitive-buildr'
+require 'buildr-dependency-extensions/pom-generator'
+require 'buildr-dependency-extensions/artifact'
+require 'buildr-dependency-extensions/pom'
+require 'buildr-dependency-extensions/dependency_caching'
+
+include BuildrDependencyExtensions

data/lib/buildr-dependency-extensions/artifact.rb

@@ -0,0 +1,9 @@
+require 'buildr/packaging/artifact.rb'
+
+class Buildr::Artifact
+  def excludes(*artifacts)
+    @excludes ||= []
+    @excludes = @excludes + artifacts
+    self
+  end
+end

data/lib/buildr-dependency-extensions/dependency_caching.rb

@@ -0,0 +1,48 @@
+require 'yaml'
+
+module BuildrDependencyExtensions
+  class DependencyCaching
+    def initialize project
+      @project = project
+    end
+
+    def write_cache
+      dependencies_cache = {}
+      dependencies_cache['runtime'] = @project.run.classpath.
+        select {|dep| HelperFunctions.is_artifact?(dep)}.
+        map    {|dep| dep.to_spec}
+
+      dependencies_cache['compile'] = @project.compile.dependencies.to_a.
+        select {|dep| HelperFunctions.is_artifact?(dep)}.
+        map    {|dep| dep.to_spec}
+
+      dependencies_cache['test'] = @project.test.dependencies.to_a.
+        select {|dep| HelperFunctions.is_artifact?(dep)}.
+        map    {|dep| dep.to_spec}
+
+      dependency_caching_filename = @project.path_to('dependency.cache')
+      FileUtils.mkdir_p(File.dirname(dependency_caching_filename))
+      f = File.new(dependency_caching_filename, 'w')
+      f.write(dependencies_cache.to_yaml)
+      f.close
+    end
+
+    def read_cache
+      begin
+        dependency_caching_filename = @project.path_to('dependency.cache')
+        dependdencies_cache = YAML.load_file(dependency_caching_filename)
+
+        runtime_dependencies = dependdencies_cache['runtime']
+        compile_dependencies = dependdencies_cache['compile']
+        test_dependencies = dependdencies_cache['test']
+
+        dependdencies_cache['runtime'] = runtime_dependencies.map {|dep| @project.artifact(dep)}
+        dependdencies_cache['compile'] = compile_dependencies.map {|dep| @project.artifact(dep)}
+        dependdencies_cache['test']    = test_dependencies.map {|dep| @project.artifact(dep)}
+        dependdencies_cache
+      rescue Errno::ENOENT
+        nil
+      end
+    end
+  end
+end

data/lib/buildr-dependency-extensions/helper.rb

@@ -0,0 +1,80 @@
+require 'buildr/packaging/artifact'
+
+module BuildrDependencyExtensions
+  module HelperFunctions
+    # Change the version number to 0 and invoke uniq on the resulting array to get a unique set of artifacts (ignoring the version number)
+    def HelperFunctions.get_unique_group_artifact set
+      new_set = set.map { |artifact| hash = Artifact.to_hash(artifact); hash[:version] = 0; Artifact.to_spec(hash) }
+      new_set.uniq
+    end
+
+    # returns all versions of artifact in original_set sorted using the Version sorting order
+    def HelperFunctions.get_all_versions artifact, original_set
+      original_artifact_hash = Artifact.to_hash(artifact)
+
+      new_set = original_set.select do |candidate_artifact|
+        candidate_hash = Artifact.to_hash(candidate_artifact)
+        candidate_hash[:group] == original_artifact_hash[:group] &&
+          candidate_hash[:id] == original_artifact_hash[:id]  &&
+          candidate_hash[:type] == original_artifact_hash[:type] &&
+          candidate_hash[:classifier] == original_artifact_hash[:classifier]
+      end
+
+      new_set = new_set.uniq.sort.reverse
+      new_set.
+        map { |artifact| Artifact.to_hash(artifact)[:version] }.
+        map { |version_string| Version.new version_string}
+    end
+
+    def HelperFunctions.get_all_versions_sorted_by_depth artifact, original_set
+      original_artifact_hash = Artifact.to_hash(artifact)
+
+      new_set = original_set.select do |candidate_artifact|
+        candidate_hash = Artifact.to_hash(candidate_artifact)
+        candidate_hash[:group] == original_artifact_hash[:group] &&
+          candidate_hash[:id] == original_artifact_hash[:id]  &&
+          candidate_hash[:type] == original_artifact_hash[:type] &&
+          candidate_hash[:classifier] == original_artifact_hash[:classifier]
+      end
+
+      new_set = new_set.uniq
+      # Sort using the version first, so in case of conflict we use the higher version
+      new_set = new_set.sort {|x,y| Version.new(x.to_hash[:version]) <=> Version.new(x.to_hash[:version])}.reverse
+      new_set = new_set.sort {|x,y| x.depth <=> y.depth}
+      new_set.
+        map { |artifact| Artifact.to_hash(artifact)[:version] }.
+        map { |version_string| Version.new version_string}
+    end
+
+    def HelperFunctions.is_artifact? task
+      task.respond_to?(:to_spec) && task.respond_to?(:to_hash)
+    end
+
+  end
+
+  # Parses the version string and provides a natural ordering for versions
+  class Version
+    include Comparable
+
+    attr_reader :version_array, :version_string
+
+    def initialize version_string
+      @version_string = version_string
+      @version_array = version_string.split('.')
+    end
+
+    def <=> other_version
+      @version_array <=> other_version.version_array
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      @version_string.hash
+    end
+
+    def to_s
+      @version_string
+    end
+  end
+end

data/lib/buildr-dependency-extensions/pom-generator.rb

@@ -0,0 +1,80 @@
+require 'buildr/core/project'
+require 'rubygems'
+require 'xmlsimple'
+
+module BuildrDependencyExtensions
+  module PomGenerator
+
+    include Extension
+
+    def self.extended(base)
+      class << base
+        def extra_pom_sections
+          @extra_pom_sections ||= {}
+        end
+      end
+      super
+    end
+
+    # We have to run the pom generator first before the dependencies are
+    # changed in the compile, test and run after_define
+    after_define(:compile => :'pom-generator')
+    after_define(:'pom-generator') do |project|
+      generate_pom project
+    end
+
+    module_function
+
+    def compile_dependencies project
+      project.compile.dependencies.select {|dep| HelperFunctions.is_artifact? dep}
+    end
+
+    def runtime_dependencies project
+      project.run.classpath.select {|dep| HelperFunctions.is_artifact? dep}
+    end
+
+    def test_dependencies project
+      project.test.dependencies.select {|dep| HelperFunctions.is_artifact? dep}
+    end
+
+    def generate_dependencies_hash dependencies, scope
+      dependencies.map do |dep|
+        { 'groupId'    => dep.to_hash[:group],
+          'artifactId' => dep.to_hash[:id],
+          'version'    => dep.to_hash[:version],
+          'scope'      => scope,
+          'type'       => dep.to_hash[:type]
+        }
+      end
+    end
+
+    def generate_pom project
+      compile_dependencies =  compile_dependencies project
+      runtime_dependencies =  runtime_dependencies project
+      test_dependencies    =  test_dependencies    project
+
+      dependencies_hashes  = generate_dependencies_hash compile_dependencies, 'compile'
+      dependencies_hashes += generate_dependencies_hash runtime_dependencies, 'runtime'
+      dependencies_hashes += generate_dependencies_hash test_dependencies,    'test'
+
+      pom_hash = {
+        'modelVersion' => '4.0.0',
+        'groupId'      => project.group,
+        'artifactId'   => project.name,
+        'version'      => project.version,
+        'dependencies' => {'dependency' => dependencies_hashes.to_a}
+      }
+
+      project.extra_pom_sections.each {|key, value| pom_hash[key] = value}
+
+      my_pom = file(project.path_to(:target, 'pom.xml')) do |f|
+        FileUtils.mkdir_p(File.dirname(f.name)) unless f.exist?
+        File.open(f.name, 'w') do |file|
+          file.write(XmlSimple.xml_out(pom_hash, {'RootName' => 'project', 'NoAttr' => true}))
+        end
+      end
+
+      project.package.pom.from my_pom
+    end
+  end
+end

data/lib/buildr-dependency-extensions/pom.rb

@@ -0,0 +1,32 @@
+require 'buildr/java/pom'
+
+class Buildr::POM
+  def declared_dependencies(scopes)
+    #try to cache dependencies also
+    @declared_depends_for_scopes ||= {}
+    unless depends = @declared_depends_for_scopes[scopes]
+      declared = project["dependencies"].first["dependency"] rescue nil
+      depends = (declared || []).reject { |dep| value_of(dep["optional"]) =~ /true/ }
+      depends = depends.map do |dep|
+        spec = pom_to_hash(dep, properties)
+        apply = managed(spec)
+        spec = apply.merge(spec) if apply
+
+        #calculate transitive dependencies
+        if scopes.include?(spec[:scope])
+          exclusions = dep["exclusions"]["exclusion"] rescue nil
+          artifact = Artifact.to_spec(spec)
+
+          if exclusions
+            excuded_artifacts = exclusions.map {|exclusion| artifact("#{exclusion['groupId']}:#{exclusion['artifactId']}:jar:1.0")}
+            artifact.excludes(*excuded_artifacts)
+          end
+        end
+        artifact
+      end
+      depends = depends.compact
+      @declared_depends_for_scopes[scopes] = depends
+    end
+    depends
+  end
+end

data/lib/buildr-dependency-extensions/resolver.rb

@@ -0,0 +1,44 @@
+module BuildrDependencyExtensions
+  class ResolverBase
+    def initialize
+      @hash = {}
+    end
+
+    def resolve_from_hash artifact
+      @hash[artifact]
+    end
+
+    def resolved artifact, version
+      # @hash[artifact] = version
+    end
+  end
+
+  class HighestVersionConflictResolver < ResolverBase
+    def resolve artifact, all_artifacts
+      version = resolve_from_hash artifact
+      if version
+        version
+      else
+        all_versions = HelperFunctions.get_all_versions(artifact, all_artifacts).uniq
+        if all_versions.size > 1
+          puts $terminal.color("Warning: found versions #{all_versions.join(', ')} for artifact #{artifact}. Choosing #{all_versions[0]}", :yellow)
+        end
+        resolved artifact, all_versions[0]
+        all_versions[0]
+      end
+    end
+  end
+
+  class MavenVersionConflictResolver < ResolverBase
+    def resolve artifact, all_artifacts
+      version = resolve_from_hash artifact
+      if version
+        version
+      else
+        all_versions = HelperFunctions.get_all_versions_sorted_by_depth(artifact, all_artifacts).uniq
+        resolved artifact, all_versions[0]
+        all_versions[0]
+      end
+    end
+  end
+end

data/lib/buildr-dependency-extensions/transitive-buildr.rb

@@ -0,0 +1,125 @@
+require 'buildr/core/project'
+require 'yaml'
+
+module BuildrDependencyExtensions
+  module TransitiveDependencies
+
+    @dependency_pom_cache = {}
+
+    include Extension
+
+    def self.extended(base)
+      class << base
+
+        attr_accessor :transitive_scopes
+        attr_accessor :cache_dependencies
+
+        def conflict_resolver
+          # @conflict_resolver ||= HighestVersionConflictResolver.new
+          @conflict_resolver ||= MavenVersionConflictResolver.new
+        end
+      end
+      super
+    end
+
+    after_define(:'transitive-dependencies' => :run) do |project|
+      now = Time.now
+      if project.transitive_scopes
+        dependency_caching = DependencyCaching.new(project)
+        dependency_cache = dependency_caching.read_cache
+        unless dependency_cache && project.cache_dependencies
+          resolve_compile_dependencies project if project.transitive_scopes.include? :compile
+          resolve_runtime_dependencies project if project.transitive_scopes.include? :run
+          resolve_test_dependencies    project if project.transitive_scopes.include? :test
+          dependency_caching.write_cache
+        else
+          if project.transitive_scopes.include? :run
+            project.run.classpath = project.run.classpath.reject {|dependency| HelperFunctions.is_artifact?(dependency)}
+            project.run.classpath += dependency_cache['runtime']
+          end
+          if project.transitive_scopes.include? :compile
+            project.compile.dependencies = project.compile.dependencies.reject {|dependency| HelperFunctions.is_artifact?(dependency)}
+            project.compile.dependencies += dependency_cache['compile']
+          end
+          if project.transitive_scopes.include? :test
+            project.test.dependencies = project.test.dependencies.reject {|dependency| HelperFunctions.is_artifact?(dependency)}
+            project.test.dependencies += dependency_cache['test']
+
+            project.test.compile.dependencies = project.test.compile.dependencies.reject {|dependency| HelperFunctions.is_artifact?(dependency)}
+            project.test.compile.dependencies += dependency_cache['test']
+          end
+        end
+      end
+      trace "Adding transitive dependencies took #{Time.now - now} seconds"
+    end
+
+    module_function
+
+    def resolve_compile_dependencies project
+      original_file_tasks   = project.compile.dependencies.reject {|dep| HelperFunctions.is_artifact? dep }
+      original_dependencies = project.compile.dependencies.select {|dep| HelperFunctions.is_artifact? dep }
+      new_dependencies = []
+      original_dependencies.each do |dependency|
+        add_dependency project, new_dependencies, dependency, [nil, "compile"]
+      end
+      new_dependencies = resolve_conflicts(project, new_dependencies.uniq)
+      project.compile.dependencies = new_dependencies + original_file_tasks
+    end
+
+    def resolve_runtime_dependencies project
+      original_file_tasks   = project.run.classpath.reject {|dep| HelperFunctions.is_artifact? dep }
+      original_dependencies = project.run.classpath.select {|dep| HelperFunctions.is_artifact? dep }
+      new_dependencies = []
+      original_dependencies.each do |dependency|
+        add_dependency project, new_dependencies, dependency, [nil, "compile", "runtime"]
+      end
+      new_dependencies = resolve_conflicts(project, new_dependencies.uniq)
+      project.run.classpath = new_dependencies + original_file_tasks
+    end
+
+    def resolve_test_dependencies project
+      original_file_tasks   = project.test.dependencies.reject {|dep| HelperFunctions.is_artifact? dep }
+      original_test_compile_file_tasks = project.test.compile.dependencies.reject {|dep| HelperFunctions.is_artifact? dep }
+      original_dependencies = project.test.dependencies.select {|dep| HelperFunctions.is_artifact? dep }
+      new_dependencies = []
+      original_dependencies.each do |dependency|
+        add_dependency project, new_dependencies, dependency, [nil, "compile", "runtime"]
+      end
+      new_dependencies = resolve_conflicts(project, new_dependencies.uniq)
+      project.test.dependencies = new_dependencies + original_file_tasks
+      project.test.compile.dependencies = new_dependencies + original_test_compile_file_tasks
+    end
+
+    def add_dependency project, new_dependencies, dependency, scopes, depth = 0
+      scopes.each do |scope|
+        if (!@dependency_pom_cache[dependency])
+          @dependency_pom_cache[dependency] = POM.load(dependency.pom)
+        end
+        @dependency_pom_cache[dependency].declared_dependencies([scope]).each do |dep|
+          artifact = project.artifact(dep)
+          excludes = dependency.instance_variable_get(:@excludes) || []
+          matching_dependency = excludes.select do |excluded_dep|
+            excluded_dep.to_hash[:id] == artifact.to_hash[:id] &&
+              excluded_dep.to_hash[:group] == artifact.to_hash[:group]
+          end
+          add_dependency project, new_dependencies, artifact, scopes, (depth + 1) if matching_dependency.empty?
+        end
+      end
+      class << dependency
+        attr_accessor :depth
+      end
+      dependency.depth = depth
+      new_dependencies << dependency
+    end
+
+    def resolve_conflicts project, dependencies
+      unique_transitive_artifacts = HelperFunctions.get_unique_group_artifact(dependencies)
+      new_scope_artifacts = unique_transitive_artifacts.map do |artifact|
+        artifact_hash = Artifact.to_hash(artifact)
+        artifact_hash[:version] = project.conflict_resolver.resolve(artifact, dependencies)
+        project.artifact(Artifact.to_spec(artifact_hash))
+      end
+      new_scope_artifacts
+    end
+  end
+end