Class: Buildr::CompileTask

Inherits:
Rake::Task show all
Defined in:
lib/buildr/core/compile.rb

Overview

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 Project#compile.

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods inherited from Rake::Task

#invoke, #invoke_with_call_chain

Constructor Details

#initialize(*args) ⇒ CompileTask

:nodoc:



233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
 
# File 'lib/buildr/core/compile.rb', line 233

def initialize(*args) #:nodoc:
  super
  parent_task = Project.parent_task(name)
  inherit = lambda { |hash, key| parent_task.options[key] } if parent_task.respond_to?(:options)
  @options = OpenObject.new &inherit
  @sources = FileList[]
  @dependencies = FileList[]

  enhance do |task|
    unless sources.empty?
      raise 'No compiler selected and can\'t determine which compiler to use' unless compiler
      raise 'No target directory specified' unless target
      mkpath target.to_s
      info "Compiling #{task.name.gsub(/:[^:]*$/, '')} into #{target.to_s}"
      @compiler.compile(sources.map(&:to_s), target.to_s, dependencies.map(&:to_s))
      # By touching the target we let other tasks know we did something,
      # and also prevent recompiling again for dependencies.
      touch target.to_s
    end
  end
end

Instance Attribute Details

#dependencies ⇒ Object

Compilation dependencies.



284
285
286
 
# File 'lib/buildr/core/compile.rb', line 284

def dependencies
  @dependencies
end

#options ⇒ Object (readonly)

Returns the compiler options.



319
320
321
 
# File 'lib/buildr/core/compile.rb', line 319

def options
  @options
end

#project ⇒ Object (readonly)

The project this task belongs to.



361
362
363
 
# File 'lib/buildr/core/compile.rb', line 361

def project
  @project
end

#sources ⇒ Object

Source directories.



256
257
258
 
# File 'lib/buildr/core/compile.rb', line 256

def sources
  @sources
end

#target ⇒ Object (readonly)

The target directory for the compiled code.



302
303
304
 
# File 'lib/buildr/core/compile.rb', line 302

def target
  @target
end

#usage ⇒ Object (readonly)

The usage, one of :main or :test.



364
365
366
 
# File 'lib/buildr/core/compile.rb', line 364

def usage
  @usage
end

Instance Method Details

#classpath ⇒ Object

Deprecated: Use dependencies instead.



272
273
274
275
 
# File 'lib/buildr/core/compile.rb', line 272

def classpath
  Buildr.application.deprecated 'Use dependencies instead.'
  dependencies
end

#classpath=(artifacts) ⇒ Object

Deprecated: Use dependencies= instead.



278
279
280
281
 
# File 'lib/buildr/core/compile.rb', line 278

def classpath=(artifacts)
  Buildr.application.deprecated 'Use dependencies= instead.'
  self.dependencies = artifacts
end

#compiler ⇒ Object

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).



339
340
341
342
 
# File 'lib/buildr/core/compile.rb', line 339

def compiler
  guess_compiler unless @compiler
  @compiler && @compiler.class.to_sym
end

#from(*sources) ⇒ Object

:call-seq:

from(*sources) => self

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

For example:

compile.from('src/java').into('classes').with('module1.jar')



265
266
267
268
269
 
# File 'lib/buildr/core/compile.rb', line 265

def from(*sources)
  @sources |= sources.flatten
  guess_compiler if @compiler.nil? && sources.flatten.any? { |source| File.exist?(source.to_s) }
  self
end

#into(path) ⇒ Object

:call-seq:

into(path) => self

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.



313
314
315
316
 
# File 'lib/buildr/core/compile.rb', line 313

def into(path)
  @target = file(path.to_s).enhance([self]) unless @target.to_s == path.to_s
  self
end

#language ⇒ Object

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



345
346
347
 
# File 'lib/buildr/core/compile.rb', line 345

def language
  compiler && @compiler.class.language
end

#packaging ⇒ Object

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



350
351
352
 
# File 'lib/buildr/core/compile.rb', line 350

def packaging
  compiler && @compiler.class.packaging
end

#timestamp ⇒ Object

:nodoc:



354
355
356
357
358
 
# File 'lib/buildr/core/compile.rb', line 354

def timestamp #:nodoc:
  # If we compiled successfully, then the target directory reflects that.
  # If we didn't, see needed?
  target ? target.timestamp : Rake::EARLY
end

#using(*args) ⇒ Object

:call-seq:

using(options) => self

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)



330
331
332
333
334
 
# File 'lib/buildr/core/compile.rb', line 330

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(*specs) ⇒ Object

:call-seq:

with(*artifacts) => self

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'))



296
297
298
299
 
# File 'lib/buildr/core/compile.rb', line 296

def with(*specs)
  @dependencies |= Buildr.artifacts(specs.flatten).uniq
  self
end