class Buildr::CompileTask

Compile task.

Attempts to determine which compiler to use based on the project layout, for example, uses the Javac compiler if it finds any .java files in src/main/java. You can also select the compiler explicitly:

compile.using(:scalac)

Accepts multiple source directories that are invoked as prerequisites before compilation. You can pass a task as a source directory:

compile.from(apt)

Likewise, dependencies are invoked before compiling. All dependencies are evaluated as artifacts, so you can pass artifact specifications and even projects:

compile.with('module1.jar', 'log4j:log4j:jar:1.0', project('foo'))

Creates a file task for the target directory, so executing that task as a dependency will execute the compile task first.

Compiler options are inherited form a parent task, e.g. the foo:bar:compile task inherits its options from the foo:compile task. Even if foo is an empty project that does not compile any classes itself, you can use it to set compile options for all its sub-projects.

Normally, the project will take care of setting the source and target directory, and you only need to set options and dependencies. See Buildr::Compile#compile.

Attributes

dependencies[RW]

Compilation dependencies.

options[R]

Returns the compiler options.

project[R]

The project this task belongs to.

sources[RW]

Source directories.

target[R]

The target directory for the compiled code.

usage[R]

The usage, one of :main or :test.

Public Instance Methods

classpath() click to toggle source

Deprecated: Use dependencies instead.

# File lib/buildr/core/compile.rb, line 281
def classpath
  Buildr.application.deprecated 'Use dependencies instead.'
  dependencies
end
classpath=(artifacts) click to toggle source

Deprecated: Use dependencies= instead.

# File lib/buildr/core/compile.rb, line 287
def classpath=(artifacts)
  Buildr.application.deprecated 'Use dependencies= instead.'
  self.dependencies = artifacts
end
compiler() click to toggle source

Returns the compiler if known. The compiler is either automatically selected based on existing source directories (e.g. src/main/java), or by requesting a specific compiler (see using).

# File lib/buildr/core/compile.rb, line 348
def compiler
  guess_compiler unless @compiler
  @compiler && @compiler.class.to_sym
end
from(*sources) → self click to toggle source

Adds source directories and files to compile, and returns self.

For example:

compile.from('src/java').into('classes').with('module1.jar')
# File lib/buildr/core/compile.rb, line 274
def from(*sources)
  @sources |= sources.flatten
  guess_compiler if @compiler.nil? && sources.flatten.any? { |source| File.exist?(source.to_s) }
  self
end
into(path) → self click to toggle source

Sets the target directory and returns self. This will also set the compile task as a prerequisite to a file task on the target directory.

For example:

compile(src_dir).into(target_dir).with(artifacts)

Both compile.invoke and file(target_dir).invoke will compile the source files.

# File lib/buildr/core/compile.rb, line 322
def into(path)
  @target = file(path.to_s).enhance([self]) unless @target.to_s == path.to_s
  self
end
language() click to toggle source

Returns the compiled language, if known. See also compiler.

# File lib/buildr/core/compile.rb, line 354
def language
  compiler && @compiler.class.language
end
packaging() click to toggle source

Returns the default packaging type for this compiler, if known.

# File lib/buildr/core/compile.rb, line 359
def packaging
  compiler && @compiler.class.packaging
end
using(options) → self click to toggle source

Sets the compiler options from a hash and returns self. Can also be used to select the compiler.

For example:

compile.using(:warnings=>true, :source=>'1.5')
compile.using(:scala)
# File lib/buildr/core/compile.rb, line 339
def using(*args)
  args.pop.each { |key, value| options.send "#{key}=", value } if Hash === args.last
  self.compiler = args.pop until args.empty?
  self
end
with(*artifacts) → self click to toggle source

Adds files and artifacts as dependencies, and returns self.

Calls artifacts on the arguments, so you can pass artifact specifications, tasks, projects, etc. Use this rather than setting the dependencies array directly.

For example:

compile.with('module1.jar', 'log4j:log4j:jar:1.0', project('foo'))
# File lib/buildr/core/compile.rb, line 305
def with(*specs)
  @dependencies |= Buildr.artifacts(specs.flatten).uniq
  self
end