realityforge-buildr 1.5.9

data/lib/buildr/java/commands.rb

@@ -0,0 +1,230 @@
+# 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.
+
+if RbConfig::CONFIG['host_os'] =~ /darwin/i
+  # On OS X we attempt to guess where JAVA_HOME is, if not set
+  ENV['JAVA_HOME'] ||= '/System/Library/Frameworks/JavaVM.framework/Home'
+end
+
+# Base module for all things Java.
+module Java
+
+  # JDK commands: java, javac, javadoc, etc.
+  module Commands
+
+    class << self
+
+      # :call-seq:
+      #   java(class, *args, options?)
+      #
+      # Runs Java with the specified arguments.
+      #
+      # Each argument should be provided as separate array value, e.g.
+      #
+      #  java("-jar", "yuicompressor-2.4.2.jar", "--type","css",
+      #       "src/main/webapp/styles/styles-all.css",
+      #       "-o", "src/main/webapp/styles/styles-all-min.css")
+      #
+      # The last argument may be a Hash with additional options:
+      # * :dir -- The working directory from which to execute task..
+      # * :classpath -- One or more file names, tasks or artifact specifications.
+      #   These are all expanded into artifacts, and all tasks are invoked.
+      # * :java_args -- Any additional arguments to pass (e.g. -hotspot, -xms)
+      # * :properties -- Hash of system properties (e.g. 'path'=>base_dir).
+      # * :name -- Shows this name, otherwise shows the first argument (the class name).
+      # * :verbose -- If true, prints the command and all its argument.
+      # * :pathing_jar -- If true, forces the use of a "pathing" jar, false disables. Nil
+      #                   will default to using a "pathing" jar under windows with long classpaths.
+      #                   See http://stackoverflow.com/questions/201816/how-to-set-a-long-java-classpath-in-msdos-windows
+      def java(*args, &block)
+        options = Hash === args.last ? args.pop : {}
+        options[:verbose] ||= trace?(:java)
+        rake_check_options options, :classpath, :java_args, :properties, :name, :verbose, :dir, :pathing_jar
+
+        name = options[:name]
+        if name.nil?
+          name = "java #{args.first}"
+        end
+
+        cmd_args = []
+        if options[:dir]
+          cmd_args << "cd '#{options[:dir]}' && "
+        end
+        cmd_args << path_to_bin('java')
+        cp = classpath_from(options)
+
+        unless cp.empty?
+          if options[:pathing_jar] == true
+            paths = cp.map do |c|
+              File.directory?(c) && !c.end_with?('/') ? "#{c}/" : c.to_s
+            end
+            manifest = Buildr::Packaging::Java::Manifest.new([{'Class-Path' => paths.map{|p| URI.encode(p)}.join(" ")}])
+            tjar = Tempfile.new(%w[javacmd .jar])
+            Zip::OutputStream.open(tjar.path) do |zos|
+              zos.put_next_entry('META-INF/MANIFEST.MF')
+              zos.write manifest.to_s
+              zos.write "\n"
+            end
+            tjar.close
+
+            cmd_args << '-classpath' << tjar.path
+          else
+            cmd_args << '-classpath' << cp.join(File::PATH_SEPARATOR)
+          end
+        end
+        options[:properties].each { |k, v| cmd_args << "-D#{k}=#{v}" } if options[:properties]
+        cmd_args += (options[:java_args] || (ENV['JAVA_OPTS'] || ENV['JAVA_OPTIONS']).to_s.split).flatten
+        cmd_args += args.flatten.compact
+
+        tmp = nil
+        begin
+          unless Buildr.application.options.dryrun
+            info "Running #{name}" if name && options[:verbose]
+            block = lambda { |ok, res| fail "Failed to execute #{name}, see errors above" unless ok } unless block
+            sh(*cmd_args) do |ok, ps|
+              block.call ok, ps
+            end
+          end
+        ensure
+          unless tmp.nil?
+            tmp.close
+            tmp.unlink
+          end
+        end
+      end
+
+      # :call-seq:
+      #   javac(*files, options)
+      #
+      # Runs Javac with the specified arguments.
+      #
+      # The last argument may be a Hash with additional options:
+      # * :output -- Target directory for all compiled class files.
+      # * :classpath -- One or more file names, tasks or artifact specifications.
+      #   These are all expanded into artifacts, and all tasks are invoked.
+      # * :sourcepath -- Additional source paths to use.
+      # * :javac_args -- Any additional arguments to pass (e.g. -extdirs, -encoding)
+      # * :name -- Shows this name, otherwise shows the working directory.
+      def javac(*args, &block)
+        options = Hash === args.last ? args.pop : {}
+        rake_check_options options, :classpath, :sourcepath, :output, :javac_args, :name
+
+        files = args.flatten.each { |f| f.invoke if f.respond_to?(:invoke) }.map(&:to_s).
+          collect { |arg| File.directory?(arg) ? FileList["#{File.expand_path(arg)}/**/*.java"] : File.expand_path(arg) }.flatten
+        name = options[:name] || Dir.pwd
+
+        cmd_args = []
+        cmd_args << path_to_bin('javac')
+        cp = classpath_from(options)
+        cmd_args << '-classpath' << cp.join(File::PATH_SEPARATOR) unless cp.empty?
+        cmd_args << '-sourcepath' << [options[:sourcepath]].flatten.join(File::PATH_SEPARATOR) if options[:sourcepath]
+        cmd_args << '-d' << File.expand_path(options[:output].to_s) if options[:output]
+        cmd_args += options[:javac_args].flatten if options[:javac_args]
+        Tempfile.open('javac') do |tmp|
+          tmp.write files.join(' ')
+          cmd_args << "@#{tmp.path}"
+        end
+        unless Buildr.application.options.dryrun
+          mkdir_p options[:output] if options[:output]
+          info "Compiling #{files.size} source files in #{name}"
+          block = lambda { |ok, res| fail 'Failed to compile, see errors above' unless ok } unless block
+          sh(*cmd_args) do |ok, ps|
+            block.call ok, ps
+          end
+        end
+      end
+
+      # :call-seq:
+      #   javadoc(*files, options, &block)
+      #
+      # Runs Javadocs with the specified files and options.
+      #
+      # This method accepts the following special options:
+      # * :output -- The output directory
+      # * :classpath -- Array of classpath dependencies.
+      # * :sourcepath -- Array of sourcepaths (paths or tasks).
+      # * :name -- Shows this name, otherwise shows the working directory.
+      #
+      # All other options are passed to Javadoc as following:
+      # * true -- As is, for example, :author=>true becomes -author
+      # * false -- Prefixed, for example, :index=>false becomes -noindex
+      # * string -- Option with value, for example, :windowtitle=>'My project' becomes -windowtitle "My project"
+      # * array -- Option with set of values separated by spaces.
+      def javadoc(*args, &block)
+        options = Hash === args.last ? args.pop : {}
+        fail 'No output defined for javadoc' if options[:output].nil?
+        options[:output] = File.expand_path(options[:output].to_s)
+        cmd_args = []
+        cmd_args << path_to_bin('javadoc')
+        cmd_args << '-d' << options[:output]
+        cmd_args << (trace?(:javadoc) ? '-verbose' : '-quiet')
+
+        options.reject { |key, value| [:output, :name, :sourcepath, :classpath].include?(key) }.
+          each { |key, value| value.invoke if value.respond_to?(:invoke) }.
+          each do |key, value|
+            case value
+            when true, nil
+              cmd_args << "-#{key}"
+            when false
+              cmd_args << "-no#{key}"
+            when Hash
+              value.each { |k,v| cmd_args << "-#{key}" << k.to_s << v.to_s }
+            else
+              cmd_args += Array(value).map { |item| ["-#{key}", item.to_s] }.flatten
+            end
+          end
+        [:sourcepath, :classpath].each do |option|
+          options[option].to_a.flatten.tap do |paths|
+            cmd_args << "-#{option}" << paths.flatten.map(&:to_s).join(File::PATH_SEPARATOR) unless paths.empty?
+          end
+        end
+        files = args.each {|arg| arg.invoke if arg.respond_to?(:invoke)}.collect {|arg| arg.is_a?(Project) ? arg.compile.sources.collect{|dir| Dir["#{File.expand_path(dir.to_s)}/**/*.java"]} : File.expand_path(arg.to_s) }
+        cmd_args += files.flatten.uniq.map(&:to_s)
+        name = options[:name] || Dir.pwd
+        unless Buildr.application.options.dryrun
+          info "Generating Javadoc for #{name}"
+          trace(cmd_args.join(' '))
+          block = lambda { |ok, res| fail 'Failed to generate Javadocs, see errors above' unless ok } unless block
+          sh(*cmd_args) do |ok, ps|
+            block.call ok, ps
+          end
+        end
+      end
+
+      # :call-seq:
+      #   path_to_bin(cmd?) => path
+      #
+      # Returns the path to the specified Java command (with no argument to java itself).
+      def path_to_bin(name = nil)
+        home = ENV['JAVA_HOME'] or fail 'Are we forgetting something? JAVA_HOME not set.'
+        bin = File.expand_path(File.join(home, 'bin'))
+        fail 'JAVA_HOME environment variable does not point to a valid JRE/JDK installation.' unless File.exist? bin
+        File.expand_path(File.join(bin, name.to_s))
+      end
+
+      protected
+
+      # :call-seq:
+      #    classpath_from(options) => files
+      #
+      # Extracts the classpath from the options, expands it by calling artifacts, invokes
+      # each of the artifacts and returns an array of paths.
+      def classpath_from(options)
+        Buildr.artifacts(options[:classpath] || []).map(&:to_s).
+          map { |t| task(t).invoke; File.expand_path(t) }
+      end
+    end
+  end
+end

