realityforge-buildr 1.5.9

data/lib/buildr/packaging/artifact_search.rb

@@ -0,0 +1,138 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+autoload :Hpricot, 'hpricot'
+
+module Buildr #:nodoc:
+
+  # Search best artifact version from remote repositories
+  module ArtifactSearch
+    extend self
+
+    def include(method = nil)
+      (@includes ||= []).tap { push method if method }
+    end
+
+    def exclude(method = nil)
+      (@excludes ||= []).tap { push method if method }
+    end
+
+    # TODO: return the url for best matching repo
+    def best_version(spec, *methods)
+      spec = Artifact.to_hash(spec)
+      spec[:version] = requirement = VersionRequirement.create(spec[:version])
+      select = lambda do |candidates|
+        candidates.find { |candidate| requirement.satisfied_by?(candidate) }
+      end
+      result = nil
+      methods = search_methods if methods.empty?
+      if requirement.composed?
+        until result || methods.empty?
+          method = methods.shift
+          type = method.keys.first
+          from = method[type]
+          if (include.empty? || !(include & [:all, type, from]).empty?) &&
+              (exclude & [:all, type, from]).empty?
+            if from.respond_to?(:call)
+              versions = from.call(spec.dup)
+            else
+              versions = send("#{type}_versions", spec.dup, *from)
+            end
+            result = select[versions]
+          end
+        end
+      end
+      result ||= requirement.default
+      raise "Could not find #{Artifact.to_spec(spec)}"  +
+        "\n You may need to use an specific version instead of a requirement" unless result
+      spec.merge :version => result
+    end
+
+    def requirement?(spec)
+      VersionRequirement.requirement?(spec[:version])
+    end
+
+    private
+    def search_methods
+      [].tap do
+        push :runtime => [Artifact.list]
+        push :local => Buildr.repositories.local
+        Buildr.repositories.remote.each { |remote| push :remote => remote }
+        push :mvnrepository => []
+      end
+    end
+
+    def depend_version(spec)
+      spec[:version][/[\w\.]+/]
+    end
+
+    def runtime_versions(spec, artifacts)
+      spec_classif = spec.values_at(:group, :id, :type)
+      artifacts.inject([]) do |in_memory, str|
+        candidate = Artifact.to_hash(str)
+        if spec_classif == candidate.values_at(:group, :id, :type)
+          in_memory << candidate[:version]
+        end
+        in_memory
+      end
+    end
+
+    def local_versions(spec, repo)
+      path = (spec[:group].split(/\./) + [spec[:id]]).flatten.join('/')
+      Dir[File.expand_path(path + "/*", repo)].map { |d| d.pathmap("%f") }.sort.reverse
+    end
+
+    def remote_versions(art, base, from = :metadata, fallback = true)
+      path = (art[:group].split(/\./) + [art[:id]]).flatten.join('/')
+      base ||= "https://repo1.maven.org/maven2"
+      uris = {:metadata => "#{base}/#{path}/maven-metadata.xml"}
+      uris[:listing] = "#{base}/#{path}/" if base =~ /^https?:/
+        xml = nil
+      until xml || uris.empty?
+        begin
+          xml = URI.read(uris.delete(from))
+        rescue URI::NotFoundError => e
+          from = fallback ? uris.keys.first : nil
+        end
+      end
+      return [] unless xml
+      doc = Hpricot(xml)
+      case from
+      when :metadata then
+        doc.search("versions/version").map(&:innerHTML).reverse
+      when :listing then
+        doc.search("a[@href]").inject([]) { |vers, a|
+          vers << a.innerHTML.chop if a.innerHTML[-1..-1] == '/'
+          vers
+        }.sort.reverse
+      else
+        fail "Don't know how to parse #{from}: \n#{xml.inspect}"
+      end
+    end
+
+    def mvnrepository_versions(art)
+      uri = "http://www.mvnrepository.com/artifact/#{art[:group]}/#{art[:id]}"
+      xml = begin
+              URI.read(uri)
+            rescue URI::NotFoundError => e
+              puts e.class, e
+              return []
+            end
+      doc = Hpricot(xml)
+      doc.search("table.grid/tr/td[1]/a").map(&:innerHTML)
+    end
+
+  end # ArtifactSearch
+end

