realityforge-buildr 1.5.9

data/lib/buildr/core/assets.rb

@@ -0,0 +1,96 @@
+# 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 Assets #:nodoc:
+
+    # The base assets task that is responsible for
+    # collecting all of the assets into a single output
+    # directory
+    class AssetsTask < Rake::FileTask
+      attr_reader :project
+
+      def project=(project)
+        @project = project
+      end
+
+      # The list of input paths to add to output directory
+      def paths
+        unless @paths
+          @paths = []
+          @paths << project._(:source, :main, :assets) if File.exist?(project._(:source, :main, :assets))
+        end
+        @paths
+      end
+
+      protected
+
+      def initialize(*args) #:nodoc:
+        super
+        enhance do
+          paths = self.paths.flatten.compact
+          if paths.size > 0
+            mkdir_p name
+            paths.collect do |a|
+              a.is_a?(String) ? project.file(a) : a
+            end.each do |a|
+              a.invoke if a.respond_to?(:invoke)
+            end.each do |asset|
+              cp_r Dir["#{asset}/*"], "#{name}/"
+            end
+          end
+        end
+      end
+
+      private
+
+      def out_of_date?(stamp)
+        super ||
+          self.paths.any? { |n| n.respond_to?(:needed?) && n.needed? }
+      end
+
+    end
+
+    module ProjectExtension
+      include Extension
+
+      first_time do
+        desc "Prepare the assets"
+        Project.local_task("assets")
+      end
+
+      before_define do |project|
+        # Force the construction of the assets task
+        project.assets.paths
+      end
+
+      # Access the asset task
+      def assets
+        if @assets.nil?
+          @assets = AssetsTask.define_task(project._(:target, :main, :assets) => [])
+          @assets.project = self
+          project.task('assets').enhance([@assets])
+          project.build.enhance([@assets])
+        end
+        @assets
+      end
+    end
+  end
+end
+
+class Buildr::Project #:nodoc:
+  include ::Buildr::Assets::ProjectExtension
+end

data/lib/buildr/core/build.rb