data/lib/buildr/java/compiler.rb

@@ -0,0 +1,85 @@
+# 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:
+  module Compiler #:nodoc:
+
+    # Javac compiler:
+    #   compile.using(:javac)
+    # Used by default if .java files are found in the src/main/java directory (or src/test/java)
+    # and sets the target directory to target/classes (or target/test/classes).
+    #
+    # Accepts the following options:
+    # * :warnings    -- Issue warnings when compiling.  True when running in verbose mode.
+    # * :debug       -- Generates bytecode with debugging information.  Set from the debug
+    # environment variable/global option.
+    # * :deprecation -- If true, shows deprecation messages.  False by default.
+    # * :source      -- Source code compatibility.
+    # * :target      -- Bytecode compatibility.
+    # * :lint        -- Lint option is one of true, false (default), name (e.g. 'cast') or array.
+    # * :other       -- Array of options passed to the compiler
+    # (e.g. ['-implicit:none', '-encoding', 'iso-8859-1'])
+    class Javac < Base
+
+      OPTIONS = [:warnings, :debug, :deprecation, :source, :target, :lint, :other]
+
+      specify :language=>:java, :target=>'classes', :target_ext=>'class', :packaging=>:jar
+
+      def initialize(project, options) #:nodoc:
+        super
+        options[:debug] = Buildr.options.debug if options[:debug].nil?
+        options[:warnings] ||= false
+        options[:deprecation] ||= false
+        options[:lint] ||= false
+      end
+
+      def compile(sources, target, dependencies) #:nodoc:
+        check_options options, OPTIONS
+        Java::Commands.javac(files_from_sources(sources),
+                             :classpath => dependencies,
+                             :sourcepath => sources.select { |source| File.directory?(source) },
+                             :output => target,
+                             :javac_args => self.javac_args)
+      end
+
+      # Filter out source files that are known to not produce any corresponding .class output file. If we leave
+      # this type of file in the generated compile map the compiler will always be run due to missing output files.
+      def compile_map(sources, target)
+        map = super
+        map.reject! { |key,_| File.basename(key) == 'package-info.java' } || map
+      end
+
+    private
+
+      def javac_args #:nodoc:
+        args = []
+        args << '-nowarn' unless options[:warnings]
+        args << '-verbose' if trace?(:javac)
+        args << '-g' if options[:debug]
+        args << '-deprecation' if options[:deprecation]
+        args << '-source' << options[:source].to_s if options[:source]
+        args << '-target' << options[:target].to_s if options[:target]
+        case options[:lint]
+          when Array  then args << "-Xlint:#{options[:lint].join(',')}"
+          when String then args << "-Xlint:#{options[:lint]}"
+          when true   then args << '-Xlint'
+        end
+        args + Array(options[:other])
+      end
+    end
+  end
+end
+
+Buildr::Compiler << Buildr::Compiler::Javac