data/lib/buildr/packaging/package.rb

@@ -0,0 +1,237 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+module Buildr #:nodoc:
+  # Methods added to Project to support packaging and tasks for packaging,
+  # installing and uploading packages.
+  module Package
+
+    include Extension
+
+    first_time do
+      desc 'Create packages'
+      Project.local_task('package'=>'build') { |name| "Packaging #{name}" }
+      desc 'Install packages created by the project'
+      Project.local_task('install'=>'package') { |name| "Installing packages from #{name}" }
+      desc 'Remove previously installed packages'
+      Project.local_task('uninstall') { |name| "Uninstalling packages from #{name}" }
+      desc 'Upload packages created by the project'
+      Project.local_task('upload'=>'package') { |name| "Deploying packages from #{name}" }
+      # Anything that comes after local packaging (install, upload) executes the integration tests,
+      # which do not conflict with integration invoking the project's own packaging (package=>
+      # integration=>foo:package is not circular, just confusing to debug.)
+      task 'package' do
+        task('integration').invoke if Buildr.options.test && Buildr.application.original_dir == Dir.pwd
+      end
+    end
+
+    before_define(:package => :build) do |project|
+      [ :package, :install, :uninstall, :upload ].each { |name| project.recursive_task name }
+      # Need to run build before package, since package is often used as a dependency by tasks that
+      # expect build to happen.
+      project.task('package'=>project.task('build'))
+      project.group ||= project.parent && project.parent.group || project.name
+      project.version ||= project.parent && project.parent.version
+    end
+
+    after_define(:package)
+
+    # The project's identifier. Same as the project name, with colons replaced by dashes.
+    # The ID for project foo:bar is foo-bar.
+    def id
+      name.gsub(':', '-')
+    end
+
+    # Group used for packaging. Inherited from parent project. Defaults to the top-level project name.
+    attr_accessor :group
+
+    # Version used for packaging. Inherited from parent project.
+    attr_accessor :version
+
+    # :call-seq:
+    #   package(type, spec?) => task
+    #
+    # Defines and returns a package created by this project.
+    #
+    # The first argument declares the package type. For example, :jar to create a JAR file.
+    # The package is an artifact that takes its artifact specification from the project.
+    # You can override the artifact specification by passing various options in the second
+    # argument, for example:
+    #   package(:zip, :classifier=>'sources')
+    #
+    # Packages that are ZIP files provides various ways to include additional files, directories,
+    # and even merge ZIPs together. Have a look at ZipTask for more information. In case you're
+    # wondering, JAR and WAR packages are ZIP files.
+    #
+    # You can also enhance a JAR package using the ZipTask#with method that accepts the following options:
+    # * :manifest -- Specifies how to create the MANIFEST.MF. By default, uses the project's
+    #   #manifest property.
+    # * :meta_inf -- Specifies files to be included in the META-INF directory. By default,
+    #   uses the project's #meta-inf property.
+    #
+    # The WAR package supports the same options and adds a few more:
+    # * :classes -- Directories of class files to include in WEB-INF/classes. Includes the compile
+    #   target directory by default.
+    # * :libs -- Artifacts and files to include in WEB-INF/libs. Includes the compile classpath
+    #   dependencies by default.
+    #
+    # For example:
+    #   define 'project' do
+    #     define 'beans' do
+    #       package :jar
+    #     end
+    #     define 'webapp' do
+    #       compile.with project('beans')
+    #       package(:war).with :libs=>MYSQL_JDBC
+    #     end
+    #     package(:zip, :classifier=>'sources').include path_to('.')
+    #  end
+    #
+    # Two other packaging types are:
+    # * package :sources -- Creates a JAR file with the source code and classifier 'sources', for use by IDEs.
+    # * package :javadoc -- Creates a ZIP file with the Javadocs and classifier 'javadoc'. You can use the
+    #   javadoc method to further customize it.
+    #
+    # A package is also an artifact. The following tasks operate on packages created by the project:
+    #   buildr upload     # Upload packages created by the project
+    #   buildr install    # Install packages created by the project
+    #   buildr package    # Create packages
+    #   buildr uninstall  # Remove previously installed packages
+    #
+    # If you want to add additional packaging types, implement a method with the name package_as_[type]
+    # that accepts a file name and returns an appropriate Rake task.  For example:
+    #   def package_as_zip(file_name) #:nodoc:
+    #     ZipTask.define_task(file_name)
+    #   end
+    #
+    # The file name is determined from the specification passed to the package method, however, some
+    # packagers need to override this.  For example, package(:sources) produces a file with the extension
+    # 'jar' and the classifier 'sources'.  If you need to overwrite the default implementation, you should
+    # also include a method named package_as_[type]_spec.  For example:
+    #   def package_as_sources_spec(spec) #:nodoc:
+    #     # Change the source distribution to .zip extension
+    #     spec.merge({ :type=>:zip, :classifier=>'sources' })
+    #   end
+    def package(*args)
+      spec = Hash === args.last ? args.pop.dup : {}
+      no_options = spec.empty? # since spec is mutated
+      if spec[:file]
+        rake_check_options spec, :file, :type
+        spec[:type] = args.shift || spec[:type] || spec[:file].split('.').last.to_sym
+        file_name = spec[:file]
+      else
+        rake_check_options spec, *ActsAsArtifact::ARTIFACT_ATTRIBUTES
+        spec[:id] ||= self.id
+        spec[:group] ||= self.group
+        spec[:version] ||= self.version
+        spec[:type] = args.shift || spec[:type] || compile.packaging || :zip
+      end
+
+      packager = method("package_as_#{spec[:type]}") rescue fail("Don't know how to create a package of type #{spec[:type]}")
+      if packager.arity == 1
+        unless file_name
+          spec = send("package_as_#{spec[:type]}_spec", spec) if respond_to?("package_as_#{spec[:type]}_spec")
+          file_name = path_to(:target, Artifact.hash_to_file_name(spec))
+        end
+        package = (no_options && packages.detect { |pkg| pkg.type == spec[:type] && (pkg.id.nil? || pkg.id == spec[:id]) &&
+          (pkg.respond_to?(:classifier) ? pkg.classifier : nil) == spec[:classifier]}) ||
+          packages.find { |pkg| pkg.name == file_name } ||
+          packager.call(file_name)
+      else
+        Buildr.application.deprecated "We changed the way package_as methods are implemented.  See the package method documentation for more details."
+        file_name ||= path_to(:target, Artifact.hash_to_file_name(spec))
+        package = packager.call(file_name, spec)
+      end
+
+      # First time: prepare package for install, uninstall and upload tasks.
+      unless packages.include?(package)
+        # We already run build before package, but we also need to do so if the package itself is
+        # used as a dependency, before we get to run the package task.
+        task 'package'=>package
+        package.enhance [task('build')]
+        package.enhance { info "Packaging #{File.basename(file_name)}" }
+        if spec[:file]
+          class << package ; self ; end.send(:define_method, :type) { spec[:type] }
+          class << package ; self ; end.send(:define_method, :id) { nil }
+        else
+          # Make it an artifact using the specifications, and tell it how to create a POM.
+          package.extend ActsAsArtifact
+          package.buildr_project = self
+          package.send :apply_spec, spec.dup.delete_if{|key, _|!ActsAsArtifact::ARTIFACT_ATTRIBUTES.include?(key)}
+
+          # Create pom associated with package
+          class << package
+            def pom
+              unless @pom
+                pom_filename = self.name.sub(/\.[^.]+\z/, '.pom')
+                spec = {:group=>group, :id=>id, :version=>version, :type=>:pom}
+                @pom = Buildr.artifact(spec, pom_filename)
+                @pom.content Buildr::CustomPom.pom_xml(self.buildr_project, self)
+              end
+              @pom
+            end
+          end if package.classifier.nil?
+
+          file(Buildr.repositories.locate(package)=>package) { package.install }
+
+          # Add the package to the list of packages created by this project, and
+          # register it as an artifact. The later is required so if we look up the spec
+          # we find the package in the project's target directory, instead of finding it
+          # in the local repository and attempting to install it.
+          Artifact.register package
+          Artifact.register package.pom if package.classifier.nil?
+        end
+
+        task('install')   { package.install if package.respond_to?(:install) }
+        task('uninstall') { package.uninstall if package.respond_to?(:uninstall) }
+        task('upload')    { package.upload if package.respond_to?(:upload) }
+
+        packages << package
+      end
+      package
+    end
+
+    # :call-seq:
+    #   packages => tasks
+    #
+    # Returns all packages created by this project. A project may create any number of packages.
+    #
+    # This method is used whenever you pass a project to Buildr#artifact or any other method
+    # that accepts artifact specifications and projects. You can use it to list all packages
+    # created by the project. If you want to return a specific package, it is often more
+    # convenient to call #package with the type.
+    def packages
+      @packages ||= []
+    end
+
+    def package_as_zip(file_name) #:nodoc:
+      ZipTask.define_task(file_name)
+    end
+
+    def package_as_sources_spec(spec) #:nodoc:
+      spec.merge(:type=>:jar, :classifier=>'sources')
+    end
+
+    def package_as_sources(file_name) #:nodoc:
+      ZipTask.define_task(file_name).tap do |zip|
+        zip.include :from=>[compile.sources, resources.target].compact
+      end
+    end
+  end
+end
+
+class Buildr::Project
+  include Buildr::Package
+end

