maven-tools 0.31.0 → 0.32.0

data/lib/maven/maven_util.rb~

@@ -1,56 +0,0 @@
-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~

@@ -1,247 +0,0 @@
-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

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

@@ -1,528 +0,0 @@
-# TODO make nice require after ruby-maven uses the same ruby files
-require File.join(File.dirname(__FILE__), 'dependencies.rb')
-#require 'maven/model/dependencies'
-
-module Maven
-  module Model
-
-    class Build < Tag
-      tags :source_directory, :script_source_directory, :test_source_directory, :output_directory, :test_output_directory, :default_goal, :directory, :final_name, :plugins, :plugin_management
-
-      def plugins(&block)
-        @plugins ||= PluginHash.new
-        if block
-          block.call(@plugins)
-        end
-        @plugins
-      end
-
-      def plugin?(name)
-        plugins.key?(name)
-      end
-
-      def plugin_management(&block)
-        @plugin_management ||= PluginManagement.new
-        if block
-          block.call(@plugin_management)
-        end
-        @plugin_management
-      end
-
-      def to_xml(buf = "", indent = "")
-        if @final_name.nil? && (@plugins.nil? || @plugins.size == 0) && @plugin_management.nil? #TODO check the rest
-          ""
-        else
-          super
-        end
-      end
-    end
-
-    class PluginManagement < Tag
-      tags :plugins
-
-      def plugins(&block)
-        @plugins ||= PluginHash.new
-        if block
-          block.call(@plugins)
-        end
-        @plugins
-      end
-
-      def plugin?(name)
-        plugins.key?(name)
-      end
-
-      def to_xml(buf = "", indent = "")
-        if @plugins.nil? || @plugins.size == 0
-          ""
-        else
-          super
-        end
-      end
-
-      def _name
-        "pluginManagement"
-      end
-    end
-
-    class Plugin < Coordinate
-      tags :extensions, :configuration, :executions
-
-      include Dependencies
-
-      def initialize(*args, &block)
-        super(*args)
-        raise "plugin version must be a concrete version" if version =~ /^[\[\(].+,.*[\]\)]$/
-        if block
-          block.call(self)
-        end
-        self
-      end
-
-      def with(config)
-        self.configuration config
-      end
-
-      def in_phase(phase, name = nil, &block)
-        name = "in_phase_#{phase.to_s.gsub(/-/,'_')}" unless name
-        self.executions.get(name) do |exe|
-          exe.phase = phase
-          block.call(exe) if block
-          exe
-        end
-      end
-
-      def execute_goal(goal)
-        execution.execute_goal(goal)
-      end
-
-      def executions
-        @executions ||= ModelHash.new(Execution)
-      end
-
-      def execution(name = nil, &block)
-        executions.get(name, &block)
-      end
-
-      def configuration(c = nil)
-        @configuration = Configuration.new(c) if c
-        @configuration ||= Configuration.new({})
-      end
-    end
-
-    class Execution < Tag
-      tags :id, :phase, :goals, :inherited, :configuration
-
-      def initialize(id = nil)
-        self.id id if id
-      end
-
-      def configuration(c = nil)
-        @configuration = Configuration.new(c) if c
-        @configuration ||= Configuration.new({})
-      end
-
-      def execute_goal(g)
-        self.goals = g
-        self
-      end
-
-      def with(config)
-        self.configuration config
-      end
-
-      def goals
-        @goals ||= []
-      end
-
-      def goals=(goals)
-        @goals = goals.is_a?(Array) ? goals: [goals]
-      end
-    end
-
-    class DependencyManagement < Tag
-
-      include Dependencies
-
-      def _name
-        "dependencyManagement"
-      end
-    end
-
-    class Profile < Tag
-      tags :id, :activation, :repositories, :plugin_repositories
-      
-      include Dependencies
-
-      tags :dependency_management, :properties, :build
-
-      def initialize(id, &block)
-        self.id id
-        if block
-          block.call(self)
-        end
-        self
-      end
-      
-      def properties
-        @properties ||= Properties.new
-        @properties.map
-      end
-
-      def properties=(props)
-        if props.is_a? Hash
-          @properties = Properties.new(props)
-        else
-          @properties = props
-        end
-      end
-
-      def build
-        @build ||= Build.new
-      end
-      
-      def activation(name = nil, value = nil, &block)
-        @activation ||= Activation.new
-         if name || value
-           warn "deprecated, use 'property_activation' instead"
-           @activation.property(name, value)
-         else
-           block.call(@activation) if block
-           @activation
-         end
-      end
-
-      def repositories(&block)
-        @repositories ||= ModelHash.new(Repository)
-        if block
-          block.call(@repositories)
-        end
-        @repositories
-      end
-
-      def repository(id, url = nil, &block)
-        repo = repositories.get(id, &block)
-        repo.url = url if url
-        repo
-      end
-
-      def plugin_repositories(&block)
-        @plugin_repositories ||= ModelHash.new(PluginRepository)
-        if block
-          block.call(@plugin_repositories)
-        end
-        @plugin_repositories
-      end
-
-      def plugin_repository(id, url = nil, &block)
-        repo = plugin_repositories.get(id, &block)
-        repo.url = url if url
-        repo
-      end
-
-      def plugin(*args, &block)
-        build.plugins.get(*args, &block)
-      end
-
-      def dependency_management(&block)
-        @dependency_management ||= DependencyManagement.new
-        if block
-          block.call(@dependency_management)
-        end
-        @dependency_management
-      end
-    end
-
-    class Developer < Tag
-      tags :id, :name, :email
-
-      def initialize(*args)
-        case args.size
-        when 1
-          @email = args[0].sub(/.*</, '').sub(/>.*/, '')
-          @name = args[0].sub(/\s*<.*/, '')
-        when 2
-          @name = args[0]
-          @email = args[1]
-        when 3
-          @id = args[0]
-          @name = args[1]
-          @email = args[2]
-        end
-        @email = @email[0] if @email.is_a? Array # this produces a partial list
-        @id = @email.sub(/@/, '_at_').gsub(/\./, '_dot_') unless @id
-        self
-      end
-    end
-
-    class License < Tag
-      tags :name, :url, :distribution
-
-      def initialize(*args)
-        case args.size
-        when 1
-          @url = args[0]
-          @name = args[0].sub(/.*\//, '').sub(/\.\w+/, '')
-        when 2
-          @url = args[0]
-          @name = args[1]
-        when 3
-          @url = args[0]
-          @name = args[1]
-          @distribution = args[2]
-        end
-        @url = "./#{url}" unless @url =~ /^\.\// || @url =~ /^https?:\/\//
-        @distribution = "repo" unless @distribution
-        self
-      end
-    end
-
-
-    class Project < Coordinate
-      prepend_tags :model_version, :parent
-
-      tags :name, :packaging, :description, :url, :developers, :licenses, :repositories, :plugin_repositories
-
-      include Dependencies
-
-      tags :dependency_management, :properties, :build, :profiles
-
-      def initialize(*args, &block)
-        super(*args)
-        model_version "4.0.0"
-        if block
-          block.call(self)
-        end
-        self
-      end
- 
-      def _name
-        'project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"'
-      end
-
-      def version(val = nil)
-        self.version = val if val
-        @version ||= (@parent.nil? ? '0.0.0' : @parent.version)
-      end
-
-      def name(val = nil)
-        self.name = val if val
-        @name
-      end
-
-      def name=(val)
-        @name = "<![CDATA[#{val}]]>"
-      end
-
-      def description(val = nil)
-        self.description = val if val
-        @description
-      end
-
-      def description=(val)
-        @description = "<![CDATA[#{val}]]>"
-      end
-      
-      def parent(*args, &block)
-        @parent ||= Parent.new(*args)
-        @parent.call(block) if block
-        @parent
-      end
-
-      def execute_in_phase(phase, name = nil, &block)
-        gem_plugin = plugin("gem")
-        gem_plugin.in_phase(phase.to_s, name).execute_goal("execute_in_phase").with(:file => File.basename(current_file), :phase => phase)
-        executions_in_phase[phase.to_s] = block
-        gem_plugin
-      end
-
-      def executions_in_phase
-        @executions_in_phase ||= {}
-      end
-
-      def plugin(*args, &block)
-        build.plugins.get(*args, &block)
-      end
-
-      def plugin?(name)
-        build.plugin?(name)
-      end
-
-      def profile(*args, &block)
-        profiles.get(*args, &block)
-      end
-
-      def build
-        @build ||= Build.new
-      end
-
-      def developers(&block)
-        @developers ||= DeveloperHash.new
-        if block
-          block.call(@developers)
-        end
-        @developers
-      end
-
-      def licenses(&block)
-        @licenses ||= LicenseHash.new
-        if block
-          block.call(@licenses)
-        end
-        @licenses
-      end
-
-      def repositories(&block)
-        @repositories ||= ModelHash.new(Repository)
-        if block
-          block.call(@repositories)
-        end
-        @repositories
-      end
-
-      def repository(id, url = nil, &block)
-        repo = repositories.get(id, &block)
-        repo.url = url if url
-        repo
-      end
-
-      def plugin_repositories(&block)
-        @plugin_repositories ||= ModelHash.new(PluginRepository)
-        if block
-          block.call(@plugin_repositories)
-        end
-        @plugin_repositories
-      end
-
-      def plugin_repository(id, url = nil, &block)
-        repo = plugin_repositories.get(id, &block)
-        repo.url = url if url
-        repo
-      end
-
-      def dependency_management(&block)
-        @dependency_management ||= DependencyManagement.new
-        if block
-          block.call(@dependency_management)
-        end
-        @dependency_management
-      end
-
-      def properties
-        @properties ||= Properties.new
-        @properties.map
-      end
-
-      def properties=(props)
-        if props.is_a? Hash
-          @properties = Properties.new(props)
-        else
-          @properties = props
-        end
-      end
-
-      def profile(id, &block)
-        profiles.get(id, &block)
-      end
-
-      def profiles(&block)
-        @profiles ||= ModelHash.new(Profile)
-        if block
-          block.call(@profiles)
-        end
-        @profiles
-      end
-    end
-
-    class Configuration < HashTag
-
-      def initialize(args = {})
-        super("configuration", args)
-      end
-    end
-
-    class Properties < HashTag
-
-      def initialize(args = {})
-        super("properties", args)
-      end
-
-      def map
-        @props
-      end
-    end
-
-    class OS < Tag
-      tags :name, :family, :arch, :version
-    end
-
-    class Activation < Tag
-      tags :activeByDefault, :property, :os
-      def initialize
-        super({})
-      end
-
-      def add_property(name, value)
-        warn "deprecated, use 'property' instead"
-        property(name, value)
-      end
-
-      def property(name, value)
-        if name && value
-          # TODO make more then one property
-          raise "more then one property is not implemented: #{@property.name} => #{@property.value}" if @property
-          @property ||= ListItems.new
-          @property << Property.new(name, value)
-        end
-        self
-      end
-
-      def os(&block)
-        @os ||= OS.new
-        block.call(@os) if block
-        @os
-      end
-      
-      def by_default(value = true)
-        @activeByDefault = value
-        self
-      end
-    end
-
-    class Property < Tag
-      tags :name, :value
-
-      def initialize(name, value)
-        self.name name
-        self.value value
-      end
-    end
-
-    class Repository < Tag
-      tags :id, :name, :url, :releases, :snapshots
-      def initialize(id, &block)
-        super({})
-        self.id id
-        if block
-          block.call(self)
-        end
-        self
-      end
-
-      def releases(args = {})
-        @releases ||= args
-      end
-
-      def snapshots(args = {})
-        @snapshots ||= args
-      end
-    end
-
-    class PluginRepository < Repository
-      tags :dummy
-      def _name
-        "pluginRepository"
-      end
-    end
-  end
-end