mguymon-buildr 1.4.5-java

data/lib/buildr/packaging/artifact_search.rb

@@ -0,0 +1,140 @@
+# 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.
+
+
+require 'hpricot'
+
+
+module Buildr
+
+  # 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 ||= "http://mirrors.ibiblio.org/pub/mirrors/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/gems.rb

@@ -0,0 +1,105 @@
+# 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.
+
+
+require 'buildr/packaging/package'
+require 'buildr/packaging/archive'
+gem 'rubyforge' ; autoload :RubyForge, 'rubyforge'
+Gem.autoload :Package, 'rubygems/package'
+
+
+module Buildr
+
+  class PackageGemTask < ArchiveTask
+
+    def initialize(*args)
+      super
+      @spec = Gem::Specification.new
+      prepare do
+        include(changelog) if changelog
+      end
+    end
+
+    attr_accessor :changelog
+
+    def spec
+      yield @spec if block_given?
+      @spec
+    end
+
+    def install
+      Util::Gems.command 'install', name
+    end
+
+    def uninstall
+      Util::Gems.command 'uninstall', spec.name, '-v', spec.version.to_s
+    end
+
+    def upload
+      rubyforge = RubyForge.new
+      rubyforge.login
+      rubyforge.userconfig.merge!('release_changes'=>changelog.to_s, 'preformatted'=>true) if changelog
+      rubyforge.add_release spec.rubyforge_project.downcase, spec.name.downcase, spec.version, package(:gem).to_s
+    end
+
+  private
+
+    def create_from(file_map)
+      spec.mark_version
+      spec.validate
+
+      File.open(name, 'wb') do |io|
+        Gem::Package.open(io, 'w', nil) do |pkg|
+          pkg.metadata = spec.to_yaml
+          file_map.each do |path, content|
+            next if content.nil? || File.directory?(content.to_s)
+            pkg.add_file_simple(path, File.stat(content.to_s).mode & 0777, File.size(content.to_s)) do |os|
+              File.open(content.to_s, "rb") do |file|
+                os.write file.read(4096)  until file.eof?
+              end
+            end
+          end
+        end
+      end
+    end
+
+  end
+
+
+  module PackageAsGem #:nodoc:
+
+    def package_as_gem(file_name) #:nodoc:
+      PackageGemTask.define_task(file_name).tap do |gem|
+        %w{ lib test doc }.each do |dir|
+          gem.include :from=>_(dir), :path=>dir if File.directory?(_(dir))
+        end
+        gem.spec do |spec|
+          spec.name = id
+          spec.version = version.gsub('-','.') # RubyGems doesn't like '-' in version numbers
+          spec.summary = full_comment
+          spec.has_rdoc = true
+          spec.rdoc_options << '--title' << comment
+          spec.require_path = 'lib'
+        end
+      end
+    end
+
+  end
+
+  class Project
+    include PackageAsGem
+  end
+
+end

data/lib/buildr/packaging/package.rb

@@ -0,0 +1,249 @@
+# 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.
+
+
+require 'buildr/core/project'
+require 'buildr/core/compile'
+require 'buildr/packaging/artifact'
+
+
+module Buildr
+  # 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.send :apply_spec, spec.only(*Artifact::ARTIFACT_ATTRIBUTES)
+
+          # Create pom associated with package
+          class << package
+            def pom
+              unless @pom
+                pom_filename = Util.replace_extension(self.name, 'pom')
+                spec = {:group=>group, :id=>id, :version=>version, :type=>:pom}
+                @pom = Buildr.artifact(spec, pom_filename)
+                @pom.content @pom.pom_xml
+              end
+              @pom
+            end
+          end
+
+          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, package.pom
+        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
+
+  protected
+
+    def package_as_zip(file_name) #:nodoc:
+      ZipTask.define_task(file_name)
+    end
+
+    def package_as_tar(file_name) #:nodoc:
+      TarTask.define_task(file_name)
+    end
+    alias :package_as_tgz :package_as_tar
+
+    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