ittayd-buildr 1.3.4 → 1.3.5

data/lib/buildr/core/util.rb

@@ -1,294 +0,0 @@
-# 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 'rbconfig'
-require 'pathname'
-autoload :Tempfile, 'tempfile'
-autoload :YAML, 'yaml'
-autoload :REXML, 'rexml/document'
-gem 'xml-simple' ; autoload :XmlSimple, 'xmlsimple'
-gem 'builder' ; autoload :Builder, 'builder' # A different kind of buildr, one we use to create XML.
-require 'highline/import'
-
-
-module Buildr
-  
-  module Util
-    extend self
-
-    def java_platform?
-      RUBY_PLATFORM =~ /java/
-    end
-
-    # In order to determine if we are running on a windows OS,
-    # prefer this function instead of using Gem.win_platform?.
-    #
-    # Gem.win_platform? only checks these RUBY_PLATFORM global,
-    # that in some cases like when running on JRuby is not 
-    # succifient for our purpose:
-    #
-    # For JRuby, the value for RUBY_PLATFORM will always be 'java'
-    # That's why this function checks on Config::CONFIG['host_os']
-    def win_os?
-      Config::CONFIG['host_os'] =~ /windows|cygwin|bccwin|cygwin|djgpp|mingw|mswin|wince/i
-    end
-
-    # Runs Ruby with these command line arguments.  The last argument may be a hash,
-    # supporting the following keys:
-    #   :command  -- Runs the specified script (e.g., :command=>'gem')
-    #   :sudo     -- Run as sudo on operating systems that require it.
-    #   :verbose  -- Override Rake's verbose flag.
-    def ruby(*args)
-      options = Hash === args.last ? args.pop : {}
-      cmd = []
-      ruby_bin = File.expand_path(Config::CONFIG['ruby_install_name'], Config::CONFIG['bindir'])
-      if options.delete(:sudo) && !(win_os? || Process.uid == File.stat(ruby_bin).uid)
-        cmd << 'sudo' << '-u' << "##{File.stat(ruby_bin).uid}"
-      end
-      cmd << ruby_bin
-      cmd << '-S' << options.delete(:command) if options[:command]
-      sh *cmd.push(*args.flatten).push(options) do |ok, status|
-        ok or fail "Command failed with status (#{status ? status.exitstatus : 'unknown'}): [#{cmd.join(" ")}]"
-      end
-    end
-
-    # Just like File.expand_path, but for windows systems it
-    # capitalizes the drive name and ensures backslashes are used
-    def normalize_path(path, *dirs)
-      path = File.expand_path(path, *dirs)
-      if win_os?
-        path.gsub!('/', '\\').gsub!(/^[a-zA-Z]+:/) { |s| s.upcase }
-      else
-        path
-      end
-    end
-    
-    # Return the timestamp of file, without having to create a file task
-    def timestamp(file)
-      if File.exist?(file)
-        File.mtime(file)
-      else
-        Rake::EARLY
-      end
-    end
-
-    # Return the path to the first argument, starting from the path provided by the
-    # second argument.
-    #
-    # For example:
-    #   relative_path('foo/bar', 'foo')
-    #   => 'bar'
-    #   relative_path('foo/bar', 'baz')
-    #   => '../foo/bar'
-    #   relative_path('foo/bar')
-    #   => 'foo/bar'
-    #   relative_path('/foo/bar', 'baz')
-    #   => '/foo/bar'
-    def relative_path(to, from = '.')
-      to = Pathname.new(to).cleanpath
-      return to.to_s if from.nil?
-      to_path = Pathname.new(File.expand_path(to.to_s, "/"))
-      from_path = Pathname.new(File.expand_path(from.to_s, "/"))
-      to_path.relative_path_from(from_path).to_s
-    end
-
-    # Generally speaking, it's not a good idea to operate on dot files (files starting with dot).
-    # These are considered invisible files (.svn, .hg, .irbrc, etc).  Dir.glob/FileList ignore them
-    # on purpose.  There are few cases where we do have to work with them (filter, zip), a better
-    # solution is welcome, maybe being more explicit with include.  For now, this will do.
-    def recursive_with_dot_files(*dirs)
-      FileList[dirs.map { |dir| File.join(dir, '/**/{*,.*}') }].reject { |file| File.basename(file) =~ /^[.]{1,2}$/ }
-    end
-
-    # Utility methods for running gem commands
-    module Gems
-      extend self
-
-      # Install gems specified by each Gem::Dependency if they are missing. This method prompts the user
-      # for permission before installing anything.
-      # 
-      # Returns the installed Gem::Dependency objects or fails if permission not granted or when buildr
-      # is not running interactively (on a tty)
-      def install(*dependencies)
-        raise ArgumentError, "Expected at least one argument" if dependencies.empty?
-        remote = dependencies.map { |dep| Gem::SourceInfoCache.search(dep).last || dep }
-        not_found_deps, to_install = remote.partition { |gem| gem.is_a?(Gem::Dependency) }
-        fail Gem::LoadError, "Build requires the gems #{not_found_deps.join(', ')}, which cannot be found in local or remote repository." unless not_found_deps.empty?
-        uses = "This build requires the gems #{to_install.map(&:full_name).join(', ')}:"
-        fail Gem::LoadError, "#{uses} to install, run Buildr interactively." unless $stdout.isatty
-        unless agree("#{uses} do you want me to install them? [Y/n]", true)
-          fail Gem::LoadError, 'Cannot build without these gems.'
-        end
-        to_install.each do |spec|
-          say "Installing #{spec.full_name} ... " if verbose
-          command 'install', spec.name, '-v', spec.version.to_s, :verbose => false
-          Gem.source_index.load_gems_in Gem::SourceIndex.installed_spec_directories
-        end
-        to_install
-      end
-
-      # Execute a GemRunner command
-      def command(cmd, *args)
-        options = Hash === args.last ? args.pop : {}
-        gem_home = ENV['GEM_HOME'] || Gem.path.find { |f| File.writable?(f) }
-        options[:sudo] = :root unless Util.win_os? || gem_home
-        options[:command] = 'gem'
-        args << options
-        args.unshift '-i', gem_home if cmd == 'install' && gem_home && !args.any?{ |a| a[/-i|--install-dir/] }
-        Util.ruby cmd, *args
-      end
-
-    end # Gems
-
-  end # Util
-end
-
-
-if RUBY_VERSION < '1.9.0'
-  module Kernel #:nodoc:
-    # Borrowed from Ruby 1.9.
-    def tap
-      yield self if block_given?
-      self
-    end unless method_defined?('tap')
-  end
-
-
-  class Symbol #:nodoc:
-    # Borrowed from Ruby 1.9.
-    def to_proc
-      Proc.new{|*args| args.shift.__send__(self, *args)}
-    end unless method_defined?('to_proc')
-  end
-
-  # Also borrowed from Ruby 1.9.
-  class BasicObject #:nodoc:
-    (instance_methods - ['__send__', '__id__', '==', 'send', 'send!', 'respond_to?', 'equal?', 'object_id']).
-      each do |method|
-        undef_method method
-      end
-
-    def self.ancestors
-      [Kernel]
-    end
-  end
-end
-
-
-class OpenObject < Hash
-
-  def initialize(source=nil, &block)
-    @hash = Hash.new(&block)
-    @hash.update(source) if source
-  end
-
-  def [](key)
-    @hash[key]
-  end
-
-  def []=(key, value)
-    @hash[key] = value
-  end
-
-  def delete(key)
-    @hash.delete(key)
-  end
-
-  def to_hash
-    @hash.clone
-  end
-
-  def method_missing(symbol, *args)
-    if symbol.to_s =~ /=$/
-      self[symbol.to_s[0..-2].to_sym] = args.first
-    else
-      self[symbol]
-    end
-  end
-end
-
-
-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)
-      hash = {}
-      input_stream = Java.java.io.StringBufferInputStream.new(string)
-      java_properties = Java.java.util.Properties.new
-      java_properties.load input_stream
-      keys = java_properties.keySet.iterator
-      while keys.hasNext
-        # Calling key.next in JRuby returns a java.lang.String, behaving as a Ruby string and life is good.
-        # MRI, unfortunately, treats next() like the interface says returning an object that's not a String,
-        # and the Hash doesn't work the way we need it to.  Unfortunately, we can call toString on MRI's object,
-        # but not on the JRuby one; calling to_s on the JRuby object returns what we need, but ... you guessed it.
-        #  So this seems like the one hack to unite them both.
-        key = Java.java.lang.String.valueOf(keys.next)
-        hash[key] = java_properties.getProperty(key)
-      end
-      hash
-    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

