maven-tools 0.31.0 → 0.32.0

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

@@ -1,832 +0,0 @@
-module Maven
-  module Model
-    class Tag
-
-      def self.tags(*tags)
-        if tags.size == 0
-          @tags
-        else
-          #self.send :attr_accessor, *tags
-          tags.each do |tag|
-          eval <<-EOF
-            def #{tag.to_s}(val = nil)
-              @#{tag.to_s} = val if val
-              @#{tag.to_s}
-            end
-            def #{tag.to_s}=(val)
-              @#{tag.to_s} = val
-            end
-EOF
-          end
-          @tags ||= []
-          if self.superclass.respond_to?:tags
-            @tags = self.superclass.tags || []
-          else
-            @tags ||= []
-          end
-          @tags.replace([ @tags, tags].flatten)
-        end
-      end
-
-      def _name
-        self.class.to_s.downcase.sub(/.*::/, '')
-      end
-
-      def initialize(args = {})
-        args.each do |k,v|
-          send("#{k}=".to_sym, v)
-        end
-      end
-
-      def to_xml(buf = "", indent = "")
-        buf << "#{indent}<#{_name}>\n"
-        self.class.tags.each do |var|
-          val = instance_variable_get("@#{var}".to_sym)
-          var = var.to_s.gsub(/_(.)/) { $1.upcase }
-          case val
-          when Array
-            val.flatten!
-            if val.size > 0
-              buf << "#{indent}  <#{var}>\n"
-              val.each do |v|
-                if v.is_a? Tag
-                  v.to_xml(buf, indent + "    ")
-                else
-                  buf << "#{indent}    <#{var.to_s.sub(/s$/, '')}>#{v}</#{var.to_s.sub(/s$/, '')}>\n"
-                end
-              end
-              buf << "#{indent}  </#{var}>\n"
-            end
-          when Hash
-            if val.size > 0
-              buf << "#{indent}  <#{var}>\n"
-              val.each do |k, v|
-                if v.is_a? Tag
-                  v.to_xml(buf, indent + "    ")
-                else
-                  buf << "#{indent}    <#{k}>#{v}</#{k}>\n"
-                end
-              end
-              buf << "#{indent}  </#{var}>\n"
-            end
-          when Tag
-            val.to_xml(buf, indent + "  ")
-          else
-            #when String
-            buf << "#{indent}  <#{var}>#{val}</#{var}>\n" if val
-          end
-        end
-        buf << "#{indent}</#{_name}>\n"
-        buf
-      end
-    end
-
-    # class Coordinate < Tag
-    #   tags :group_id, :artifact_id, :version
-    #   def initialize(args = {})
-    #     super
-    #   end
-
-    #   def ==(other)
-    #     group_id == other.group_id && artifact_id == other.artifact_id
-    #   end
-    # end
-
-    # class Dependency < Coordinate
-    #   tags :type, :scope, :classifier
-    #   def initialize(group_id, artifact_id, version = nil, type = nil)
-    #     super(:group_id => group_id, :artifact_id => artifact_id, :version => version, :type => type)
-    #   end
-    # end
-
-    # class Gem < Dependency
-    #   tags :dummy
-    #   def initialize(gemname, version = nil)
-    #     super("rubygems", gemname, version, "gem")
-    #   end
-
-    #   def _name
-    #     "dependency"
-    #   end
-    # end
-
-    class NamedArray < Array
-      attr_reader :name
-      def initialize(name, &block)
-        @name = name.to_s
-        if block
-          block.call(self)
-        end
-        self
-      end
-    end
-
-    # class DepArray < Array
-    #   def <<(args)
-    #     item = 
-    #       case args
-    #       when Dependency
-    #         args
-    #       when Array
-    #         if args.size == 1
-    #           args << "[0.0.0,)"
-    #         elsif args.size == 2 && args.last.is_a?(Hash)
-    #           args = [args[0], "[0.0.0,)", args[1]]
-    #         elsif args.size >= 2
-    #           if args[1] =~ /~>/
-    #             val = args[1].sub(/~>\s*/, '')
-    #             last = val.sub(/\.[^.]+$/, '.99999')
-    #             args[1] = "[#{val}, #{last}]"
-    #           elsif args[1] =~ />=/
-    #             val = args[1].sub(/>=\s*/, '')
-    #             args[1] = "[#{val},)"
-    #           elsif args[1] =~ /<=/
-    #             val = args[1].sub(/<=\s*/, '')
-    #             args[1] = "[0.0.0,#{val}]"
-    #           elsif args[1] =~ />/
-    #             val = args[1].sub(/>\s*/, '')
-    #             args[1] = "(#{val},)"
-    #           elsif args[1] =~ /</
-    #             val = args[1].sub(/<\s*/, '')
-    #             args[1] = "[0.0.0,#{val})"
-    #           end
-    #         end
-    #         if args[0] =~ /:/
-    #           Dependency.new(args[0].sub(/:[^:]+$/, ''), 
-    #                          args[0].sub(/.*:/, ''), 
-    #                          args[1])
-    #         else
-    #           args = args.delete(2) if args[2]
-    #           Gem.new(*args)
-    #         end
-    #       when String
-    #         if args =~ /:/
-    #           Dependency.new(args.sub(/:[^:]+$/, ''), 
-    #                          args.sub(/.*:/, ''))
-    #         else
-    #           Gem.new(args)
-    #         end
-    #       else
-    #         args
-    #       end
-    #     super item unless member? item
-    #     item
-    #   end
-
-    # end
-
-    class Build < Tag
-      tags :finalName, :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 @finalName.nil? && (@plugins.nil? || @plugins.size == 0)
-          ""
-        else
-          super
-        end
-      end
-    end
-
-    class Plugin < Coordinate
-      tags :extensions, :configuration, :executions, :dependencies
-      def initialize(group_id, artifact_id, version, &block)
-        super(:artifact_id => artifact_id, :version => version)
-        @group_id = group_id if group_id
-        if block
-          block.call(self)
-        end
-        self
-      end
-
-      def dependencies(&block)
-        @dependencies ||= DepArray.new
-        if block
-          block.call(@dependencies)
-        end
-        @dependencies
-      end
-
-      def with(config)
-        self.configuration = config
-      end
-
-      def in_phase(phase, name = nil, &block)
-        name = "in_phase_#{phase.gsub(/-/,'_')}" unless name
-        self.executions.get(name) do |exe|
-          exe.phase = phase
-          block.call(exe) if block
-          exe
-        end
-      end
-
-      def executions
-        @executions ||= ModelHash.new(Execution)
-      end
-
-      def execution(name = nil, &block)
-        executions.get(name, &block)
-      end
-
-      def configuration=(c)
-        if c.is_a? Hash
-          @configuration = Configuration.new(c)
-        else
-          @configuration = c
-        end
-      end
-    end
-
-    class Execution < Tag
-      tags :id, :phase, :goals, :inherited, :configuration
-
-      def initialize(id = nil)
-        super({ :id => id })
-      end
-
-      def configuration=(c)
-        if c.is_a? Hash
-          @configuration = Configuration.new(c)
-        else
-          @configuration = c
-        end
-      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
-      tags :dependencies
-
-      def _name
-        "dependencyManagement"
-      end
-
-      def dependencies(&block)
-        @dependencies ||= DepArray.new
-        if block
-          block.call(@dependencies)
-        end
-        @dependencies
-      end
-    end
-
-    class Profile < Tag
-      tags :id, :activation, :dependencies, :dependency_management, :properties, :build
-
-      def initialize(id, &block)
-        super(:id => id)
-        if block
-          block.call(self)
-        end
-        self
-      end
-      
-      def properties
-        (@properties || Properties.new).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 default_activation(name = nil, value = nil)
-        warn "deprecated, use 'activation.by_default.property(name.value)' instead"
-        activation.property(name, value).by_default
-      end
-
-      def plugin(*args, &block)
-        build.plugins.get(*args, &block)
-      end
-
-      def dependencies(&block)
-        @dependencies ||= DepArray.new
-        if block
-          block.call(@dependencies)
-        end
-        @dependencies
-      end
-
-      def dependency_management(&block)
-        @dependency_management ||= DependencyManagement.new
-        if block
-          block.call(@dependency_management.dependencies)
-        end
-        @dependency_management.dependencies
-      end
-    end
-
-    class ModelHash < Hash
-
-      def initialize(clazz)
-        @clazz = clazz
-      end
-
-      def get(key, &block)
-        key = key.to_sym if key
-        result = self[key]
-        if result.nil?
-          result = (self[key] = @clazz.new(key))
-        end
-        if block
-          block.call(result)
-        end
-        result
-      end
-      alias :new :get
-      
-      def default_model
-        @default_model ||= 
-          begin
-            model = @clazz.new
-            self[nil] = model
-            model
-          end
-      end
-
-      def method_missing(method, *args, &block)
-        default_model.send(method, *args, &block)
-      end
-    end
-    
-    class DeveloperHash < Hash
-
-      def get(*args, &block)
-        developer = if args.size == 1 && args[0].is_a?(Developer)
-                      args[0] 
-                    else 
-                      Developer.new(*args)
-                    end
-        self[developer.id] = developer
-        if block
-          block.call(developer)
-        end
-        developer
-      end
-      alias :new :get
-      alias :add :get
-    end
-
-    class LicenseHash < Hash
-
-      def get(*args, &block)
-        license = if args.size == 1 && args[0].is_a?(License)
-                      args[0] 
-                    else 
-                      License.new(*args)
-                    end
-        self[license.name] = license
-        if block
-          block.call(license)
-        end
-        license
-      end
-      alias :new :get
-      alias :add :get
-    end
-
-    class PluginHash < Hash
-
-      def adjust_key(name)
-        name = name.to_s
-        if (name =~ /\:/).nil?
-          if [:jruby, :gem, :rspec, :rake, :rails2, :rails3, :gemify, :cucumber, :runit, :bundler].member? name.to_sym
-            "de.saumya.mojo:#{name}-maven-plugin"
-          else
-            "maven-#{name}-plugin"
-          end
-        else
-          name
-        end
-      end
-
-      def key?(k)
-        super( adjust_key(k).to_sym )
-      end
-
-      def get(*args, &block)
-        case args.size
-        when 3
-          name = args[0] + ":" + args[1]
-          version = args[2]
-        when 2
-          name = args[0].to_s
-          version = args[1]
-        when 1
-          name = args[0].to_s
-        else
-          raise "need name"
-        end
-
-        name = adjust_key(name)
-        group_id = name =~ /\:/ ? name.sub(/:.+$/, '') : nil
-        artifact_id = name.sub(/^.+:/, '')
-
-        k = "#{group_id}:#{artifact_id}".to_sym
-        result = self[k]
-        if result.nil?
-          result = (self[k] = Plugin.new(group_id, artifact_id, version))
-        end
-        result.version = version if version
-        if block
-          block.call(result)
-        end
-        result
-      end
-      alias :new :get
-      alias :add :get
-      
-    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
-        @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 =~ /^\.\//
-        @distribution = "repo" unless @distribution
-        self
-      end
-    end
-
-    class Project < Tag
-      tags :model_version, :group_id, :artifact_id, :version, :name, :packaging, :description, :url, :developers, :licenses, :repositories, :plugin_repositories, :dependencies, :dependency_management, :properties, :build, :profiles
-
-      def initialize(group_id, artifact_id, version = "0.0.0", &block)
-        super(:model_version => "4.0.0", :artifact_id => artifact_id, :group_id => group_id, :version => version)
-        if block
-          block.call(self)
-        end
-        self
-      end
-
-      def _name
-        "project"
-      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 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(*args, &block)
-        repositories.get(*args, &block)
-      end
-
-      def plugin_repositories(&block)
-        @plugin_repositories ||= ModelHash.new(PluginRepository)
-        if block
-          block.call(@plugin_repositories)
-        end
-        @plugin_repositories
-      end
-
-      def plugin_repository(*args, &block)
-        plugin_repositories.get(*args, &block)
-      end
-
-      def dependencies(&block)
-        @dependencies ||= DepArray.new
-        if block
-          block.call(@dependencies)
-        end
-        @dependencies
-      end
-
-      def dependency_management(&block)
-        @dependency_management ||= DependencyManagement.new
-        if block
-          block.call(@dependency_management.dependencies)
-        end
-        @dependency_management.dependencies
-      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 profiles(&block)
-        @profiles ||= ModelHash.new(Profile)
-        if block
-          block.call(@profiles)
-        end
-        @profiles
-      end
-    end
-
-    class HashTag < Tag
-
-      def initialize(name, args = {})
-        @name = name
-        @props = args
-      end
-
-      def [](key, value)
-        @props ||= {}
-        @props[key] = value
-      end
-      
-      def to_xml(buf = "", indent = "")
-        buf << "#{indent}<#{@name}>\n"
-        map_to_xml(buf, indent, @props)
-        buf << "#{indent}</#{@name}>\n"
-      end
-      
-      def map_to_xml(buf, indent, map)
-        # sort the hash over the keys
-        map.collect { |k,v| [k.to_s, v]}.sort.each do |k,v|
-          case v
-          when Hash
-            buf << "#{indent}  <#{k}>\n"
-            map_to_xml(buf, indent + "  ", v)
-            buf << "#{indent}  </#{k}>\n"
-          when NamedArray
-            buf << "#{indent}  <#{k}>\n"
-            v.each do|i|
-              buf << "#{indent}    <#{v.name}>\n"
-              case i
-              when Hash
-                map_to_xml(buf, indent + "    ", i)
-              end
-              buf << "#{indent}    </#{v.name}>\n"
-            end
-            buf << "#{indent}  </#{k}>\n"
-          when Array
-            buf << "#{indent}  <#{k}>\n"
-            singular = k.to_s.sub(/s$/, '')
-            v.each do |i|
-              buf << "#{indent}    <#{singular}>#{i}</#{singular}>\n"
-            end
-            buf << "#{indent}  </#{k}>\n"
-          when /\n$/
-            buf << "#{indent}  <#{k}>#{v}"
-            buf << "#{indent}  </#{k}>\n"
-          else
-            buf << "#{indent}  <#{k}>#{v}</#{k}>\n"
-          end
-        end
-      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 ListItems < Tag
-
-      def initialize(name = nil)
-        @name = name
-      end
-
-      def add(item)
-        @items ||= Array.new
-        @items << item
-      end
-      alias :<< :add
-
-      def to_xml(buf = "", indent = "")
-        buf << "#{indent}<#{@name}>\n" if @name 
-        @items.each do |i|
-          i.to_xml(buf, indent)
-        end
-        buf << "#{indent}</#{@name}>\n" if @name
-      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 => name, :value => value)
-        end
-        self
-      end
-
-      def os(&block)
-        @os ||= OS.new
-        block.call(@os) if block
-        @os
-      end
-
-      def as_default
-        warn "deprecated, use 'by_default' instead"
-        by_default
-      end
-      
-      def by_default(value = true)
-        @activeByDefault = value
-        self
-      end
-    end
-
-    class Property < Tag
-      tags :name, :value
-    end
-
-    class Repository < Tag
-      tags :id, :name, :url, :releases, :snapshots
-      def initialize(id, &block)
-        super({:id => id, :url => url})
-        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