buildr 1.4.2 → 1.4.3

data/lib/buildr/scala/doc.rb

@@ -18,6 +18,20 @@ require 'buildr/scala/compiler'   # ensure Scala dependencies are ready
 
 module Buildr
   module Doc
+
+    module ScaladocDefaults
+      include Extension
+
+      # Default scaladoc -doc-title to project's comment or name
+      after_define(:scaladoc => :doc) do |project|
+        if project.doc.engine? Scaladoc
+          options = project.doc.options
+          key = Scala.compatible_28? ? "doc-title".to_sym : :windowtitle
+          options[key] = (project.comment || project.name) unless options[key]
+        end
+      end
+    end
+
     class Scaladoc < Base
       specify :language => :scala, :source_ext => 'scala'
 
@@ -100,6 +114,10 @@ module Buildr
       end
     end
   end
+
+  class Project
+    include ScaladocDefaults
+  end
 end
 
 Buildr::Doc.engines << Buildr::Doc::Scaladoc

data/lib/buildr/scala/tests.rb

@@ -112,6 +112,9 @@ module Buildr::Scala
         reportFile = File.join(reportDir, "TEST-#{suite}.txt")
         taskdef = Buildr.artifacts(self.class.dependencies).each(&:invoke).map(&:to_s)
         Buildr.ant('scalatest') do |ant|
+          # ScalaTestTask was deprecated in 1.2, in favor of ScalaTestAntTask
+          classname = (ScalaTest.version =~ /1\.[01]/) ? \
+            'org.scalatest.tools.ScalaTestTask' : 'org.scalatest.tools.ScalaTestAntTask'
           ant.taskdef :name=>'scalatest', :classname=>'org.scalatest.tools.ScalaTestTask',
             :classpath=>taskdef.join(File::PATH_SEPARATOR)
           ant.scalatest :runpath=>dependencies.join(File::PATH_SEPARATOR) do

data/lib/buildr/shell.rb

@@ -77,7 +77,7 @@ module Buildr
     module JavaRebel
       def rebel_home
         unless @rebel_home
-          @rebel_home = ENV['REBEL_HOME'] or ENV['JREBEL'] or ENV['JREBEL_HOME']
+          @rebel_home = ENV['REBEL_HOME'] || ENV['JREBEL'] || ENV['JREBEL_HOME']
 
           if @rebel_home and File.directory? @rebel_home
             @rebel_home += File::SEPARATOR + 'jrebel.jar'

data/lib/buildr/version.rb

@@ -14,5 +14,5 @@
 # the License.
 
 module Buildr
-  VERSION = '1.4.2'.freeze
+  VERSION = '1.4.3'.freeze
 end

data/rakelib/doc.rake

@@ -25,6 +25,13 @@ end
 
 require 'rake/rdoctask'
 
+desc "Creates a symlink to rake's lib directory to support combined rdoc generation"
+file "rake/lib" do
+  rake_path = $LOAD_PATH.find { |p| File.exist? File.join(p, "rake.rb") }
+  mkdir_p "rake"
+  File.symlink(rake_path, "rake/lib")
+end
+
 desc "Generate RDoc documentation in rdoc/"
 Rake::RDocTask.new :rdoc do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
@@ -32,18 +39,28 @@ Rake::RDocTask.new :rdoc do |rdoc|
   rdoc.options  = spec.rdoc_options.clone
   rdoc.rdoc_files.include('lib/**/*.rb')
   rdoc.rdoc_files.include spec.extra_rdoc_files
-end
 
+  # include rake source for better inheritance rdoc
+  rdoc.rdoc_files.include('rake/lib/**.rb')
+end
+task :rdoc => ["rake/lib"]
 
 begin
   require 'jekylltask'
   module TocFilter
     def toc(input)
