buildr 1.2.10 → 1.3.0

data/lib/core/application.rb

@@ -1,188 +0,0 @@
-module Buildr
-
-  # When running from +rake+, we already have an Application setup and must plug into it,
-  # since the top-level tasks come from there. When running from +buildr+, we get to load
-  # Rake and set everything up, and we use our own Application full of cool Buildr features.
-  if defined?(Rake)
-    Rake.application.top_level_tasks.unshift task("buildr:initialize")
-  else
-
-    require "rake"
-
-    class Application < Rake::Application #:nodoc:
-
-      DEFAULT_BUILDFILES = ["buildfile", "Buildfile"] + DEFAULT_RAKEFILES
-
-      OPTIONS = [     # :nodoc:
-        ['--help',     '-H', GetoptLong::NO_ARGUMENT,
-          "Display this help message."],
-        ['--nosearch', '-N', GetoptLong::NO_ARGUMENT,
-          "Do not search parent directories for the buildfile."],
-        ['--quiet',    '-q', GetoptLong::NO_ARGUMENT,
-          "Do not log messages to standard output."],
-        ['--buildfile', '-f', GetoptLong::REQUIRED_ARGUMENT,
-          "Use FILE as the buildfile."],
-        ['--require',  '-r', GetoptLong::REQUIRED_ARGUMENT,
-          "Require MODULE before executing buildfile."],
-        ['--trace',    '-t', GetoptLong::NO_ARGUMENT,
-          "Turn on invoke/execute tracing, enable full backtrace."],
-        ['--version',  '-V', GetoptLong::NO_ARGUMENT,
-          "Display the program version."],
-        ['--environment', '-e', GetoptLong::REQUIRED_ARGUMENT,
-          "Environment name (e.g. development, test, production)."],
-        ['--freeze',   "-F",  GetoptLong::NO_ARGUMENT,
-         "Freezes the Buildfile so it always uses Buildr version #{Buildr::VERSION}"],
-        ['--unfreeze', "-U",  GetoptLong::NO_ARGUMENT,
-         "Unfreezes the Buildfile to use the latest version of Buildr"]
-      ]
-
-      def initialize()
-        super
-        @rakefiles = DEFAULT_BUILDFILES
-        @name = "Buildr"
-        @requires = []
-        opts = GetoptLong.new(*command_line_options)
-        opts.each { |opt, value| do_option(opt, value) }
-        collect_tasks
-        top_level_tasks.unshift "buildr:initialize"
-      end
-
-      def run()
-        standard_exception_handling do
-          find_buildfile
-          load_buildfile
-          top_level
-        end
-      end
-
-      def do_option(opt, value)
-        case opt
-        when '--help'
-          help
-          exit
-        when "--buildfile"
-          @rakefiles.clear
-          @rakefiles << value
-        when '--version'
-          puts "Buildr, version #{Buildr::VERSION}"
-          exit
-        when '--environment'
-          ENV['BUILDR_ENV'] = value
-        when "--freeze" 
-          find_buildfile
-          puts "Freezing the Buildfile so it always uses Buildr version #{Buildr::VERSION}"
-          original = File.read(rakefile)
-          if original =~ /gem\s*(["'])buildr\1/
-            modified = original.sub(/gem\s*(["'])buildr\1\s*,\s*(["']).*\2/, %{gem "buildr", "#{Buildr::VERSION}"})
-          else
-            modified = %{gem "buildr", "#{Buildr::VERSION}"\n} + original
-          end
-          File.open(rakefile, "w") { |file| file.write modified }
-          exit
-        when "--unfreeze"
-          find_buildfile
-          puts "Unfreezing the Buildfile to use the latest version of Buildr from your Gems repository."
-          modified = File.read(rakefile).sub(/^\s*gem\s*(["'])buildr\1.*\n/, "")
-          File.open(rakefile, "w") { |file| file.write modified }
-          exit
-        when "--require"
-          @requires << value
-        when "--nosearch", "--quiet", "--trace"
-          super
-        end
-      end
-
-      def find_buildfile()
-        here = Dir.pwd
-        while ! have_rakefile
-          Dir.chdir("..")
-          if Dir.pwd == here || options.nosearch
-            error = "No Buildfile found (looking for: #{@rakefiles.join(', ')})"
-            if STDIN.isatty
-              chdir(original_dir) { task("generate").invoke }
-              exit 1
-            else
-              raise error
-            end
-          end
-          here = Dir.pwd
-        end
-      end
-
-      def load_buildfile()
-        @requires.each { |name| require name }
-        puts Buildr.environment ? "(in #{Dir.pwd}, #{Buildr.environment})" : "(in #{Dir.pwd})"
-        load File.expand_path(@rakefile) if @rakefile != ''
-        load_imports
-      end
-
-      def usage()
-        puts "Buildr #{Buildr::VERSION}"
-        puts
-        puts "Usage:"
-        puts "  buildr [-f buildfile] {options} targets..."
-      end
-
-      def help()
-        usage
-        puts
-        puts "Options:"
-        OPTIONS.sort.each do |long, short, mode, desc|
-          if mode == GetoptLong::REQUIRED_ARGUMENT
-            if desc =~ /\b([A-Z]{2,})\b/
-              long = long + "=#{$1}"
-            end
-          end
-          printf "  %-20s (%s)\n", long, short
-          printf "      %s\n", desc
-        end
-        puts
-        puts "For help with your buildfile:"
-        puts "  buildr help"
-      end
-
-      def command_line_options
-        OPTIONS.collect { |lst| lst[0..-2] }
-      end
-    end
-
-    Rake.application = Buildr::Application.new
-  end
-
-
-  class << self
-
-    # Loads buildr.rake files from users home directory and project directory.
-    # Loads custom tasks from .rake files in tasks directory.
-    def load_tasks_and_local_files() #:nodoc:
-      return false if @build_files
-      # Load the settings files.
-      @build_files = [ File.expand_path("buildr.rb", Gem::user_home), "buildr.rb" ].select { |file| File.exist?(file) }
-      @build_files += [ File.expand_path("buildr.rake", Gem::user_home), File.expand_path("buildr.rake") ].
-        select { |file| File.exist?(file) }.each { |file| warn "Please use '#{file.ext('rb')}' instead of '#{file}'" }
-      #Load local tasks that can be used in the Buildfile.
-      @build_files += Dir["#{Dir.pwd}/tasks/*.rake"]
-      @build_files.each do |file|
-        unless $LOADED_FEATURES.include?(file)
-          load file
-          $LOADED_FEATURES << file
-        end
-      end
-      true
-    end
-
-    # :call-seq:
-    #   build_files() => files
-    #
-    # Returns a list of build files. These are files used by the build, 
-    def build_files()
-      [Rake.application.rakefile].compact + @build_files
-    end
-
-    task "buildr:initialize" do
-      Buildr.load_tasks_and_local_files
-    end
-
-  end
-
-end

data/lib/core/common.rb

@@ -1,562 +0,0 @@
-require "tempfile"
-require "pathname"
-require "core/transports"
-require "open-uri"
-require "uri/open-sftp"
-
-
-class Hash
-
-  class << self
-
-    # :call-seq:
-    #   Hash.from_java_properties(string)
-    #
-    # Returns a hash from a string in the Java properties file format. For example:
-    #   str = "foo=bar\nbaz=fab"
-    #   Hash.from_properties(str)
-    #   => { "foo"=>"bar", "baz"=>"fab" }.to_properties
-    def from_java_properties(string)
-      string.gsub(/\\\n/, "").split("\n").select { |line| line =~ /^[^#].*=.*/ }.
-        map { |line| line.gsub(/\\[trnf\\]/) { |escaped| {?t=>"\t", ?r=>"\r", ?n=>"\n", ?f=>"\f", ?\\=>"\\"}[escaped[1]] } }.
-        map { |line| line.split("=") }.
-        inject({}) { |hash, (name, value)| hash.merge(name=>value) }
-    end
-
-  end
-
-  # :call-seq:
-  #   only(keys*) => hash
-  #
-  # Returns a new hash with only the specified keys.
-  #
-  # For example:
-  #   { :a=>1, :b=>2, :c=>3, :d=>4 }.only(:a, :c)
-  #   => { :a=>1, :c=>3 }
-  def only(*keys)
-    keys.inject({}) { |hash, key| has_key?(key) ? hash.merge(key=>self[key]) : hash }
-  end
-
-
-  # :call-seq:
-  #   except(keys*) => hash
-  #
-  # Returns a new hash without the specified keys.
-  #
-  # For example:
-  #   { :a=>1, :b=>2, :c=>3, :d=>4 }.except(:a, :c)
-  #   => { :b=>2, :d=>4 }
-  def except(*keys)
-    (self.keys - keys).inject({}) { |hash, key| hash.merge(key=>self[key]) }
-  end
-
-  # :call-seq:
-  #   to_java_properties() => string
-  #
-  # Convert hash to string format used for Java properties file. For example:
-  #   { "foo"=>"bar", "baz"=>"fab" }.to_properties
-  #   => foo=bar
-  #      baz=fab
-  def to_java_properties()
-    keys.sort.map { |key|
-      value = self[key].gsub(/[\t\r\n\f\\]/) { |escape| "\\" + {"\t"=>"t", "\r"=>"r", "\n"=>"n", "\f"=>"f", "\\"=>"\\"}[escape] }
-      "#{key}=#{value}"
-    }.join("\n")
-  end
-
-end
-
-
-module Buildr
-
-  # Collection of options for controlling Buildr. For example for running builds without running
-  # test cases, using a proxy server, JVM arguments, etc. You access this object by calling options,
-  # for example:
-  #   options.proxy.http = "http://proxy.acme.com:8080"
-  #   options.java_args = "-Xmx512M"
-  class Options
-
-    # We use this to present environment variable as arrays.
-    class EnvArray < Array #:nodoc:
-    
-      def initialize(name)
-        @name = name.upcase
-        replace((ENV[@name] || ENV[@name.downcase] || "").split(/\s*,\s*/).reject(&:empty?))
-      end
-
-      (Array.instance_methods - Object.instance_methods - Enumerable.instance_methods).sort.each do |method|
-        class_eval %{def #{method}(*args, &block) ; result = super ; write ; result ; end}
-      end
-
-    private
-
-      def write()
-        ENV[@name.downcase] = nil
-        ENV[@name] = map(&:to_s).join(",")
-      end
-
-    end
-
-    # Wraps around the proxy environment variables:
-    # * :http -- HTTP_PROXY
-    # * :exclude -- NO_PROXY
-    class Proxies
-
-      # Returns the HTTP_PROXY URL.
-      def http()
-        ENV["HTTP_PROXY"] || ENV["http_proxy"]
-      end
-
-      # Sets the HTTP_PROXY URL.
-      def http=(url)
-        ENV["http_proxy"] = nil
-        ENV["HTTP_PROXY"] = url
-      end
-   
-      # Returns list of hosts to exclude from proxying (NO_PROXY). 
-      def exclude()
-        @exclude ||= EnvArray.new("NO_PROXY")
-      end
-
-      # Sets list of hosts to exclude from proxy (NO_PROXY). Accepts host name, array of names,
-      # or nil to clear the list.
-      def exclude=(url)
-        exclude.clear
-        exclude.concat [url].flatten if url
-        exclude
-      end
-
-    end
-
-    # :call-seq:
-    #   proxy() => options
-    #
-    # Returns the proxy options. Currently supported options are:
-    # * :http -- HTTP proxy for use when downloading.
-    # * :exclude -- Do not use proxy for these hosts/domains.
-    #
-    # For example:
-    #   options.proxy.http = "http://proxy.acme.com:8080"
-    # You can also set it using the environment variable HTTP_PROXY.
-    #
-    # You can exclude individual hosts from being proxied, or entire domains, for example:
-    #   options.proxy.exclude = "optimus"
-    #   options.proxy.exclude = ["optimus", "prime"]
-    #   options.proxy.exclude << "*.internal"
-    def proxy()
-      @proxy ||= Proxies.new
-    end
-
-  end
-
-  class << self
-
-    # :call-seq:
-    #   options() => Options
-    #
-    # Returns the Buildr options. See Options.
-    def options()
-      @options ||= Options.new
-    end
-
-  end
-
-  # :call-seq:
-  #   options() => Options
-  #
-  # Returns the Buildr options. See Options.
-  def options()
-    Buildr.options
-  end
-
-  # :call-seq:
-  #   environment() => string or nil
-  #
-  # Returns the environment name.  Use this when your build depends on the environment,
-  # for example, development, production, etc.  The value comes from the BUILDR_ENV environment variable.
-  # 
-  # For example:
-  #   buildr -e production
-  def environment()
-    ENV['BUILDR_ENV']
-  end
-
-  # :call-seq:
-  #   environment(env)
-  #
-  # Sets the environment name.
-  def environment=(env)
-    ENV['BUILDR_ENV'] = env
-  end
-
-  # :call-seq:
-  #   struct(hash) => Struct
-  #
-  # Convenience method for creating an anonymous Struct.
-  #
-  # For example:
-  #   COMMONS             = struct(
-  #     :collections      =>"commons-collections:commons-collections:jar:3.1",
-  #     :lang             =>"commons-lang:commons-lang:jar:2.1",
-  #     :logging          =>"commons-logging:commons-logging:jar:1.0.3",
-  #   )
-  #
-  #   compile.with COMMONS.logging
-  def struct(hash)
-    Struct.new(nil, *hash.keys).new(*hash.values)  
-  end
-
-  # :call-seq:
-  #   write(name, content)
-  #   write(name) { ... }
-  #
-  # Write the contents into a file. The second form calls the block and writes the result.
-  #
-  # For example:
-  #   write "TIMESTAMP", Time.now
-  #   write("TIMESTAMP") { Time.now }
-  #
-  # Yields to the block before writing the file, so you can chain read and write together.
-  # For example:
-  #   write("README") { read("README").sub("${build}", Time.now) }
-  def write(name, content = nil)
-    mkpath File.dirname(name), :verbose=>false
-    content = yield if block_given?
-    File.open(name.to_s, "wb") { |file| file.write content.to_s }
-    content.to_s
-  end
-
-  # :call-seq:
-  #   read(name) => string
-  #   read(name) { |string| ... } => result
-  #
-  # Reads and returns the contents of a file. The second form yields to the block and returns
-  # the result of the block.
-  #
-  # For example:
-  #   puts read("README")
-  #   read("README") { |text| puts text }
-  def read(name)
-    contents = File.open(name.to_s) { |f| f.read }
-    if block_given?
-      yield contents
-    else
-      contents
-    end
-  end
-
-  # :call-seq:
-  #    download(url_or_uri) => task
-  #    download(path=>url_or_uri) =>task
-  #
-  # Create a task that will download a file from a URL.
-  #
-  # Takes a single argument, a hash with one pair. The key is the file being
-  # created, the value if the URL to download. The task executes only if the
-  # file does not exist; the URL is not checked for updates.
-  #
-  # The task will show download progress on the console; if there are MD5/SHA1
-  # checksums on the server it will verify the download before saving it.
-  #
-  # For example:
-  #   download "image.jpg"=>"http://example.com/theme/image.jpg"
-  def download(args)
-    args = URI.parse(args) if String === args
-    if URI === args
-      # Given only a download URL, download into a temporary file.
-      # You can infer the file from task name.
-      temp = Tempfile.open(File.basename(args.to_s))
-      file(temp.path).tap do |task|
-        # Since temporary file exists, force a download.
-        class << task ; def needed?() ; true ; end ; end
-        task.sources << args
-        task.enhance { args.download temp }
-      end
-    else
-      # Download to a file created by the task.
-      fail unless args.keys.size == 1
-      uri = URI.parse(args.values.first.to_s)
-      file_create(args.keys.first).tap do |task|
-        task.sources << uri
-        task.enhance { uri.download task.name }
-      end
-    end
-
-  end
-
-
-  # A filter knows how to copy files from one directory to another, applying mappings to the
-  # contents of these files.
-  #
-  # You can specify the mapping using a Hash, and it will map ${key} fields found in each source
-  # file into the appropriate value in the target file. For example:
-  #   filter.using "version"=>"1.2", "build"=>Time.now
-  # will replace all occurrences of <tt>${version}</tt> with <tt>1.2</tt>, and <tt>${build}</tt>
-  # with the current date/time.
-  #
-  # You can also specify the mapping by passing a proc or a method, that will be called for
-  # each source file, with the file name and content, returning the modified content.
-  #
-  # Without any mapping, the filter simply copies files from the source directory into the target
-  # directory.
-  #
-  # A filter has one target directory, but you can specify any number of source directories,
-  # either when creating the filter or calling #from. Include/exclude patterns are specified
-  # relative to the source directories, so:
-  #   filter.include "*.png"
-  # will only include PNG files from any of the source directories.
-  #
-  # See Buildr#filter.
-  class Filter
-
-    def initialize() #:nodoc:
-      @include = []
-      @exclude = []
-      @sources = []
-    end
-
-    # Returns the list of source directories (each being a file task).
-    attr_reader :sources
-
-    # *Deprecated* Use #sources instead.
-    def source()
-      warn_deprecated "Please use sources instead."
-      @sources.first
-    end
-
-    # *Deprecated* Use #from instead.
-    def source=(dir)
-      warn_deprecated "Please use from instead."
-      from(dir)
-    end
-    
-    # :call-seq:
-    #   from(*sources) => self
-    #
-    # Adds additional directories from which to copy resources.
-    #
-    # For example:
-    #   filter.from("src").into("target").using("build"=>Time.now)
-    def from(*sources)
-      @sources |= sources.flatten.map { |dir| file(File.expand_path(dir.to_s)) }
-      self
-    end
-
-    # The target directory as a file task.
-    attr_reader :target
-
-    # :call-seq:
-    #   into(dir) => self
-    #
-    # Sets the target directory into which files are copied and returns self.
-    #
-    # For example:
-    #   filter.from("src").into("target").using("build"=>Time.now)
-    def into(dir)
-      @target = file(File.expand_path(dir.to_s)) { |task| run if target == task && !sources.empty? }
-      self
-    end
-
-    # :call-seq:
-    #   include(*files) => self
-    #
-    # Specifies files to include and returns self. See FileList#include.
-    #
-    # By default all files are included. You can use this method to only include specific
-    # files form the source directory.
-    def include(*files)
-      @include += files
-      self
-    end
-    alias :add :include 
-
-    # :call-seq:
-    #   exclude(*files) => self
-    #
-    # Specifies files to exclude and returns self. See FileList#exclude.
-    def exclude(*files)
-      @exclude += files
-      self
-    end
-
-    # The mapping. See #using.
-    attr_accessor :mapping
-
-    # The mapper to use. See #using.
-    attr_accessor :mapper
-
-    # :call-seq:
-    #   using(mapping) => self
-    #   using() { |file_name, contents| ... } => self
-    #
-    # Specifies the mapping to use and returns self.
-    #
-    # The most typical mapping uses a Hash, and the default mapping uses the Maven style, so
-    # <code>${key}</code> are mapped to the values. You can change that by passing a different
-    # format as the first argument. Currently supports:
-    # * :ant -- Map <code>@key@</code>.
-    # * :maven -- Map <code>${key}</code> (default).
-    # * :ruby -- Map <code>#{key}</code>.
-    # * Regexp -- Maps the matched data (e.g. <code>/=(.*?)=/</code>
-    #
-    # For example:
-    #   filter.using "version"=>"1.2"
-    # Is the same as:
-    #   filter.using :maven, "version"=>"1.2"
-    #
-    # You can also pass a proc or method. It will be called with the file name and content,
-    # to return the mapped content.
-    #
-    # Without any mapping, all files are copied as is.
-    def using(*args, &block)
-      case args.first
-      when Hash # Maven hash mapping
-        using :maven, *args
-      when Symbol # Mapping from a method
-        raise ArgumentError, "Expected mapper type followed by mapping hash" unless args.size == 2 && Hash === args[1]
-        @mapper, @mapping = *args
-      when Regexp # Mapping using a regular expression
-        raise ArgumentError, "Expected regular expression followed by mapping hash" unless args.size == 2 && Hash === args[1]
-        @mapper, @mapping = *args
-      else
-        raise ArgumentError, "Expected proc, method or a block" if args.size > 1 || (args.first && block)
-        @mapping = args.first || block
-      end
-      self
-    end
-
-    # :call-seq:
-    #    run() => boolean
-    #
-    # Runs the filter.
-    def run()
-      raise "No source directory specified, where am I going to find the files to filter?" if sources.empty?
-      sources.each { |source| raise "Source directory #{source} doesn't exist" unless File.exist?(source.to_s) }
-      raise "No target directory specified, where am I going to copy the files to?" if target.nil?
-
-      copy_map = sources.flatten.map(&:to_s).inject({}) do |map, source|
-        base = Pathname.new(source)
-        files = FileList.recursive(source).
-          map { |file| Pathname.new(file).relative_path_from(base).to_s }.
-          select { |file| @include.empty? || @include.any? { |pattern| File.fnmatch(pattern, file) } }.
-          reject { |file| @exclude.any? { |pattern| File.fnmatch(pattern, file) } }
-        files.each do |file|
-          src, dest = File.expand_path(file, source), File.expand_path(file, target.to_s)
-          map[file] = src if !File.exist?(dest) || File.stat(src).mtime > File.stat(dest).mtime
-        end
-        map
-      end
-        
-      return false if copy_map.empty?
-
-      verbose(Rake.application.options.trace || false) do
-        mkpath target.to_s
-        copy_map.each do |path, source|
-          dest = File.expand_path(path, target.to_s)
-          if File.directory?(source)
-            mkpath dest
-          else
-            mkpath File.dirname(dest)
-            case mapping
-            when Proc, Method # Call on input, accept output.
-              mapped = mapping.call(path, File.open(source, "rb") { |file| file.read })
-              File.open(dest, "wb") { |file| file.write mapped }
-            when Hash # Map ${key} to value
-              content = File.open(source, "rb") { |file| file.read }
-              if Symbol === @mapper
-                mapped = send("#{@mapper}_mapper", content) { |key| mapping[key] }
-              else
-                mapped = regexp_mapper(content) { |key| mapping[key] }
-              end
-                #gsub(/\$\{[^}]*\}/) { |str| mapping[str[2..-2]] || str }
-              File.open(dest, "wb") { |file| file.write mapped }
-            when nil # No mapping.
-              cp source, dest
-              File.chmod(0664, dest)
-            else
-              fail "Filter can be a hash (key=>value), or a proc/method; I don't understand #{mapping}"
-            end
-          end
-        end
-        touch target.to_s 
-      end
-      true
-    end
-
-    # Returns the target directory. 
-    def to_s()
-      @target.to_s
-    end
-
-  private
-
-    def maven_mapper(content)
-      content.gsub(/\$\{.*?\}/) { |str| yield(str[2..-2]) || str }
-    end
-
-    def ant_mapper(content)
-      content.gsub(/@.*?@/) { |str| yield(str[1..-2]) || str }
-    end
-
-    def ruby_mapper(content)
-      content.gsub(/#\{.*?\}/) { |str| yield(str[2..-2]) || str }
-    end
-
-    def regexp_mapper(content)
-      content.gsub(@mapper) { |str| yield(str.scan(@mapper).join) || str }
-    end
-
-  end
-
-  # :call-seq:
-  #   filter(*source) => Filter
-  #
-  # Creates a filter that will copy files from the source directory(ies) into the target directory.
-  # You can extend the filter to modify files by mapping <tt>${key}</tt> into values in each
-  # of the copied files, and by including or excluding specific files.
-  #
-  # A filter is not a task, you must call the Filter#run method to execute it.
-  #
-  # For example, to copy all files from one directory to another:
-  #   filter("src/files").into("target/classes").run
-  # To include only the text files, and replace each instance of <tt>${build}</tt> with the current
-  # date/time:
-  #   filter("src/files").into("target/classes").include("*.txt").using("build"=>Time.now).run
-  def filter(*sources)
-    Filter.new.from(*sources)
-  end
-
-end
-
-
-# Add a touch of colors (red) to warnings.
-HighLine.use_color = PLATFORM !~ /win32/
-module Kernel #:nodoc:
-
-  def warn_with_color(message)
-    warn_without_color $terminal.color(message.to_s, :red)
-  end
-  alias_method_chain :warn, :color
-
-  # :call-seq:
-  #   warn_deprecated(message)
-  #
-  # Use with deprecated methods and classes. This method automatically adds the file name and line number,
-  # and the text "Deprecated" before the message, and eliminated duplicate warnings. It only warns when
-  # running in verbose mode.
-  #
-  # For example:
-  #   warn_deprecated "Please use new_foo instead of foo."
-  def warn_deprecated(message) #:nodoc:
-    return unless verbose
-    "#{caller[1]}: Deprecated: #{message}".tap do |message|
-      @deprecated ||= {}
-      unless @deprecated[message]
-        @deprecated[message] = true
-        warn message
-      end
-    end
-  end
-
-end
-