data/lib/buildr/groovy.rb

@@ -1,18 +0,0 @@
-# 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/groovy/compiler'
-require 'buildr/groovy/bdd'

data/lib/buildr/groovy/bdd.rb

@@ -1,106 +0,0 @@
-# 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::Groovy
-
-  # EasyB is a Groovy based BDD framework.
-  # To use in your project:
-  #
-  #   test.using :easyb
-  # 
-  # This framework will search in your project for:
-  #   src/spec/groovy/**/*Story.groovy
-  #   src/spec/groovy/**/*Behavior.groovy
-  #
-  # Support the following options:
-  # * :format -- Report format :txt or :xml, default is :txt
-  # * :properties -- Hash of properties passed to the test suite.
-  # * :java_args -- Arguments passed to the JVM.
-  class EasyB < TestFramework::JavaBDD
-    @lang = :groovy
-    @bdd_dir = :spec
-
-    VERSION = "0.7"
-    TESTS_PATTERN = [ /(Story|Behavior).groovy$/ ]
-    OPTIONS = [:format, :properties, :java_args]
-
-    class << self
-      def version
-        Buildr.settings.build['jbehave'] || VERSION
-      end
-
-      def dependencies
-        @dependencies ||= ["org.easyb:easyb:jar:#{version}",
-          'org.codehaus.groovy:groovy:jar:1.5.3','asm:asm:jar:2.2.3',
-          'commons-cli:commons-cli:jar:1.0','antlr:antlr:jar:2.7.7']
-      end
-
-      def applies_to?(project) #:nodoc:
-        %w{
-          **/*Behaviour.groovy **/*Behavior.groovy **/*Story.groovy
-        }.any? { |glob| !Dir[project.path_to(:source, bdd_dir, lang, glob)].empty? }
-      end
-
-    private
-      def const_missing(const)
-        return super unless const == :REQUIRES # TODO: remove in 1.5
-        Buildr.application.deprecated "Please use JBehave.dependencies/.version instead of JBehave::REQUIRES/VERSION"
-        dependencies
-      end
-    end
-
-    def tests(dependencies) #:nodoc:
-      Dir[task.project.path_to(:source, bdd_dir, lang, "**/*.groovy")].
-        select { |name| TESTS_PATTERN.any? { |pat| pat === name } }
-    end
-
-    def run(tests, dependencies) #:nodoc:
-      options = { :format => :txt }.merge(self.options).only(*OPTIONS)
-    
-      if :txt == options[:format]
-        easyb_format, ext = 'txtstory', '.txt'
-      elsif :xml == options[:format]
-        easyb_format, ext = 'xmlbehavior', '.xml'
-      else
-        raise "Invalid format #{options[:format]} expected one of :txt :xml"
-      end
-    
-      cmd_args = [ 'org.disco.easyb.SpecificationRunner' ]
-      cmd_options = { :properties => options[:properties],
-                      :java_args => options[:java_args],
-                      :classpath => dependencies }
-
-      tests.inject([]) do |passed, test|
-        name = test.sub(/.*?groovy[\/\\]/, '').pathmap('%X')
-        report = File.join(task.report_to.to_s, name + ext)
-        mkpath report.pathmap('%d'), :verbose => false
-        begin
-          Java::Commands.java cmd_args,
-             "-#{easyb_format}", report,
-             test, cmd_options.merge(:name => name)
-        rescue => e
-          passed
-        else
-          passed << test
-        end
-      end
-    end
-  
-  end # EasyB
-  
-end
-
-Buildr::TestFramework << Buildr::Groovy::EasyB

data/lib/buildr/groovy/compiler.rb

@@ -1,138 +0,0 @@
-# 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::Groovy
-
-  # Groovyc compiler:
-  #  compile.using(:groovyc)
-  #
-  # You need to require 'buildr/groovy/compiler' if you need to use this compiler.
-  #
-  # Used by default if .groovy files are found in the src/main/groovy directory (or src/test/groovy)
-  # and sets the target directory to target/classes (or target/test/classes).
-  #
-  # Groovyc is a joint compiler, this means that when selected for a project, this compiler is used
-  # to compile both groovy and java sources. It's recommended that Groovy sources are placed in the
-  # src/main/groovy directory, even though this compiler also looks in src/main/java
-  #
-  # Groovyc accepts the following options:
-  #
-  # * :encoding          -- Encoding of source files
-  # * :verbose           -- Asks the compiler for verbose output, true when running in verbose mode.
-  # * :fork              -- Whether to execute groovyc using a spawned instance of the JVM; defaults to no
-  # * :memoryInitialSize -- The initial size of the memory for the underlying VM, if using fork mode; ignored otherwise. 
-  #                                     Defaults to the standard VM memory setting. (Examples: 83886080, 81920k, or 80m)
-  # * :memoryMaximumSize -- The maximum size of the memory for the underlying VM, if using fork mode; ignored otherwise. 
-  #                                     Defaults to the standard VM memory setting. (Examples: 83886080, 81920k, or 80m)
-  # * :listfiles         -- Indicates whether the source files to be compiled will be listed; defaults to no
-  # * :stacktrace        -- If true each compile error message will contain a stacktrace
-  # * :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.
-  # * :optimise          -- Generates faster bytecode by applying optimisations to the program.
-  # * :source            -- Source code compatibility.
-  # * :target            -- Bytecode compatibility.
-  # * :javac             -- Hash of options passed to the ant javac task
-  #
-  class Groovyc < Compiler::Base
-    
-    # The groovyc compiler jars are added to classpath at load time,
-    # if you want to customize artifact versions, you must set them on the
-    #
-    #      artifact_ns['Buildr::Compiler::Groovyc'].groovy = '1.5.4'
-    #
-    # namespace before this file is required.
-    REQUIRES = ArtifactNamespace.for(self) do |ns|
-      ns.groovy!       'org.codehaus.groovy:groovy:jar:>=1.5.3'
-      ns.commons_cli!  'commons-cli:commons-cli:jar:>=1.0'
-      ns.asm!          'asm:asm:jar:>=2.2'
-      ns.antlr!        'antlr:antlr:jar:>=2.7.7'
-    end
-    
-    ANT_TASK = 'org.codehaus.groovy.ant.Groovyc'
-    GROOVYC_OPTIONS = [:encoding, :verbose, :fork, :memoryInitialSize, :memoryMaximumSize, :listfiles, :stacktrace]
-    JAVAC_OPTIONS = [:optimise, :warnings, :debug, :deprecation, :source, :target, :javac]
-    OPTIONS = GROOVYC_OPTIONS + JAVAC_OPTIONS
-
-    class << self
-      def dependencies #:nodoc:
-        REQUIRES.artifacts
-      end
-
-      def applies_to?(project, task) #:nodoc:
-        paths = task.sources + [sources].flatten.map { |src| Array(project.path_to(:source, task.usage, src.to_sym)) }
-        paths.flatten!
-        # Just select if we find .groovy files
-        paths.any? { |path| !Dir["#{path}/**/*.groovy"].empty? }
-      end
-    end
-    
-    Java.classpath << dependencies
-    
-    specify :language => :groovy, :sources => [:groovy, :java], :source_ext => [:groovy, :java], 
-            :target => 'classes', :target_ext => 'class', :packaging => :jar
-
-    def initialize(project, options) #:nodoc:
-      super
-      options[:debug] = Buildr.options.debug if options[:debug].nil?
-      options[:deprecation] ||= false
-      options[:optimise] ||= false
-      options[:verbose] ||= Buildr.application.options.trace if options[:verbose].nil?
-      options[:warnings] = verbose if options[:warnings].nil?
-      options[:javac] = OpenObject.new if options[:javac].nil?
-    end
-
-    # http://groovy.codehaus.org/The+groovyc+Ant+Task
-    def compile(sources, target, dependencies) #:nodoc:
-      return if Buildr.application.options.dryrun
-      Buildr.ant 'groovyc' do |ant|
-        classpath = dependencies | self.class.dependencies.map(&:to_s)
-        ant.taskdef :name => 'groovyc', :classname => ANT_TASK, :classpath => classpath.join(File::PATH_SEPARATOR)
-        ant.groovyc groovyc_options(sources, target) do
-          sources.each { |src| ant.src :path => src }
-          ant.classpath do
-            classpath.each { |dep| ant.pathelement :path => dep }
-          end
-          ant.javac(javac_options)
-        end
-      end
-    end
-
-   private 
-    def groovyc_options(sources, target)
-      check_options options, OPTIONS
-      groovyc_options = options.to_hash.only(*GROOVYC_OPTIONS)
-      groovyc_options[:destdir] = File.expand_path(target)
-      groovyc_options
-    end
-
-    def javac_options
-      check_options options, OPTIONS
-      javac_options = options.to_hash.only(*JAVAC_OPTIONS)
-      javac_options[:optimize] = (javac_options.delete(:optimise) || false)
-      javac_options[:nowarn] = (javac_options.delete(:warnings) || verbose).to_s !~ /^(true|yes|on)$/i
-      other = javac_options.delete(:javac) || {}
-      javac_options.merge!(other)
-      javac_options
-    end
-    
-  end
-end
-
-# Groovy compiler comes first, ahead of Javac, this allows it to pick
-# projects that mix Groovy and Java code by spotting Groovy code first.
-Buildr::Compiler.compilers.unshift Buildr::Groovy::Groovyc