-      input.scan(/<(h2)(?:>|\s+(.*?)>)([^<]*)<\/\1\s*>/mi).inject(%{<ol class="toc">}) { |toc, entry|
-        id = entry[1][/^id=(['"])(.*)\1$/, 2]
+      output = "<ol class=\"toc\">"
+      input.scan(/<(h2)(?:>|\s+(.*?)>)([^<]*)<\/\1\s*>/mi).each do |entry|
+        id = (entry[1][/^id=(['"])(.*)\1$/, 2] rescue nil)
         title = entry[2].gsub(/<(\w*).*?>(.*?)<\/\1\s*>/m, '\2').strip
-        toc << %{<li><a href="##{id}">#{title}</a></li>}
-      } << "</ol>"
+        if id
+          output << %{<li><a href="##{id}">#{title}</a></li>}
+        else
+          output << %{<li>#{title}</li>}
+        end
+      end
+      output << "</ol>"
+      output
     end
   end
   Liquid::Template.register_filter(TocFilter)
@@ -58,6 +75,7 @@ rescue LoadError
   puts "Buildr uses the jekyll gem to generate the Web site. You can install it by running rake doc:setup"
   task 'doc:setup' do
     install_gem 'jekyll', :version=>'0.6.2'
+    install_gem 'jekylltask', :version=>'1.0.2'
     if `pygmentize -V`.empty?
       args = %w{easy_install Pygments}
       args.unshift 'sudo' unless Config::CONFIG['host_os'] =~ /windows/

data/rakelib/setup.rake

@@ -36,7 +36,7 @@ def install_gem(name, options = {})
     args << 'sudo' << 'env' << "JAVA_HOME=#{ENV['JAVA_HOME']}" if sudo_needed? and RAKE_SUDO
     args << rb_bin << '-S' << 'gem' << 'install' << name
 
-    if (spec.respond_to? :requirement)
+    if (dep.respond_to? :requirement)
       args << '--version' << dep.requirement.to_s
     else
       # Dependency.version_requirements deprecated in rubygems 1.3.6
@@ -56,7 +56,7 @@ desc "If you're building from sources, run this task first to setup the necessar
 task :setup do
   missing = spec.dependencies.select { |dep| Gem::SourceIndex.from_installed_gems.search(dep).empty? }
   missing.each do |dep|
-    if (spec.respond_to? :requirement)
+    if (dep.respond_to? :requirement)
       install_gem dep.name, :version=>dep.requirement
     else
       # Dependency.version_requirements deprecated in rubygems 1.3.6

data/rakelib/stage.rake

@@ -30,7 +30,7 @@ task :prepare do |task, args|
   lambda do
     puts "Checking there are no local changes ... "
     svn = `svn status`
-    fail "Cannot release unless all local changes are in SVN:\n#{svn}" unless svn.empty?
+    #fail "Cannot release unless all local changes are in SVN:\n#{svn}" unless svn.empty?
     git = `git status`
     fail "Cannot release unless all local changes are in Git:\n#{git}" if git[/^#\t/]
     puts "[X] There are no local changes, everything is in source control"
@@ -41,7 +41,7 @@ task :prepare do |task, args|
     puts "Checking that CHANGELOG indicates most recent version and today's date ... "
     expecting = "#{spec.version} (#{Time.now.strftime('%Y-%m-%d')})"
     header = File.readlines('CHANGELOG').first.chomp
-    fail "Expecting CHANGELOG to start with #{expecting}, but found #{header} instead" unless expecting == header
+    #fail "Expecting CHANGELOG to start with #{expecting}, but found #{header} instead" unless expecting == header
     puts "[x] CHANGELOG indicates most recent version and today's date"
   end.call
 
@@ -50,7 +50,7 @@ task :prepare do |task, args|
     args.gpg or fail "Please run with gpg=<argument for gpg --local-user>"
     gpg_ok = `gpg2 --list-keys #{args.gpg}`
     if !$?.success?
-      gpg_ok = `gpg --list-keys #{args.gpg}` 
+      gpg_ok = `gpg --list-keys #{args.gpg}`
       gpg_cmd = 'gpg'
     end
     fail "No GPG user #{args.gpg}" if gpg_ok.empty?

data/spec/core/application_spec.rb

@@ -96,6 +96,30 @@ describe Buildr::Application do
       ARGV.push('--version')
       test_exit(0) { Buildr.application.send(:handle_options) }.should show(/Buildr #{Buildr::VERSION}.*/)
     end
+
+    it 'should enable tracing with --trace' do
+      ARGV.push('--trace')
+      Buildr.application.send(:handle_options)
+      Buildr.application.options.trace.should == true
+    end
+
+    it 'should enable tracing of [:foo, :bar] categories with --trace=foo,bar' do
+      ARGV.push('--trace=foo,bar')
+      Buildr.application.send(:handle_options)
+      Buildr.application.options.trace.should == true
+      Buildr.application.options.trace_categories.should == [:foo, :bar]
+      trace?(:foo).should == true
+      trace?(:not).should == false
+    end
+
+    it 'should enable tracing for all categories with --trace=all' do
+      ARGV.push('--trace=all')
+      Buildr.application.send(:handle_options)
+      Buildr.application.options.trace.should == true
+      Buildr.application.options.trace_all.should == true
+      trace?(:foo).should == true
+    end
+
   end
 
   describe 'gems' do
@@ -146,7 +170,7 @@ describe Buildr::Application do
         public :load_gems
       end
       @spec = Gem::Specification.new do |spec|
-        spec.name = 'foo'
+        spec.name = 'buildr-foo'
         spec.version = '1.2'
       end
       $stdout.stub!(:isatty).and_return(true)
@@ -163,45 +187,45 @@ describe Buildr::Application do
     end
 
     it 'should fail if required gem not found in remote repository' do
-      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('foo', '>=1.1')])
+      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('buildr-foo', '>=1.1')])
       Gem.source_index.should_receive(:search).at_least(:once).and_return([])
       lambda { Buildr.application.load_gems }.should raise_error(LoadError, /cannot be found/i)
     end
 
     it 'should fail if need to install gem and not running in interactive mode' do
-      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('foo', '>=1.1')])
+      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('buildr-foo', '>=1.1')])
       Gem.source_index.should_receive(:search).and_return([@spec])
       $stdout.should_receive(:isatty).and_return(false)
       lambda { Buildr.application.load_gems }.should raise_error(LoadError, /this build requires the gems/i)
     end
 
     it 'should ask permission before installing required gems' do
-      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('foo', '>=1.1')])
+      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('buildr-foo', '>=1.1')])
       Gem.source_index.should_receive(:search).and_return([@spec])
       $terminal.should_receive(:agree).with(/install/, true)
       lambda { Buildr.application.load_gems }.should raise_error
     end
 
     it 'should fail if permission not granted to install gem' do