@@ -0,0 +1,587 @@
+# 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:
+
+  class Options
+
+    # Runs the build in parallel when true (defaults to false). You can force a parallel build by
+    # setting this option directly, or by running the parallel task ahead of the build task.
+    #
+    # This option only affects recursive tasks. For example:
+    #   buildr parallel package
+    # will run all package tasks (from the sub-projects) in parallel, but each sub-project's package
+    # task runs its child tasks (prepare, compile, resources, etc) in sequence.
+    attr_accessor :parallel
+
+  end
+
+  task('parallel') { Buildr.options.parallel = true }
+
+
+  module Build
+
+    include Extension
+
+    first_time do
+      desc 'Build the project'
+      Project.local_task('build') { |name| "Building #{name}" }
+      desc 'Clean files generated during a build'
+      Project.local_task('clean') { |name| "Cleaning #{name}" }
+
+      desc 'The default task is build'
+      task 'default'=>'build'
+    end
+
+    before_define(:build => [:compile, :test]) do |project|
+      project.recursive_task 'build'
+      project.recursive_task 'clean'
+      project.clean do
+        rm_rf project.path_to(:target)
+        rm_rf project.path_to(:reports)
+      end
+    end
+
+    after_define(:build)
+
+    # :call-seq:
+    #    build(*prereqs) => task
+    #    build { |task| .. } => task
+    #
+    # Returns the project's build task. With arguments or block, also enhances that task.
+    def build(*prereqs, &block)
+      task('build').enhance prereqs, &block
+    end
+
+    # :call-seq:
+    #    clean(*prereqs) => task
+    #    clean { |task| .. } => task
+    #
+    # Returns the project's clean task. With arguments or block, also enhances that task.
+    def clean(*prereqs, &block)
+      task('clean').enhance prereqs, &block
+    end
+
+  end
+
+  module Hg #:nodoc:
+    module_function
+
+    # :call-seq:
+    #   hg(*args)
+    #
+    # Executes a Mercurial (hg) command passing through the args and returns the output.
+    # Throws exception if the exit status is not zero. For example:
+    #   hg 'commit'
+    #   hg 'update', 'default'
+    def hg(*args)
+      cmd = "hg #{args.shift} #{args.map { |arg| arg.inspect }.join(' ')}"
+      output = `#{cmd}`
+      fail "Mercurial command \"#{cmd}\" failed with status #{$?.exitstatus}\n#{output}" unless $?.exitstatus == 0
+      return output
+    end
+
+    # Return a list of uncommitted / untracked files as reported by hg status
+    # The codes used to show the status of files are:
+    #   M = modified
+    #   A = added
+    #   R = removed
+    #   C = clean
+    #   ! = missing (deleted by non-hg command, but still tracked)
+    #   ? = not tracked
+    #   I = ignored
+    #     = origin of the previous file listed as A (added)
+    def uncommitted_files
+      `hg status`.scan(/^(A|M|R|!|\?) (\S.*)$/).map{ |match| match.last.split.last }
+    end
+
+    # Commit the given file with a message. The file should already be added to the Mercurial index.
+    def commit(file, message)
+      hg 'commit', '-m', message, file
+    end
+
+    # Update the remote branch with the local commits
+    # This will push the current remote destination and current branch.
+    def push
+      hg 'push'
+    end
+
+    # Return the name of the current local branch or nil if none.
+    def current_branch
+      hg('branch').to_s.strip
+    end
+
+    # Return the aliases (if any) of any remote repositories which the current local branch tracks
+    def remote
+      hg('paths').scan(/^(?:default|default-push)\s+=\s+(\S.*)/).map{ |match| match.last }
+    end
+  end
+
+  module Git  #:nodoc:
+    module_function
+
+    # :call-seq:
+    #   git(*args)
+    #
+    # Executes a Git command and returns the output. Throws exception if the exit status
+    # is not zero. For example:
+    #   git 'commit'
+    #   git 'remote', 'show', 'origin'
+    def git(*args)
+      cmd = "git #{args.shift} #{args.map { |arg| arg.inspect }.join(' ')}"
+      output = `#{cmd}`
+      fail "GIT command \"#{cmd}\" failed with status #{$?.exitstatus}\n#{output}" unless $?.exitstatus == 0
+      return output
+    end
+
+    # Returns list of uncommited/untracked files as reported by git status.
+    def uncommitted_files
+      `git status`.scan(/^#(\t|\s{7})(\S.*)$/).map { |match| match.last.split.last }
+    end
+
+    # Commit the given file with a message.
+    # The file has to be known to Git meaning that it has either to have been already committed in the past
+    # or freshly added to the index. Otherwise it will fail.
+    def commit(file, message)
+      git 'commit', '-m', message, file
+    end
+
+    # Update the remote refs using local refs
+    #
+    # By default, the "remote" destination of the push is the the remote repo linked to the current branch.
+    # The default remote branch is the current local branch.
+    def push(remote_repo = remote, remote_branch = current_branch)
+      git 'push', remote, current_branch
+    end
+
+    # Return the name of the remote repository whose branch the current local branch tracks,
+    # or nil if none.
+    def remote(branch = current_branch)
+      remote = git('config', '--get', "branch.#{branch}.remote").to_s.strip
+      remote if !remote.empty? && git('remote').include?(remote)
+    end
+
+    # Return the name of the current branch
+    def current_branch
+      git('branch')[/^\* (.*)$/, 1]
+    end
+  end
+
+
+  module Svn #:nodoc:
+    module_function
+
+    # :call-seq:
+    #   svn(*args)
+    #
+    # Executes a SVN command and returns the output. Throws exception if the exit status
+    # is not zero. For example:
+    #   svn 'commit'
+    def svn(*args)
+      output = `svn #{args.shift} #{args.map { |arg| arg.inspect }.join(' ')}`
+      fail "SVN command failed with status #{$?.exitstatus}" unless $?.exitstatus == 0
+      return output
+    end
+
+    def tag(tag_name)
+      url = tag_url repo_url, tag_name
+      remove url, 'Removing old copy' rescue nil
+      copy Dir.pwd, url, "Release #{tag_name}"
+    end
+
+    # Status check reveals modified files, but also SVN externals which we can safely ignore.
+    def uncommitted_files
+      svn('status', '--ignore-externals').split("\n").reject { |line| line =~ /^X\s/ }
+    end
+
+    def commit(file, message)
+      svn 'commit', '-m', message, file
+    end
+
+    # :call-seq:
+    #   tag_url(svn_url, version) => tag_url
+    #
+    # Returns the SVN url for the tag.
+    # Can tag from the trunk or from branches.
+    # Can handle the two standard repository layouts.
+    #   - http://my.repo/foo/trunk => http://my.repo/foo/tags/1.0.0
+    #   - http://my.repo/trunk/foo => http://my.repo/tags/foo/1.0.0
+    def tag_url(svn_url, tag)
+      trunk_or_branches = Regexp.union(%r{^(.*)/trunk(.*)$}, %r{^(.*)/branches(.*)/([^/]*)$})
+      match = trunk_or_branches.match(svn_url)
+      prefix = match[1] || match[3]
+      suffix = match[2] || match[4]
+      prefix + '/tags' + suffix + '/' + tag
+    end
+
+    # Return the current SVN URL
+    def repo_url
+      svn('info', '--xml')[/<url>(.*?)<\/url>/, 1].strip
+    end
+
+    def copy(dir, url, message)
+      svn 'copy', '--parents', dir, url, '-m', message
+    end
+
+    def remove(url, message)
+      svn 'remove', url, '-m', message
+    end
+
+  end
+
+
+  class Release #:nodoc:
+
+    THIS_VERSION_PATTERN  = /(THIS_VERSION|VERSION_NUMBER)\s*=\s*(["'])(.*)\2/
+
+    class << self
+
+      # Use this to specify a different tag name for tagging the release in source control.
+      # You can set the tag name or a proc that will be called with the version number,
+      # for example:
+      #   Release.tag_name = lambda { |ver| "foo-#{ver}" }
+      attr_accessor :tag_name
+
+      # Use this to specify a different commit message to commit the buildfile with the next version in source control.
+      # You can set the commit message or a proc that will be called with the next version number,
+      # for example:
+      #   Release.commit_message = lambda { |ver| "Changed version number to #{ver}" }
+      attr_accessor :commit_message
+
+      # Use this to specify the next version number to replace VERSION_NUMBER with in the buildfile.
+      # You can set the next version or a proc that will be called with the current version number.
+      # For example, with the following buildfile:
+      #   THIS_VERSION = "1.0.0-rc1"
+      #   Release.next_version = lambda { |version|
+      #       version[-1] = version[-1].to_i + 1
+      #       version
+      #   }
+      #
+      # Release.next_version will return "1.0.0-rc2", so at the end of the release, the buildfile will contain VERSION_NUMBER = "1.0.0-rc2"
+      #
+      attr_accessor :next_version
+
+      # :call-seq:
+      #     add(MyReleaseClass)
+      #
+      # Add a Release implementation to the list of available Release classes.
+      def add(release)
+        @list ||= []
+        @list |= [release]
+      end
+      alias :<< :add
+
+      # The list of supported Release implementations
+      def list
+        @list ||= []
+      end
+
+      # Finds and returns the Release instance for this project.
+      def find
+        unless @release
+          klass = list.detect { |impl| impl.applies_to? }
+          @release = klass.new if klass
+        end
+        @release
+      end
+
+    end
+
+    # :call-seq:
+    #   make()
+    #
+    # Make a release.
+    def make
+      @this_version = extract_version
+      check
+      with_release_candidate_version do |release_candidate_buildfile|
+        args = []
+        args << 'buildr' << '--buildfile' << release_candidate_buildfile
+        args << '--environment' << Buildr.environment unless Buildr.environment.to_s.empty?
+        args << 'clean' << 'upload' << 'DEBUG=no'
+        sh *args
+      end
+      tag_release resolve_tag
+      update_version_to_next if this_version != resolve_next_version(this_version)
+    end
+
+    def check
+      if this_version == resolve_next_version(this_version) && this_version.match(/-SNAPSHOT$/)
+        fail "The next version can't be equal to the current version #{this_version}.\nUpdate THIS_VERSION/VERSION_NUMBER, specify Release.next_version or use NEXT_VERSION env var"
+      end
+    end
+
+    # :call-seq:
+    #   extract_version() => this_version
+    #
+    # Extract the current version number from the buildfile.
+    # Raise an error if not found.
+    def extract_version
+      buildfile = File.read(version_file)
+      buildfile.scan(THIS_VERSION_PATTERN)[0][2]
+    rescue
+      fail 'Looking for THIS_VERSION = "..." in your Buildfile, none found'
+    end
+
+  protected
+
+    # the initial value of THIS_VERSION
+    attr_accessor :this_version
+
+    # :call-seq:
+    #   version_file()
+    # Provides the file containing the version of the project.
+    # If the project contains a version.rb file next to the Buildr build file,
+    # it is used. Otherwise, always use the buildfile.
+    def version_file
+      version_rb_file = File.dirname(Buildr.application.buildfile.to_s)  + '/version.rb'
+      return version_rb_file if File.exists?(version_rb_file)
+      return Buildr.application.buildfile.to_s
+    end
+
+    # :call-seq:
+    #   with_release_candidate_version() { |filename| ... }
+    #
+    # Yields to block with release candidate buildfile, before committing to use it.
+    #
+    # We need a Buildfile with upgraded version numbers to run the build, but we don't want the
+    # Buildfile modified unless the build succeeds. So this method updates the version number in
+    # a separate (Buildfile.next) file, yields to the block with that filename, and if successful
+    # copies the new file over the existing one.
+    #
+    # The release version is the current version without '-SNAPSHOT'.  So:
+    #   THIS_VERSION = 1.1.0-SNAPSHOT
+    # becomes:
+    #   THIS_VERSION = 1.1.0
+    # for the release buildfile.
+    def with_release_candidate_version
+      release_candidate_buildfile = version_file + '.next'
+
+      release_candidate_buildfile_contents = change_version { |version|
+        version.gsub(/-SNAPSHOT$/, "")
+      }
+      File.open(release_candidate_buildfile, 'w') { |file| file.write release_candidate_buildfile_contents }
+      begin
+        yield release_candidate_buildfile
+        mv release_candidate_buildfile, version_file
+      ensure
+        rm release_candidate_buildfile rescue nil
+      end
+    end
+
+    # :call-seq:
+    #   change_version() { |this_version| ... } => buildfile
+    #
+    # Change version number in the current Buildfile, but without writing a new file (yet).
+    # Returns the contents of the Buildfile with the modified version number.
+    #
+    # This method yields to the block with the current (this) version number and expects
+    # the block to return the updated version.
+    def change_version
+      current_version = extract_version
+      new_version = yield(current_version)
+      buildfile = File.read(version_file)
+      buildfile.gsub(THIS_VERSION_PATTERN) { |ver| ver.sub(/(["']).*\1/, %Q{"#{new_version}"}) }
+    end
+
+    # Return the name of the tag to tag the release with.
+    def resolve_tag
+      version = extract_version
+      tag = Release.tag_name || version
+      tag = tag.call(version) if Proc === tag
+      tag
+    end
+
+    # Return the new value of THIS_VERSION based on the version passed.
+    #
+    # This method receives the existing value of THIS_VERSION
+    def resolve_next_version(current_version)
+        next_version = Release.next_version
+        next_version ||= lambda { |v|
+          snapshot = v.match(/-SNAPSHOT$/)
+          version = v.gsub(/-SNAPSHOT$/, "").split(/\./)
+          if snapshot
+            version[-1] = sprintf("%0#{version[-1].size}d", version[-1].to_i + 1) + '-SNAPSHOT'
+          end
+          version.join('.')
+        }
+        next_version = ENV['NEXT_VERSION'] if ENV['NEXT_VERSION']
+        next_version = ENV['next_version'] if ENV['next_version']
+        next_version = next_version.call(current_version) if Proc === next_version
+        next_version
+    end
+
+    # Move the version to next and save the updated buildfile
+    def update_buildfile
+      buildfile = change_version { |version| # THIS_VERSION minus SNAPSHOT
+        resolve_next_version(this_version) # THIS_VERSION
+      }
+      File.open(version_file, 'w') { |file| file.write buildfile }
+    end
+
+    # Return the message to use to commit the buildfile with the next version
+    def message
+      version = extract_version
+      msg = Release.commit_message || "Changed version number to #{version}"
+      msg = msg.call(version) if Proc === msg
+      msg
+    end
+
+    def update_version_to_next
+      update_buildfile
+    end
+  end
+
+
+  class HgRelease < Release
+    class << self
+      def applies_to?
+        if File.exist? '.hg/requires'
+          true
+        else
+          curr_pwd = Dir.pwd
+          Dir.chdir('..') do
+            return false if curr_pwd == Dir.pwd # Means going up one level is not possible.
+            applies_to?
+          end
+        end
+      end
+    end
+
+    # Fails if one of these 2 conditions are not met:
+    #   1. The reository is not 'clean'; no content staged or unstaged
+    #   2. The repository is only a local repository and has no remote refs
+    def check
+      super
+      info "Working in branch '#{Hg.current_branch}'"
+      uncommitted = Hg.uncommitted_files
+      fail "Uncommitted files violate the First Principle Of Release!\n#{uncommitted.join("\n")}" unless uncommitted.empty?
+      fail "You are releasing from a local branch that does not track a remote!" if Hg.remote.empty?
+    end
+
+    # Tag this release in Mercurial
+    def tag_release(tag)
+      unless this_version == extract_version
+        info "Committing buildfile with version number #{extract_version}"
+        Hg.commit File.basename(version_file), message
+        Hg.push if Hg.remote
+      end
+      info "Tagging release #{tag}"
+      Hg.hg 'tag', tag, '-m', "[buildr] Cutting release #{tag}"
+      Hg.push if Hg.remote
+    end
+
+    # Update buildfile with next version number
+    def update_version_to_next
+      super
+      info "Current version is now #{extract_version}"
+      Hg.commit File.basename(version_file), message
+      Hg.push if Hg.remote
+    end
+  end
+
+
+  class GitRelease < Release
+    class << self
+      def applies_to?
+        if File.exist? '.git/config'
+          true
+        else
+          curr_pwd = Dir.pwd
+          Dir.chdir('..') do
+            return false if curr_pwd == Dir.pwd # Means going up one level is not possible.
+            applies_to?
+          end
+        end
+      end
+    end
+
+    # Fails if one of these 2 conditions are not met:
+    #    1. the repository is clean: no content staged or unstaged
+    #    2. some remote repositories are defined but the current branch does not track any
+    def check
+      super
+      uncommitted = Git.uncommitted_files
+      fail "Uncommitted files violate the First Principle Of Release!\n#{uncommitted.join("\n")}" unless uncommitted.empty?
+      fail "You are releasing from a local branch that does not track a remote!" unless Git.remote
+    end
+
+    # Add a tag reference in .git/refs/tags and push it to the remote if any.
+    # If a tag with the same name already exists it will get deleted (in both local and remote repositories).
+    def tag_release(tag)
+      unless this_version == extract_version
+        info "Committing buildfile with version number #{extract_version}"
+        Git.commit File.basename(version_file), message
+        Git.push if Git.remote
+      end
+      info "Tagging release #{tag}"
+      Git.git 'tag', '-d', tag rescue nil
+      Git.git 'push', Git.remote, ":refs/tags/#{tag}" rescue nil if Git.remote
+      Git.git 'tag', '-a', tag, '-m', "[buildr] Cutting release #{tag}"
+      Git.git 'push', Git.remote, 'tag', tag if Git.remote
+    end
+
+    def update_version_to_next
+      super
+      info "Current version is now #{extract_version}"
+      Git.commit File.basename(version_file), message
+      Git.push if Git.remote
+    end
+  end
+
+
+  class SvnRelease < Release
+    class << self
+      def applies_to?
+        File.exist?('.svn')
+      end
+    end
+
+    def check
+      super
+      fail "Uncommitted files violate the First Principle Of Release!\n"+Svn.uncommitted_files.join("\n") unless Svn.uncommitted_files.empty?
+      fail "SVN URL must contain 'trunk' or 'branches/...'" unless Svn.repo_url =~ /(trunk)|(branches.*)$/
+    end
+
+    def tag_release(tag)
+      # Unlike Git, committing the buildfile with the released version is not necessary.
+      # svn tag does commit & tag.
+      info "Tagging release #{tag}"
+      Svn.tag tag
+    end
+
+    def update_version_to_next
+      super
+      info "Current version is now #{extract_version}"
+      Svn.commit version_file, message
+    end
+  end
+
+  Release.add HgRelease
+  Release.add SvnRelease
+  Release.add GitRelease
+
+  desc 'Make a release'
+  task 'release' do |task|
+    release = Release.find
+    fail 'Unable to detect the Version Control System.' unless release
+    release.make
+  end
+
+end
+
+class Buildr::Project #:nodoc:
+  include Buildr::Build
+end