maven-tools 0.29.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Kristian Meier
+
+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.md

@@ -0,0 +1 @@
+# maven tools [![Build Status](https://secure.travis-ci.org/torquebox/maven-tools.png)](http://travis-ci.org/torquebox/maven-tools) #

data/lib/maven-tools.rb

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

data/lib/maven-tools.rb~

@@ -0,0 +1 @@
+require 'maven_tools/jarfile'

data/lib/maven/jarfile.rb~

@@ -0,0 +1,77 @@
+require 'jbundler/maven_util'
+module JBundler
+
+  class Mavenfile
+    include MavenUtil
+
+    def initialize(file = 'Mvnfile')
+      @file = file
+      @lockfile = file + ".lock"
+    end
+
+    def mtime
+      File.mtime(@file)
+    end
+
+    def exists?
+      File.exists?(@file)
+    end
+
+    def mtime_lock
+      File.mtime(@lockfile)
+    end
+
+    def exists_lock?
+      File.exists?(@lockfile)
+    end
+
+    def load_lockfile
+      _locked = []
+      if exists_lock?
+        File.read(@lockfile).each_line do |line|
+          line.strip!
+          if line.size > 0 && !(line =~ /^\s*#/)
+            _locked << line
+          end
+        end
+      end
+      _locked
+    end
+
+    def locked
+      @locked ||= load_lockfile
+    end
+
+    def locked?(coordinate)
+      coord = coordinate.sub(/^([^:]+:[^:]+):.+/) { $1 }
+      locked.detect { |l| l.sub(/^([^:]+:[^:]+):.+/) { $1 } == coord } != nil
+    end
+
+    def populate_unlocked(aether)
+      File.read(@file).each_line do |line| 
+        if coord = to_coordinate(line)
+          unless locked?(coord)
+            aether.add_artifact(coord)
+          end
+        elsif line =~ /^\s*(repository|source)\s/
+          name, url = line.sub(/.*(repository|source)\s+/, '').gsub(/['":]/,'').split(/,/)
+          url = name unless url
+          aether.add_repository(name, url)
+        end
+      end
+    end
+
+    def populate_locked(aether)
+      locked.each { |l| aether.add_artifact(l) }
+    end
+
+    def generate_lockfile(dependency_coordinates)
+      File.open(@lockfile, 'w') do |f|
+        dependency_coordinates.each do |d|
+          f.puts d.to_s
+        end
+      end
+    end
+  end
+
+end

data/lib/maven/maven_util.rb~

@@ -0,0 +1,56 @@
+module JBundler
+  module MavenUtil
+    
+    def to_coordinate(line)
+      if line =~ /^\s*(jar|pom)\s/
+        
+        group_id, artifact_id, version, second_version = line.sub(/\s*[a-z]+\s+/, '').sub(/#.*/,'').gsub(/\s+/,'').gsub(/['"],/, ':').gsub(/['"]/, '').split(/:/)
+        mversion = second_version ? to_version(version, second_version) : to_version(version)
+        extension = line.strip.sub(/\s+.*/, '')
+        "#{group_id}:#{artifact_id}:#{extension}:#{mversion}"
+      end
+    end
+
+    def to_version(*args)
+      if args.size == 0 || (args.size == 1 && args[0].nil?)
+        "[0,)"
+      else
+        low, high = convert(args[0])
+        low, high = convert(args[1], low, high) if args[1] =~ /[=~><]/
+        if low == high
+          low
+        else
+          "#{low || '[0'},#{high || ')'}"
+        end
+      end
+    end
+    
+    private
+
+    def convert(arg, low = nil, high = nil)
+      if arg =~ /~>/
+        val = arg.sub(/~>\s*/, '')
+        last = val.sub(/\.[^.]+$/, '.99999')
+        ["[#{val}", "#{last}]"]
+      elsif arg =~ />=/
+        val = arg.sub(/>=\s*/, '')
+        ["[#{val}", (nil || high)]
+      elsif arg =~ /<=/
+        val = arg.sub(/<=\s*/, '')
+        [(nil || low), "#{val}]"]
+        # treat '!' the same way as '>' since maven can not describe such range
+      elsif arg =~ /[!>]/  
+        val = arg.sub(/[!>]\s*/, '')
+        ["(#{val}", (nil || high)]
+      elsif arg =~ /</
+        val = arg.sub(/<\s*/, '')
+        [(nil || low), "#{val})"]
+      elsif arg =~ /\=/
+        val = arg.sub(/=\s*/, '')
+        ["[" + val, val + '.0.0.0.0.1)']
+      else
+        [arg, arg]
+      end
+    end
+  end
+end

data/lib/maven/model/dependencies.rb

@@ -0,0 +1,230 @@
+# TODO make nice require after ruby-maven uses the same ruby files
+require File.join(File.dirname(__FILE__), 'utils.rb')
+require File.join(File.dirname(File.dirname(__FILE__)), 'tools', 'coordinate.rb')
+#require 'maven/tools/coordinate'
+
+module Maven
+  module Model
+
+    class DependencyArray < Array
+      def <<(dep)
+        raise "not of type Dependency" unless dep.is_a?(Dependency)
+        d = detect { |item| item == dep }
+        if d
+          d.version = dep.version
+          self
+        else
+          super
+        end
+      end
+      alias :push :<<
+    end
+
+    class ExclusionArray < Array
+      def <<(*dep)
+        excl = dep[0].is_a?(Exclusion) ? dep[0]: Exclusion.new(*dep.flatten)
+        delete_if { |item| item == excl }
+        super excl
+      end
+      alias :push :<<
+    end
+
+    class Coordinate < Tag
+
+      private
+
+      include ::Maven::Tools::Coordinate
+
+      public
+
+      tags :group_id, :artifact_id, :version
+      def initialize(*args)
+        @group_id, @artifact_id, @version = gav(*args.flatten)
+      end
+
+      def version?
+        !(@version.nil? || @version == '[0,)')
+      end
+
+      def hash
+        "#{group_id}:#{artifact_id}".hash
+      end
+
+      def ==(other)
+        group_id == other.group_id && artifact_id == other.artifact_id
+      end
+      alias :eql? :==
+
+    end
+
+    class Parent < Coordinate
+      tags :relative_path
+
+    end
+
+    class Exclusion < Tag
+      tags :group_id, :artifact_id
+      def initialize(*args)
+        @group_id, @artifact_id = group_artifact(*args)
+      end
+
+      def hash
+        "#{group_id}:#{artifact_id}".hash
+      end
+
+      def ==(other)
+        group_id == other.group_id && artifact_id == other.artifact_id
+      end
+      alias :eql? :==
+
+      private
+      
+      include ::Maven::Tools::Coordinate
+    end
+
+    class Dependency < Coordinate
+      tags :type, :scope, :classifier, :exclusions
+      def initialize(type, *args)
+        super(*args)
+        @type = type
+        args.flatten!
+        if args[0] =~ /:/ && args.size == 3
+          @classifier = args[2] unless args[2] =~ /[=~><]/
+        elsif args.size == 4
+          @classifier = args[3] unless args[3] =~ /[=~><]/
+        end
+      end
+
+      def hash
+        "#{group_id}:#{artifact_id}:#{@type}:#{@classifier}".hash
+      end
+
+      def ==(other)
+        super && @type == other.instance_variable_get(:@type) && @classifier == other.instance_variable_get(:@classifier)
+      end
+      alias :eql? :==
+
+      def self.new_gem(gemname, *args)
+        new(:gem, "rubygems", gemname, *args)
+      end
+
+      def self.new_pom(*args)
+        new(:pom, *args)
+      end
+
+      def self.new_jar(*args)
+        new(:jar, *args)
+      end
+
+      def self.new_test_jar(*args)
+        result = new(:jar, *args)
+        result.scope :test
+        result
+      end
+
+      def exclusions(&block)
+        @exclusions ||= ExclusionArray.new
+        if block
+          block.call(@exclusions)
+        end
+        @exclusions
+      end
+
+      def exclude(*args)
+        exclusions << args
+      end
+    end
+
+    module Dependencies
+    
+      def self.included(parent)
+        parent.tags :dependencies
+      end
+
+      def jar?(*args)
+        dependencies.member?(Dependency.new(:jar, *args))
+      end
+
+      def test_jar?(*args)
+        dependencies.member?(Dependency.new_test_jar(*args))
+      end
+
+      def gem?(*args)
+        dependencies.member?(Dependency.new(:gem, ['rubygems', *args].flatten))
+      end
+
+      def detect_gem(name)
+        dependencies.detect { |d| d.type.to_sym == :gem && d.artifact_id == name }
+      end
+
+      def pom?(*args)
+        dependencies.member?(Dependency.new_pom(*args))
+      end
+
+      def dependencies(&block)
+        @dependencies ||= DependencyArray.new
+        if block
+          block.call(self)
+        end
+        @dependencies
+      end
+
+      def add_dependency(dep, has_version = true, &block)
+        d = dependencies.detect { |d| d == dep }
+        if d
+          if has_version
+            d.version = dep.version
+          end
+          dep = d
+        else
+          dependencies << dep
+        end
+        block.call(dep) if block
+        dep
+      end
+      private :add_dependency
+
+      def add_gem(*args, &block)
+        args = args.flatten
+        if args.size == 1
+          dep = Dependency.new_gem(*args)
+          dep = dependencies.detect { |d| d == dep }
+          if dep
+            return dep
+          end
+          args[1] = ">= 0"
+        end
+        add_dependency(Dependency.new_gem(*args), &block)
+      end
+      private :add_gem
+
+      def jar(*args, &block)
+        if args.last.is_a?(Hash)
+          raise "hash not allowed for jar"
+        end
+        add_dependency(Dependency.new_jar(args), args.size > 1, &block)
+      end
+
+      def test_jar(*args, &block)
+        if args.last.is_a?(Hash)
+          raise "hash not allowed for test_jar"
+        end
+        add_dependency(Dependency.new_test_jar(args), args.size > 1, &block)
+      end
+      
+      def gem(*args, &block)
+        if args.last.is_a?(Hash)
+          raise "hash not allowed in that context"
+        end
+        add_gem(args, &block)
+      end
+
+      def pom(*args, &block)
+        if args.last.is_a?(Hash)
+          raise "hash not allowed in that context"
+        end
+        add_dependency(Dependency.new_pom(args), args.size > 1, &block)
+      end
+    end
+  end
+end

data/lib/maven/model/dependencies.rb~

@@ -0,0 +1,247 @@
+require File.join(File.dirname(__FILE__), "..", "tools", 'model.rb')
+
+module Maven
+  module Model
+
+    class DependencyArray < Array
+      def <<(dep)
+        d = detect { |item| item == dep }
+        if d
+          d.version = arg.version
+          self
+        else
+          super
+        end
+      end
+      alias :push :<<
+    end
+
+    class ExclusionArray < Array
+      def <<(dep)
+        excl = dep.is_a?(Exclusion) ? dep: Exclusion.new(dep)
+        d = detect { |item| item == excl }
+        if d
+          delete d
+        end
+        super excl
+      end
+      alias :push :<<
+    end
+
+    class Coordinate < Maven::Tools::Tag
+      tags :group_id, :artifact_id, :version
+      def initialize(*args)
+        @group_id, @artifact_id, @version = *coordinate(*args.flatten)
+      end
+
+      def coordinate(*args)
+        if args[0] =~ /:/
+          [args[0].sub(/:[^:]+$/, ''), args[0].sub(/.*:/, ''), version(*args[1, 2])]
+        else
+          [args[0], args[1], version(*args[2,3])]
+        end
+      end
+
+      def version(*args)
+        if args.size == 0
+          nil
+        else
+          low, high = convert(args[0])
+          low, high = convert(args[1], low, high) if args[1]
+          if low == high
+            low
+          else
+            "#{low || '[0.0.0'},#{high || ')'}"
+          end
+        end
+      end
+
+      def convert(arg, low = nil, high = nil)
+        if arg =~ /~>/
+          val = arg.sub(/~>\s*/, '')
+          last = val.sub(/\.[^.]+$/, '.99999')
+          ["[#{val}", "#{last}]"]
+        elsif arg =~ />=/
+          val = arg.sub(/>=\s*/, '')
+          ["[#{val}", (nil || high)]
+        elsif arg =~ /<=/
+          val = arg.sub(/<=\s*/, '')
+          [(nil || low), "#{val}]"]
+        elsif arg =~ />/
+          val = arg.sub(/>\s*/, '')
+          ["(#{val}", (nil || high)]
+        elsif arg =~ /</
+          val = arg.sub(/<\s*/, '')
+          [(nil || low), "#{val})"]
+        else
+          [arg, arg]
+        end
+      end
+
+      def hash
+        "#{group_id}:#{artifact_id}".hash
+      end
+
+      def ==(other)
+        group_id == other.group_id && artifact_id == other.artifact_id
+      end
+      alias :eql? :==
+    end
+
+    class Exclusion < Maven::Tools::Tag
+      tags :group_id, :artifact_id
+      def initialize(*args)
+        @group_id, @artifact_id = *coordinate(*args)
+      end
+      
+      def coordinate(*args)
+        case args.size
+        when 1
+          name = args[0].sub(/^mvn:/, '')
+          if name =~ /:/
+            [name.sub(/:[^:]+$/, ''), name.sub(/.*:/, '')]
+          else
+            ["rubygems", name]
+          end
+        else
+          [args[0], args[1]]
+        end
+      end
+
+      def hash
+        "#{group_id}:#{artifact_id}".hash
+      end
+
+      def ==(other)
+        group_id == other.group_id && artifact_id == other.artifact_id
+      end
+      alias :eql? :==
+    end
+
+    class Dependency < Coordinate
+      tags :type, :scope, :classifier, :exclusions
+      def initialize(type, *args)
+        super(*args)
+        @type = type
+      end
+
+      def hash
+        "#{group_id}:#{artifact_id}:#{@type}".hash
+      end
+
+      def ==(other)
+        super && @type == other.instance_variable_get(:@type)
+      end
+      alias :eql? :==
+
+      def self.new_gem(gemname, *args)
+        if gemname =~ /^mvn:/
+          new(:maven_gem, gemname.sub(/^mvn:/, ''), *args)
+        else
+          new(:gem, "rubygems", gemname, *args)
+        end
+      end
+
+      def self.new_jar(*args)
+        new(:jar, *args)
+      end
+
+      def self.new_test_jar(*args)
+        new(:test_jar, *args)
+      end
+
+      def exclusions(&block)
+        @exclusions ||= ExclusionArray.new
+        if block
+          block.call(@exclusions)
+        end
+        @exclusions
+      end
+
+    end
+
+    module Dependencies
+    
+      def jar?(*args)
+        dependencies.member?(Dependency.new(:jar, *args))
+      end
+
+      def test_jar?(*args)
+        dependencies.member?(Dependency.new(:test_jar, *args))
+      end
+
+      def gem?(*args)
+        dependencies.member?(Dependency.new(:gem, *args))
+      end
+
+      def maven_gem?(*args)
+        dependencies.member?(Dependency.new(:maven_gem, *args))
+      end
+
+      def dependencies(&block)
+        @dependencies ||= DependencyArray.new
+        if block
+          block.call(@dependencies)
+        end
+        @dependencies
+      end
+
+      def lock_file
+        nil
+      end
+
+      def add_dependency(dep, &block)
+        dependencies << dep
+        block.call(dep) if block
+        dep
+      end
+      private :add_dependency
+
+      def add_gem(*args, &block)
+        if lock_file.nil? #|| !lock_file.hull.member?(args[0])
+          args[1] = ">= 0.0.0" unless args[1]
+          add_dependency(:gem, args, block)
+        else
+          result = add_dependency(:gem, args[0], block)
+         
+          # add its dependencies as well to have the version
+          # determine by the dependencyManagement
+          lock_file.dependency_hull(args[0]).map.each do |d|
+            add_dependency(:gem, d[0], block)
+          end
+
+          result
+        end
+      end
+      private :add_gem
+
+      def jar(*args, &block)
+        if args.last.is_a?(Hash)
+          raise "hash not allowed for jar"
+        end
+        add_dependency(:jar, args, block)
+      end
+
+      def test_jar(*args, &block)
+        if args.last.is_a?(Hash)
+          raise "hash not allowed for test_jar"
+        end
+        add_dependency(:test_jar, args, block)
+      end
+      
+      def gem(*args, &block)
+        if args.last.is_a?(Hash)
+          raise "hash not allowed in that context"
+        end
+        add_gem(args, block)
+      end
+
+      def maven_gem(*args, &block)
+        if args.last.is_a?(Hash)
+          raise "hash not allowed in that context"
+        end
+        add_dependency(:maven_gem, args, block)
+      end
+    end
+  end
+end