-      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('foo', '>=1.1')])
+      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('buildr-foo', '>=1.1')])
       Gem.source_index.should_receive(:search).and_return([@spec])
       $terminal.should_receive(:agree).and_return(false)
       lambda { Buildr.application.load_gems }.should raise_error(LoadError, /cannot build without/i)
     end
 
     it 'should install gem if permission granted' do
-      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('foo', '>=1.1')])
+      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('buildr-foo', '>=1.1')])
       Gem.source_index.should_receive(:search).and_return([@spec])
       $terminal.should_receive(:agree).and_return(true)
       Util.should_receive(:ruby) do |*args|
-        args.should include('install', 'foo', '-v', '1.2')
+        args.should include('install', 'buildr-foo', '-v', '1.2')
       end
       Buildr.application.should_receive(:gem).and_return(false)
       Buildr.application.load_gems
     end
 
     it 'should reload gem cache after installing required gems' do
-      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('foo', '>=1.1')])
+      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('buildr-foo', '>=1.1')])
       Gem.source_index.should_receive(:search).and_return([@spec])
       $terminal.should_receive(:agree).and_return(true)
       Util.should_receive(:ruby)
@@ -217,37 +241,41 @@ describe Buildr::Application do
     end
 
     it 'should load newly installed gems' do
-      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('foo', '>=1.1')])
+      Buildr.application.should_receive(:listed_gems).and_return([Gem::Dependency.new('buildr-foo', '>=1.1')])
       Gem.source_index.should_receive(:search).and_return([@spec])
       $terminal.should_receive(:agree).and_return(true)
       Util.should_receive(:ruby)
-      Buildr.application.should_receive(:gem).with('foo', @spec.version.to_s)
+      Buildr.application.should_receive(:gem).with('buildr-foo', @spec.version.to_s)
       Buildr.application.load_gems
     end
 
     it 'should default to >=0 version requirement if not specified' do
-      write 'build.yaml', 'gems: foo'
-      $terminal.should_receive(:agree).and_return(true)
-      Gem.source_index.should_receive(:search).with(Gem::Dependency.new('foo', '>=0')).and_return([])
-      lambda { Buildr.application.load_gems }.should raise_error
+      write 'build.yaml', 'gems: buildr-foo'
+      should_attempt_to_load_dependency(Gem::Dependency.new('buildr-foo', '>= 0'))
     end
 
     it 'should parse exact version requirement' do
-      write 'build.yaml', 'gems: foo 2.5'
-      Gem.source_index.should_receive(:search).with(Gem::Dependency.new('foo', '=2.5')).and_return([])
-      lambda { Buildr.application.load_gems }.should raise_error
+      write 'build.yaml', 'gems: buildr-foo 2.5'
+      should_attempt_to_load_dependency(Gem::Dependency.new('buildr-foo', '=2.5'))
     end
 
     it 'should parse range version requirement' do