data/lib/buildr/packaging/version_requirement.rb

@@ -0,0 +1,189 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership.  The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+# Rubygems 1.3.6 removed the 'version' accessor so monkey-patch it back to
+# circumvent version validation.  This is needed because Gem::Version doesn't
+# accept version specs with dashes.
+unless Gem::Version.new("0").respond_to?(:version=)
+  class Gem::Version
+    def version=(version)
+      @version = version.to_s.strip
+
+      # re-prime @segments
+      @segments = nil
+      @canonical_segments = nil
+      segments
+    end
+  end
+end
+
+module Buildr #:nodoc:
+
+  #
+  # See ArtifactNamespace#need
+  class VersionRequirement
+
+    CMP_PROCS = Gem::Requirement::OPS.dup
+    CMP_REGEX = Gem::Requirement::OPS.keys.map { |k| Regexp.quote k }.join "|"
+    CMP_CHARS = CMP_PROCS.keys.join
+    BOOL_CHARS = '\|\&\!'
+    VER_CHARS = '\w\.\-'
+
+    class << self
+      # is +str+ a version string?
+      def version?(str)
+        /^\s*r?\d[#{VER_CHARS}]*\s*$/ === str
+      end
+
+      # is +str+ a version requirement?
+      def requirement?(str)
+        /[#{BOOL_CHARS}#{CMP_CHARS}\(\)]/ === str
+      end
+
+      # :call-seq:
+      #    VersionRequirement.create(" >1 <2 !(1.5) ") -> requirement
+      #
+      # parse the +str+ requirement
+      def create(str)
+        instance_eval normalize(str)
+      rescue StandardError => e
+        raise "Failed to parse #{str.inspect} due to: #{e}"
+      end
+
+      private
+      def requirement(req)
+        unless req =~ /^\s*(#{CMP_REGEX})?\s*([#{VER_CHARS}]+)\s*$/
+          raise "Invalid requirement string: #{req}"
+        end
+        comparator, version = $1, $2
+        # dup required due to jruby 1.7.13 bug/feature that caches versions?
+        version = Gem::Version.new(0).dup.tap { |v| v.version = version }
+        VersionRequirement.new(nil, [$1, version])
+      end
+
+      def negate(vreq)
+        vreq.negative = !vreq.negative
+        vreq
+      end
+
+      def normalize(str)
+        str = str.strip
+        if str[/[^\s\(\)#{BOOL_CHARS + VER_CHARS + CMP_CHARS}]/]
+          raise "version string #{str.inspect} contains invalid characters"
+        end
+        str.gsub!(/\s+(and|&&)\s+/, ' & ')
+        str.gsub!(/\s+(or|\|\|)\s+/, ' | ')
+        str.gsub!(/(^|\s*)not\s+/, ' ! ')
+        pattern = /(#{CMP_REGEX})?\s*[#{VER_CHARS}]+/
+        left_pattern = /[#{VER_CHARS}\)]$/
+        right_pattern = /^(#{pattern}|\()/
+        str = str.split.inject([]) do |ary, i|
+          ary << '&' if ary.last =~ left_pattern  && i =~ right_pattern
+          ary << i
+        end
+        str = str.join(' ')
+        str.gsub!(/!([^=])?/, ' negate \1')
+        str.gsub!(pattern) do |expr|
+          case expr.strip
+          when 'not', 'negate' then 'negate '
+          else 'requirement("' + expr + '")'
+          end
+        end
+        str.gsub!(/negate\s+\(/, 'negate(')
+        str
+      end
+    end
+
+    def initialize(op, *requirements) #:nodoc:
+      @op, @requirements = op, requirements
+    end
+
+    # Is this object a composed requirement?
+    #   VersionRequirement.create('1').composed? -> false
+    #   VersionRequirement.create('1 | 2').composed? -> true
+    #   VersionRequirement.create('1 & 2').composed? -> true
+    def composed?
+      requirements.size > 1
+    end
+
+    # Return the last requirement on this object having an = operator.
+    def default
+      default = nil
+      requirements.reverse.find do |r|
+        if Array === r
+          if !negative && (r.first.nil? || r.first.include?('='))
+            default = r.last.to_s
+          end
+        else
+          default = r.default
+        end
+      end
+      default
+    end
+
+    # Test if this requirement can be satisfied by +version+
+    def satisfied_by?(version)
+      return false unless version
+      unless version.kind_of?(Gem::Version)
+        raise "Invalid version: #{version.inspect}" unless self.class.version?(version)
+        # dup required due to jruby 1.7.13 bug/feature that caches versions?
+        version = Gem::Version.new(0).dup.tap { |v| v.version = version.strip }
+      end
+      message = op == :| ? :any? : :all?
+      result = requirements.send message do |req|
+        if Array === req
+          cmp, rv = *req
+          CMP_PROCS[cmp || '='].call(version, rv)
+        else
+          req.satisfied_by?(version)
+        end
+      end
+      negative ? !result : result
+    end
+
+    # Either modify the current requirement (if it's already an or operation)
+    # or create a new requirement
+    def |(other)
+      operation(:|, other)
+    end
+
+    # Either modify the current requirement (if it's already an and operation)
+    # or create a new requirement
+    def &(other)
+      operation(:&, other)
+    end
+
+    # return the parsed expression
+    def to_s
+      str = requirements.map(&:to_s).join(" " + @op.to_s + " ").to_s
+      str = "( " + str + " )" if negative || requirements.size > 1
+      str = "!" + str if negative
+      str
+    end
+
+    attr_accessor :negative
+    protected
+    attr_reader :requirements, :op
+    def operation(op, other)
+      @op ||= op
+      if negative == other.negative && @op == op && other.requirements.size == 1
+        @requirements << other.requirements.first
+        self
+      else
+        self.class.new(op, self, other)
+      end
+    end
+  end # VersionRequirement
+end