data/lib/buildr/java/custom_pom.rb

@@ -0,0 +1,300 @@
+# 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
+  class CustomPom
+    Developer = Struct.new(:id, :name, :email, :roles)
+
+    # Specify the name of the project
+    attr_writer :name
+
+    # Retrieve the name of the project, defaulting to the project description or the name if not specified
+    def name
+      @name || @buildr_project.comment || @buildr_project.name
+    end
+
+    # Specify a project description
+    attr_writer :description
+
+    # Retrieve the project description, defaulting to the name if not specified
+    def description
+      @description || name
+    end
+
+    # Property for the projects url
+    attr_accessor :url
+
+    # Return the map of licenses for project
+    def licenses
+      @licenses ||= {}
+    end
+
+    # Add Apache2 to the list of licenses
+    def add_apache_v2_license
+      self.licenses['The Apache Software License, Version 2.0'] = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+    end
+
+    def add_bsd_2_license
+      self.licenses['The BSD 2-Clause License'] = 'http://opensource.org/licenses/BSD-2-Clause'
+    end
+
+    def add_bsd_3_license
+      self.licenses['The BSD 3-Clause License'] = 'http://opensource.org/licenses/BSD-3-Clause'
+    end
+
+    def add_cddl_v1_license
+      self.licenses['Common Development and Distribution License (CDDL-1.0)'] = 'http://opensource.org/licenses/CDDL-1.0'
+    end
+
+    def add_epl_v1_license
+      self.licenses['Eclipse Public License - v 1.0'] = 'http://www.eclipse.org/legal/epl-v10.html'
+    end
+
+    def add_gpl_v1_license
+      self.licenses['GNU General Public License (GPL) version 1.0'] = 'http://www.gnu.org/licenses/gpl-1.0.html'
+    end
+
+    def add_gpl_v2_license
+      self.licenses['GNU General Public License (GPL) version 2.0'] = 'http://www.gnu.org/licenses/gpl-2.0.html'
+    end
+
+    def add_gpl_v3_license
+      self.licenses['GNU General Public License (GPL) version 3.0'] = 'http://www.gnu.org/licenses/gpl-3.0.html'
+    end
+
+    def add_lgpl_v2_license
+      self.licenses['GNU General Lesser Public License (LGPL) version 2.1'] = 'http://www.gnu.org/licenses/lgpl-2.1.html'
+    end
+
+    def add_lgpl_v3_license
+      self.licenses['GNU General Lesser Public License (LGPL) version 3.0'] = 'http://www.gnu.org/licenses/lgpl-3.0.html'
+    end
+
+    def add_mit_license
+      self.licenses['The MIT License'] = 'http://opensource.org/licenses/MIT'
+    end
+
+    attr_accessor :scm_url
+    attr_accessor :scm_connection
+    attr_accessor :scm_developer_connection
+
+    attr_accessor :issues_url
+    attr_accessor :issues_system
+
+    # Add a project like add_github_project('realityforge/gwt-appcache')
+    def add_github_project(project_spec)
+      git_url = "git@github.com:#{project_spec}.git"
+      self.scm_connection = self.scm_developer_connection = "scm:git:#{git_url}"
+      self.scm_url = git_url
+      web_url = "https://github.com/#{project_spec}"
+      self.url = web_url
+      self.issues_url = "#{web_url}/issues"
+      self.issues_system = 'GitHub Issues'
+    end
+
+    def developers
+      @developers ||= []
+    end
+
+    def add_developer(id, name = nil, email = nil, roles = nil)
+      self.developers << Developer.new(id, name, email, roles)
+    end
+
+    def provided_dependencies
+      @provided_dependencies ||= []
+    end
+
+    def provided_dependencies=(provided_dependencies)
+      @provided_dependencies = provided_dependencies
+    end
+
+    def runtime_dependencies
+      @runtime_dependencies ||= []
+    end
+
+    def runtime_dependencies=(runtime_dependencies)
+      @runtime_dependencies = runtime_dependencies
+    end
+
+    def additional_dependencies
+      @additional_dependencies ||= []
+    end
+
+    def additional_dependencies=(additional_dependencies)
+      @additional_dependencies = additional_dependencies
+    end
+
+    def include_transitive_dependencies
+      @include_transitive_dependencies ||= []
+    end
+
+    def include_transitive_dependencies=(include_transitive_dependencies)
+      @include_transitive_dependencies = include_transitive_dependencies
+    end
+
+    def optional_dependencies
+      @optional_dependencies ||= []
+    end
+
+    def optional_dependencies=(optional_dependencies)
+      @optional_dependencies = optional_dependencies
+    end
+
+    # Property that accepts a proc that accepts a dependency and returns a boolean to
+    # determine whether dependency is included in pom or not.
+    attr_accessor :dependency_filter
+
+    protected
+
+    def associate_project(buildr_project)
+      @buildr_project = buildr_project
+    end
+
+    def self.pom_xml(project, package)
+      Proc.new do
+        xml = Builder::XmlMarkup.new(:indent => 2)
+        xml.instruct!
+        xml.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') do
+          xml.modelVersion '4.0.0'
+          xml.groupId project.group
+          xml.artifactId project.id
+          xml.version project.version
+          candidates = project.packages.select{|p| p.classifier.nil? }.collect{|p|p.type.to_s}
+          packaging = !candidates.empty? ? candidates[0] : (project.compile.packaging || :zip).to_s
+          xml.packaging packaging
+
+          xml.name project.pom.name if project.pom.name
+          xml.description project.pom.description if project.pom.description
+          xml.url project.pom.url if project.pom.url
+
+          xml.licenses do
+            project.pom.licenses.each_pair do |name, url|
+              xml.license do
+                xml.name name
+                xml.url url
+                xml.distribution 'repo'
+              end
+            end
+          end unless project.pom.licenses.empty?
+
+          if project.pom.scm_url || project.pom.scm_connection || project.pom.scm_developer_connection
+            xml.scm do
+              xml.connection project.pom.scm_connection if project.pom.scm_connection
+              xml.developerConnection project.pom.scm_developer_connection if project.pom.scm_developer_connection
+              xml.url project.pom.scm_url if project.pom.scm_url
+            end
+          end
+
+          if project.pom.issues_url
+            xml.issueManagement do
+              xml.url project.pom.issues_url
+              xml.system project.pom.issues_system if project.pom.issues_system
+            end
+          end
+
+          xml.developers do
+            project.pom.developers.each do |developer|
+              xml.developer do
+                xml.id developer.id
+                xml.name developer.name if developer.name
+                xml.email developer.email if developer.email
+                if developer.roles
+                  xml.roles do
+                    developer.roles.each do |role|
+                      xml.role role
+                    end
+                  end
+                end
+              end
+            end
+          end unless project.pom.developers.empty?
+
+          provided_deps = Buildr.artifacts(project.pom.provided_dependencies)
+          runtime_deps = Buildr.artifacts(project.pom.runtime_dependencies)
+          additional_deps = Buildr.artifacts(project.pom.additional_dependencies)
+          include_transitive_deps = Buildr.artifacts(project.pom.include_transitive_dependencies).collect {|dep| dep.to_s}
+          optional_deps = Buildr.artifacts(project.pom.optional_dependencies).collect {|dep| dep.to_s}
+
+          done = []
+
+          deps = []
+          deps += provided_deps.
+            select {|d| d.is_a?(ActsAsArtifact)}.
+            select {|d| !done.include?(d.to_s)}.
+            collect {|dep| done << dep.to_s; dep.to_hash.merge(:scope => 'provided', :optional => optional_deps.include?(dep.to_s), :include_transitive => include_transitive_deps.include?(dep.to_s), :artifact => dep)}
+          deps += runtime_deps.
+            select {|d| d.is_a?(ActsAsArtifact)}.
+            select {|d| !done.include?(d.to_s)}.
+            collect {|dep| done << dep.to_s; dep.to_hash.merge(:scope => 'runtime', :optional => optional_deps.include?(dep.to_s), :include_transitive => include_transitive_deps.include?(dep.to_s), :artifact => dep)}
+          deps += additional_deps.
+            select {|d| d.is_a?(ActsAsArtifact)}.
+            select {|d| !done.include?(d.to_s)}.
+            collect {|dep| done << dep.to_s; dep.to_hash.merge(:scope => 'compile', :optional => optional_deps.include?(dep.to_s), :include_transitive => include_transitive_deps.include?(dep.to_s), :artifact => dep)}
+
+          deps +=
+            Buildr.artifacts(project.compile.dependencies).
+              select {|d| d.is_a?(ActsAsArtifact)}.
+              select {|d| !done.include?(d.to_s)}.
+              collect {|d| done << d.to_s; d.to_hash.merge(:scope => 'compile', :optional => optional_deps.include?(d.to_s), :include_transitive => include_transitive_deps.include?(d.to_s), :artifact => d)}
+
+          deps += Buildr.artifacts(project.test.compile.dependencies).
+            select {|d| d.is_a?(ActsAsArtifact)}.
+            select {|d| !done.include?(d.to_s)}.
+            collect {|d| d.to_hash.merge(:scope => 'test', :include_transitive => include_transitive_deps.include?(d.to_s), :artifact => d)}
+
+          xml.dependencies do
+            deps.select {|dependency| project.pom.dependency_filter.nil? ? true : project.pom.dependency_filter.call(dependency)}.each do |dependency|
+              xml.dependency do
+                xml.groupId dependency[:group]
+                xml.artifactId dependency[:id]
+                xml.version dependency[:version]
+                xml.classifier dependency[:classifier] if dependency[:classifier] && dependency[:classifier].to_s != 'jar'
+                xml.scope dependency[:scope] unless dependency[:scope] == 'compile'
+                xml.optional true if dependency[:optional]
+                unless dependency[:include_transitive]
+                  xml.exclusions do
+                    xml.exclusion do
+                      xml.groupId '*'
+                      xml.artifactId '*'
+                    end
+                  end
+                end
+              end
+            end
+          end unless deps.empty?
+        end
+      end
+    end
+  end
+  module CPom
+    module ProjectExtension
+      include Extension
+
+      def pom
+        unless @pom
+          @pom = parent ? parent.pom.dup : Buildr::CustomPom.new
+          @pom.send :associate_project, self
+        end
+        @pom
+      end
+    end
+  end
+end
+
+class Buildr::Project
+  include Buildr::CPom::ProjectExtension
+end