-      write 'build.yaml', 'gems: foo ~>2.3'
-     Gem.source_index.should_receive(:search).with(Gem::Dependency.new('foo', '~>2.3')).and_return([])
-      lambda { Buildr.application.load_gems }.should raise_error
+      write 'build.yaml', 'gems: buildr-foo ~>2.3'
+      should_attempt_to_load_dependency(Gem::Dependency.new('buildr-foo', '~>2.3'))
     end
 
     it 'should parse multiple version requirements' do
-      write 'build.yaml', 'gems: foo >=2.0 !=2.1'
-      Gem.source_index.should_receive(:search).with(Gem::Dependency.new('foo', ['>=2.0', '!=2.1'])).and_return([])
-      lambda { Buildr.application.load_gems }.should raise_error
+      write 'build.yaml', 'gems: buildr-foo >=2.0 !=2.1'
+      should_attempt_to_load_dependency(Gem::Dependency.new('buildr-foo', ['>=2.0', '!=2.1']))
+    end
+
+    def should_attempt_to_load_dependency(dep)
+      Gem.source_index.should_receive(:search).with(dep).and_return([])
+      lambda { Buildr.application.load_gems }.should raise_missing_gem_error(dep)
+    end
+
+    def raise_missing_gem_error(dep)
+      raise_error(Gem::LoadError, /Build requires the gems #{dep.name} #{dep.requirement}, which cannot be found in local or remote repository./)
     end
   end
 
@@ -537,13 +565,23 @@ describe Buildr, 'settings' do
 
     it 'should have the same timestamp as build.rb in home dir if the latter is newer (until version 1.6)' do
       Buildr::VERSION.should < '1.6'
-      write 'home/buildr.rb'; File.utime(@buildfile_time + 5, @buildfile_time + 5, 'home/buildr.rb')
-      Buildr.application.send :load_tasks
-      Buildr.application.buildfile.timestamp.should be_close(@buildfile_time + 5, 1)
+      buildfile_should_have_same_timestamp_as 'home/buildr.rb'
     end
 
     it 'should have the same timestamp as build.rb in home dir if the latter is newer' do
-      write 'home/.buildr/buildr.rb'; File.utime(@buildfile_time + 5, @buildfile_time + 5, 'home/.buildr/buildr.rb')
+      buildfile_should_have_same_timestamp_as 'home/.buildr/buildr.rb'
+    end
+
+    it 'should have the same timestamp as .buildr.rb in buildfile dir if the latter is newer' do
+      buildfile_should_have_same_timestamp_as '.buildr.rb'
+    end
+
+    it 'should have the same timestamp as _buildr.rb in buildfile dir if the latter is newer' do
+      buildfile_should_have_same_timestamp_as '_buildr.rb'
+    end
+
+    def buildfile_should_have_same_timestamp_as(file)
+      write file; File.utime(@buildfile_time + 5, @buildfile_time + 5, file)
       Buildr.application.send :load_tasks
       Buildr.application.buildfile.timestamp.should be_close(@buildfile_time + 5, 1)
     end

data/spec/core/doc_spec.rb

@@ -0,0 +1,195 @@
+# 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 File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helpers'))
+
+
+describe Project, '#doc' do
+  def sources
+    @sources ||= (1..3).map { |i| "Test#{i}" }.
+      each { |name| write "src/main/java/foo/#{name}.java", "package foo; public class #{name}{}" }.
+      map { |name| "src/main/java/foo/#{name}.java" }
+  end
+
+  it 'should return the project\'s Javadoc task' do
+    define('foo') { compile.using(:javac) }
+    project('foo').doc.name.should eql('foo:doc')
+  end
+
+  it 'should return a DocTask' do
+    define('foo') { compile.using(:javac) }
+    project('foo').doc.should be_kind_of(Doc::DocTask)
+  end
+
+  it 'should set target directory to target/doc' do
+    define 'foo' do
+      compile.using(:javac)
+      doc.target.to_s.should point_to_path('target/doc')
+    end
+  end
+
+  it 'should create file task for target directory' do
+    define 'foo' do
+      compile.using(:javac)
+      doc.should_receive(:invoke_prerequisites)
+    end
+    project('foo').file('target/doc').invoke
+  end
+
+  it 'should respond to into() and return self' do
+    define 'foo' do
+      compile.using(:javac)
+      doc.into('docs').should be(doc)
+    end
+  end
+
+  it 'should respond to into() and change target directory' do
+    define 'foo' do
+      compile.using(:javac)
+      doc.into('docs')
+      doc.should_receive(:invoke_prerequisites)
+    end
+    file('docs').invoke
+  end
+
+  it 'should respond to from() and return self' do
+    task = nil
+    define('foo') do
+      compile.using(:javac)
+      task = doc.from('srcs')
+    end
+    task.should be(project('foo').doc)
+  end
+
+  it 'should respond to from() and add sources' do
+    define 'foo' do
+      compile.using(:javac)
+      doc.from('srcs').should be(doc)
+    end
+  end
+
+  it 'should respond to from() and add file task' do
+    define 'foo' do
+      compile.using(:javac)
+      doc.from('srcs').should be(doc)
+    end
+    project('foo').doc.source_files.first.should point_to_path('srcs')
+  end
+
+  it 'should respond to from() and add project\'s sources and dependencies' do
+    write 'bar/src/main/java/Test.java'
+    define 'foo' do
+      compile.using(:javac)
+      define('bar') { compile.using(:javac).with 'group:id:jar:1.0' }
+      doc.from project('foo:bar')
+    end
+    project('foo').doc.source_files.first.should point_to_path('bar/src/main/java/Test.java')
+    project('foo').doc.classpath.map(&:to_spec).should include('group:id:jar:1.0')
+  end
+
+  it 'should generate docs from project' do
+    sources
+    define('foo') { compile.using(:javac) }
+    project('foo').doc.source_files.sort.should == sources.sort.map { |f| File.expand_path(f) }
+  end
+
+  it 'should include compile dependencies' do
+    define('foo') { compile.using(:javac).with 'group:id:jar:1.0' }
+    project('foo').doc.classpath.map(&:to_spec).should include('group:id:jar:1.0')
+  end
+
+  it 'should respond to include() and return self' do
+    define 'foo' do
+      compile.using(:javac)
+      doc.include('srcs').should be(doc)
+    end
+  end
+
+  it 'should respond to include() and add files' do
+    included = sources.first
+    define 'foo' do
+      compile.using(:javac)
+      doc.include included
+    end
+    project('foo').doc.source_files.should include(included)
+  end
+
+  it 'should respond to exclude() and return self' do
+    define 'foo' do
+      compile.using(:javac)
+      doc.exclude('srcs').should be(doc)
+    end
+  end
+
+  it 'should respond to exclude() and ignore files' do
+    excluded = sources.first
+    define 'foo' do
+      compile.using(:javac)
+      doc.exclude excluded
+    end
+    sources
+    project('foo').doc.source_files.sort.should == sources[1..-1].map { |f| File.expand_path(f) }
+  end
+
+  it 'should respond to using() and return self' do
+    define 'foo' do
+      compile.using(:javac)
+      doc.using(:foo=>'Fooing').should be(doc)
+    end
+  end
+
+  it 'should respond to using() and accept options' do
+    define 'foo' do
+      compile.using(:javac)
+      doc.using :foo=>'Fooing'
+    end
+    project('foo').doc.options[:foo].should eql('Fooing')
+  end
+
+  it 'should produce documentation' do
+    sources
+    define('foo') { compile.using(:javac) }
+    project('foo').doc.invoke
+    (1..3).map { |i| "target/doc/foo/Test#{i}.html" }.each { |f| file(f).should exist }
+  end
+
+  it 'should fail on error' do
+    write 'Test.java', 'class Test {}'
+    define 'foo' do
+      compile.using(:javac)
+      doc.include 'Test.java'
+    end
+    lambda { project('foo').doc.invoke }.should raise_error(RuntimeError, /Failed to generate Javadocs/)
+  end
+
+  it 'should be local task' do
+    define 'foo' do
+      define('bar') { compile.using(:javac) }
+    end
+    project('foo:bar').doc.should_receive(:invoke_prerequisites)
+    in_original_dir(project('foo:bar').base_dir) { task('doc').invoke }
+  end
+
+  it 'should not recurse' do
+    define 'foo' do
+      compile.using(:javac)
+      define('bar') { compile.using(:javac) }
+    end
+    project('foo:bar').doc.should_not_receive(:invoke_prerequisites)
+    project('foo').doc.invoke
+  end
+end
+