pompompom 1.0.0

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+/tmp
+/.bundle
+/pkg
+/TODO

data/Gemfile

@@ -0,0 +1,11 @@
+source :rubygems
+
+gem 'immutable_struct'
+gem 'hpricot'
+
+group :testing do
+  gem 'rspec'
+  gem 'sdoc'
+  gem 'jeweler'
+  gem 'rake'
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Theo Hultberg
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.mdown

@@ -0,0 +1,32 @@
+# Pom Pom Pom
+
+Pom Pom Pom is a basic dependency manager for Maven repository artifacts.
+
+The following code would download `amqp-client-1.8.0.jar` and its dependencies, `commons-cli-1.1.jar` and `commons-io-1.1.jar`, to the directory `lib`:
+
+    dependencies = %w(com.rabbitmq:amqp-client:1.8.0 com.google.inject:guice:2.0)
+    dependencies = dependencies.map { |d| Dependency.parse(d) }
+    repositories = %w(http://repo1.maven.org/maven2)
+    resolver = Resolver.new(repositories)
+    resolver.download('lib', true, *dependencies)
+    
+There will be less verbose ways of doing this in the future. The goal is to be able to use this with rake, like this:
+
+    task :dependencies do
+      pompompom :artifacts => %w(com.rabbitmq:amqp-client:1.8.0 com.google.inject:guice:2.0)
+    end
+    
+Which would do the same as the code above.
+
+There is a command line tool that can be used to install artifacts:
+
+    pompompom com.rabbitmq:amqp-client:1.8.0 com.google.inject:guice:2.0
+    
+It will create a directory called `lib` and download JARs into it. In the future things may be configurable, and POMs will be cached to make things quicker.
+
+## Why another dependency management tool, why not use Maven, Buildr, sbt or Ivy?
+
+Every time I look at Maven I cringe. Buildr is almost as bad, but hides some of the complexity. Ivy is better, but still too much noisy XML.
+
+Pom Pom Pom is meant to do more or less what Ivy does, but in a way that doesn't make you want to tear out your eyes.
+

data/Rakefile

@@ -0,0 +1,7 @@
+$: << File.expand_path('../lib', __FILE__)
+
+require 'pompompom'
+
+task :default => :spec
+
+Dir[File.join(File.dirname(__FILE__), 'tasks', '*.rake')].each { |t| load t }

data/bin/pompompom

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+if File.symlink?(__FILE__)
+  $: << File.expand_path('../../lib', File.readlink(__FILE__))
+else
+  $: << File.expand_path('../../lib', __FILE__)
+end
+
+require 'rubygems'
+
+gem 'hpricot'
+gem 'immutable_struct'
+
+require 'pompompom'
+require 'pompompom/cli'
+
+exit PomPomPom::Cli.new(STDIN, STDOUT, STDERR).run!(*ARGV)

data/lib/pom_pom_pom.rb

@@ -0,0 +1 @@
+require 'pompompom'

data/lib/pompompom/cli.rb

@@ -0,0 +1,87 @@
+module PomPomPom
+  class Cli
+    STANDARD_REPOSITORIES = [
+      'http://repo1.maven.org/maven2/'
+    ]
+    
+    DEFAULT_DESTINATION_DIR = 'lib'
+    
+    def initialize(stdin, stdout, stderr)
+      @stdin, @stdout, @stderr = stdin, stdout, stderr
+      @status_logger = EchoLogger.new(@stderr)
+    end
+    
+    def run!(*args)
+      if args.empty?
+        print_usage
+        return 1
+      end
+
+      resolver = create_resolver
+    
+      create_lib_directory!
+    
+      @status_logger.info("Determining transitive dependencies...")
+    
+      dependencies = parse_dependencies(args)
+      dependencies = resolver.find_transitive_dependencies(*dependencies)
+      dependencies = dependencies.reject { |d| File.exists?(File.join(DEFAULT_DESTINATION_DIR, d.jar_file_name)) }
+    
+      if dependencies.empty?
+        @status_logger.info('All dependencies are met')
+      else
+        dependencies.each do |dependency|
+          @status_logger.info(%(Downloading "#{dependency.to_dependency.to_s}"))
+          resolver.download!(DEFAULT_DESTINATION_DIR, false, dependency)
+        end
+      end
+      
+      return 0
+    rescue => e
+      @status_logger.warn(%(Warning: #{e.message}))
+      return 1
+    end
+    
+  private
+  
+    def create_lib_directory!
+      return if File.directory?(DEFAULT_DESTINATION_DIR)
+      raise %(Cannot create destination, "#{DEFAULT_DESTINATION_DIR}" is a file!) if File.exists?(DEFAULT_DESTINATION_DIR)
+      Dir.mkdir(DEFAULT_DESTINATION_DIR)
+    end
+  
+    def create_resolver
+      Resolver.new(STANDARD_REPOSITORIES, :logger => @status_logger)
+    end
+  
+    def parse_dependencies(args)
+      args.map do |coordinate|
+        begin
+          Dependency.parse(coordinate)
+        rescue ArgumentError => e
+          @status_logger.warn(%(Warning: "#{coordinate}" is not a valid artifact coordinate))
+          nil
+        end
+      end.compact
+    end
+  
+    def print_usage
+      @status_logger.info('Usage: pompompom <group_id:artifact_id:version> [<group_id:artifact_id:version>]')
+    end
+    
+    class EchoLogger
+      def initialize(io)
+        @io = io
+      end
+      
+      def debug(msg); end
+      
+      def info(msg)
+        @io.puts(msg)
+      end
+      
+      alias_method :warn, :info
+      alias_method :fatal, :info
+    end
+  end
+end

data/lib/pompompom/dependency.rb

@@ -0,0 +1,55 @@
+require 'immutable_struct'
+
+
+module PomPomPom
+  class Dependency < ImmutableStruct.new(:group_id, :artifact_id, :version, :packaging, :classifier, :optional, :exclusions)
+    include UrlBuilder
+    
+    def self.parse(artifact_coordinates)
+      raise ArgumentError, %(Malformed artifact coordinate: "#{artifact_coordinates}") if artifact_coordinates.nil? || artifact_coordinates.strip.length == 0
+      components = artifact_coordinates.strip.split(':')
+      raise ArgumentError, %(Malformed artifact coordinate: "#{artifact_coordinates}") if components.size < 3 || components.size > 5
+      case components.size
+      when 3
+        group_id, artifact_id, version = components
+      when 4
+        group_id, artifact_id, packaging, version = components
+      when 5
+        group_id, artifact_id, packaging, classifier, version = components
+      end
+      Dependency.new(group_id, artifact_id, version, packaging, classifier)
+    end
+    
+    def exclusions
+      self[:exclusions] || []
+    end
+    
+    def optional?
+      optional
+    end
+    
+    def has_version?
+      !version.nil?
+    end
+    
+    def same_artifact?(o)
+      o.artifact_id == self.artifact_id && o.group_id == self.group_id
+    end
+    
+    def eql?(o)
+      o.to_s == to_s
+    end
+    
+    def hash
+      to_s.hash
+    end
+    
+    def clone(overrides={})
+      self.class.new(self.to_h.merge(overrides))
+    end
+    
+    def to_s
+      "#{group_id}:#{artifact_id}:#{version}"
+    end
+  end
+end

data/lib/pompompom/downloader.rb

@@ -0,0 +1,15 @@
+require 'open-uri'
+
+module PomPomPom
+  class Downloader
+    def get(url)
+      open(url).read
+    end
+  end
+  
+  class FilesystemDownloader
+    def get(path)
+      File.read(path) if File.exists?(path)
+    end
+  end
+end

data/lib/pompompom/metadata.rb

@@ -0,0 +1,26 @@
+module PomPomPom
+  class Metadata
+    def initialize(io)
+      @io = io
+    end
+    
+    def parse!
+      doc = Hpricot.XML(@io)
+      versioning = doc.at('/metadata/versioning')
+      if versioning
+        release = versioning.at('release/text()')
+        if release
+          @latest_version = release.to_s
+        else
+          @latest_version = versioning.search('versions/version/text()').map(&:to_s).sort.last
+        end
+      else
+        @latest_version = doc.at('/metadata/version/text()').to_s
+      end
+    end
+    
+    def latest_version
+      @latest_version
+    end
+  end
+end

data/lib/pompompom/pom.rb

@@ -0,0 +1,234 @@
+require 'hpricot'
+
+
+module PomPomPom
+  class Pom
+    include UrlBuilder
+    
+    PROPERTIES = [:group_id, :artifact_id, :version, :name, :description, :url, :packaging]
+    
+    attr_reader *PROPERTIES
+    attr_reader :parent
+    
+    def initialize(io, defaults={})
+      @io = io
+      merge_defaults!(defaults)
+    end
+
+    def parse!
+      doc = Hpricot.XML(@io)
+      parse_properties!(doc)
+      parse_meta!(doc)
+      parse_parent!(doc)
+      parse_dependency_management!(doc)
+      parse_dependencies!(doc)
+    end
+    
+    def dependencies(scope = :default)
+      @dependencies.fetch(scope, []).dup
+    end
+    
+    def exclusions
+      []
+    end
+    
+    def has_parent?
+      !!parent
+    end
+    
+    def group_id
+      @group_id || parent.group_id
+    end
+    
+    def artifact_id
+      @artifact_id || parent.artifact_id
+    end
+    
+    def version
+      @version || parent.version
+    end
+    
+    def properties
+      if has_parent? && @parent.respond_to?(:properties)
+        @parent.properties.merge(@properties)
+      else
+        @properties || {}
+      end
+    end
+    
+    def to_dependency
+      Dependency.new(
+        :group_id => group_id,
+        :artifact_id => artifact_id, 
+        :version => version, 
+        :packaging => packaging,
+        :dependencies => dependencies
+      )
+    end
+    
+    def merge(parent)
+      defaults = Hash[*PROPERTIES.map { |p| [p, self.send(p) || parent.send(p)] }.flatten]
+      defaults = defaults.merge(
+        :parent => parent,
+        :dependencies => @dependencies.dup,
+        :dependency_management => @dependency_management.dup,
+        :properties => @properties.dup
+      )
+      self.class.new(nil, defaults)
+    end
+    
+    def to_s
+      to_dependency.to_s
+    end
+    
+  protected
+  
+    def resolve_version(dependency)
+      @dependency_management.find { |d| d.same_artifact?(dependency) } || dependency
+    end
+    
+  private
+
+    def camelize(str)
+      if str.include?('_')
+        components = str.split('_')
+        components.first + components[1..-1].map { |s| s.capitalize }.join('')
+      else
+        str
+      end
+    end
+    
+    def snakeify(str)
+      str.gsub(/([a-z])([A-Z])/) do |match|
+        "#{$1}_#{$2.downcase}"
+      end
+    end
+    
+    def merge_defaults!(defaults)
+      @parent = defaults[:parent]
+      @dependency_management = defaults.fetch(:dependency_management, [])
+      @properties = defaults.fetch(:properties, [])
+      
+      PROPERTIES.each do |p|
+        if defaults.has_key?(p)
+          value = defaults[p]
+          value = expand_properties(value) if value
+          instance_variable_set('@' + p.to_s, value)
+        end
+      end
+      
+      default_dependencies = defaults.fetch(:dependencies, {})
+
+      @dependencies = default_dependencies.keys.inject({}) do |deps, scope|
+        deps[scope] = default_dependencies[scope].map do |dependency|
+          dependency = dependency.clone(
+            :group_id    => expand_properties(dependency.group_id),
+            :artifact_id => expand_properties(dependency.artifact_id),
+            :version     => expand_properties(dependency.version)
+          )
+          
+          if dependency.has_version?
+            dependency
+          elsif @parent
+            @parent.resolve_version(dependency)
+          end
+        end
+        deps
+      end
+    end
+
+    def parse_properties!(doc)
+      @properties = {}
+      doc.search('/project/properties/*').each do |property_node|
+        if property_node.elem?
+          @properties[property_node.name] = property_node.inner_text.to_s
+        end
+      end
+    end
+
+    def parse_meta!(doc)
+      properties = PROPERTIES.map { |p| [p.to_s, camelize(p.to_s)] }
+      properties.each do |property, tag_name|
+        val = doc.at("/project/#{tag_name}/text()")
+        instance_variable_set('@' + property, expand_properties(val.to_s)) if val
+      end
+    end
+    
+    def parse_parent!(doc)
+      parent_node = doc.at("/project/parent")
+      @parent = parse_dependency(parent_node) if parent_node
+    end
+
+    def parse_dependencies!(doc)
+      doc.search('/project/dependencies/dependency').each do |dep_node|
+        scope = parse_scope(dep_node)
+        @dependencies[scope] ||= []
+        @dependencies[scope] << parse_dependency(dep_node)
+      end
+    end
+    
+    def parse_dependency_management!(doc)
+      doc.search('/project/dependencyManagement/dependencies/dependency').each do |dep_node|
+        @dependency_management << parse_dependency(dep_node)
+      end
+    end
+    
+    def parse_dependency(dep_node)
+      Dependency.new(
+        :group_id    => parse_attr(dep_node, 'groupId'),
+        :artifact_id => parse_attr(dep_node, 'artifactId'),
+        :version     => parse_version(dep_node),
+        :optional    => parse_attr(dep_node, 'optional').downcase == 'true',
+        :exclusions  => parse_exclusions(dep_node)
+      )
+    end
+    
+    def parse_attr(dep_node, attr_name)
+      str = expand_properties(dep_node.at("#{attr_name}/text()").to_s)
+    end
+    
+    def expand_properties(str)
+      return nil if str.nil?
+      str.gsub(/\$\{([.\w]+)\}/) do |match|
+        property_value($1)
+      end
+    end
+    
+    def property_value(property_name)
+      custom_properties = {'version' => @version}.merge(properties)
+      if custom_properties.has_key?(property_name)
+        custom_properties[property_name]
+      else
+        components = property_name.split('.')
+        if components.first == 'project' && components.size == 2 && self.respond_to?(snakeify(components[1]))
+          self.send(snakeify(components[1]))
+        elsif components.first == 'env' && components.size == 2
+          ENV[components[1]]
+        #elsif components.first == 'settings' # not yet supported
+        else
+          "${#{property_name}}"
+        end
+      end
+    end
+
+    def parse_version(dep_node)
+      v = parse_attr(dep_node, 'version')
+      if v.length == 0 then nil else v end
+    end
+    
+    def parse_scope(dep_node)
+      scope = parse_attr(dep_node, 'scope')
+      scope = 'default' if scope.nil? || scope.strip.length == 0
+      scope.to_sym
+    end
+    
+    def parse_exclusions(dep_node)
+      dep_node.search('exclusions/exclusion').map do |excl_node|
+        Dependency.new(
+          parse_attr(excl_node, 'groupId'),
+          parse_attr(excl_node, 'artifactId')
+        )
+      end
+    end
+  end
+end

data/lib/pompompom/resolver.rb

@@ -0,0 +1,149 @@
+module PomPomPom
+  class Resolver
+    class JarNotFoundError < StandardError; end
+    class DependencyNotFoundError < StandardError; end
+    
+    def initialize(repositories, options={})
+      @repositories, @logger, @downloader = repositories, (options[:logger] || NullLogger.new), (options[:downloader] || Downloader.new)
+      raise ArgumentError, 'No repositories given!' if repositories.nil? || repositories.empty?
+    end
+    
+    def download!(target_dir, transitive, *dependencies)
+      create_target_directory(target_dir)
+      all_dependencies = if transitive then find_transitive_dependencies(*dependencies) else dependencies end
+      all_dependencies.each do |pom|
+        destination = File.join(target_dir, "#{pom.artifact_id}-#{pom.version}.jar")
+        JarDownloader.new(pom, destination, @repositories, @downloader, @logger).download!
+      end
+    end
+    
+    def find_transitive_dependencies(*dependencies)
+      resolver = PomResolver.new(dependencies, @repositories, @downloader, @logger)
+      filter_newest(group_by_artifact(resolver.all_poms))
+    end
+    
+  private
+  
+    def filter_newest(pom_groups)
+      pom_groups.map do |id, poms|
+        if poms.size > 1
+          newest = poms.sort { |a, b| a.version <=> b.version }.reverse.first
+          @logger.warn(%(Warning: multiple versions of #{id} were required, using the newest required version (#{newest.version})))
+          newest
+        else
+          poms.first
+        end
+      end.flatten
+    end
+  
+    def group_by_artifact(poms)
+      poms.inject({}) do |acc, pom|
+        id = "#{pom.group_id}:#{pom.artifact_id}"
+        acc[id] ||= []
+        acc[id] << pom
+        acc
+      end
+    end
+  
+    def create_target_directory(target_dir)
+      return if File.directory?(target_dir)
+      raise 'Cannot create target directory because it already exists (but is not a directory)' if File.exists?(target_dir)
+      Dir.mkdir(target_dir)
+    end
+  
+    def args_and_options(*args)
+      if Hash === args.last
+        options = args.pop
+      end
+      [args, options || {}]
+    end
+  
+    class NullLogger
+      def debug(msg); end
+      def info(msg); end
+      def warn(msg); end
+    end
+  
+    class PomResolver
+      def initialize(dependencies, repositories, downloader, logger)
+        @dependencies, @repositories, @downloader, @logger = dependencies, repositories, downloader, logger
+      end
+      
+      def all_poms
+        @dependencies.map { |d| resolve_dependencies(d) }.flatten
+      end
+      
+    private
+      
+      def resolve_dependencies(dependency)
+        pom = nil
+        @repositories.detect do |repository|
+          if dependency.has_version?
+            d = dependency
+          else
+            d = find_latest(dependency, repository)
+          end
+          pom = get_pom(repository, d)
+          pom
+        end
+        raise DependencyNotFoundError, "Could not find POM for #{dependency} in any repository" unless pom
+        transitive_dependencies = pom.dependencies.reject do |d|
+          d.optional? || dependency.exclusions.any? { |dd| dd.artifact_id == d.artifact_id }
+        end
+        [pom] + transitive_dependencies.map { |d| resolve_dependencies(d) }
+      end
+      
+      def find_latest(dependency, repository)
+        @logger.info(%(Finding latest version for #{dependency.group_id}:#{dependency.artifact_id}))
+        url = dependency.metadata_url(repository)
+        metadata = Metadata.new(@downloader.get(url))
+        metadata.parse!
+        dependency.clone(:version => metadata.latest_version)
+      rescue => e
+        @logger.warn(%(Could not donwload "#{url}": #{e.message}))
+      end
+      
+      def get_pom(repository, dependency)
+        url = dependency.pom_url(repository)
+        @logger.debug(%(Loading POM from "#{url}"))
+        data = @downloader.get(url)
+        if data
+          pom = Pom.new(StringIO.new(data))
+          pom.parse!
+          if pom.has_parent?
+            parent = get_pom(repository, pom.parent)
+            pom = pom.merge(parent)
+          end
+          pom
+        else
+          nil
+        end
+      rescue => e
+        @logger.debug(%(Could not download "#{url}": #{e.message}))
+        nil
+      end
+    end
+    
+    class JarDownloader
+      def initialize(pom, local_path, repositories, downloader, logger)
+        @pom, @local_path, @repositories, @downloader, @logger = pom, local_path, repositories, downloader, logger
+      end
+      
+      def download!
+        data = nil
+        @repositories.detect do |repository|
+          url = @pom.jar_url(repository)
+          @logger.debug(%(Loading JAR from "#{url}"))
+          begin
+            data = @downloader.get(url)
+          rescue => e
+            @logger.debug(%(Could not download "#{url}": #{e.message}))
+          end
+          data
+        end
+        raise JarNotFoundError, "Could not download JAR for #{@pom.to_dependency} in any repository" unless data
+        File.open(@local_path, 'w') { |f| f.write(data) }
+      end
+    end
+  end
+end