# 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 #:nodoc:
# Symbolic mapping for directory layout. Used for both the default and custom layouts.
#
# For example, the default layout maps [:source, :main, :java] to 'src/main/java', and
# [:target, :main, :classes] to 'target/classes'. You can use this to change the layout
# of your projects.
#
# To map [:source, :main] into the 'sources' directory:
# my_layout = Layout.new
# my_layout[:source, :main] = 'sources'
#
# define 'foo', :layout=>my_layout do
# ...
# end
#
# To map [:source, :main, :java] to 'java/main':
# class MainLast < Layout
# def expand(*args)
# if args[0..1] == [:source, :main]
# super args[2], :main, *args[3,]
# else
# super
# end
# end
# end
#
# define 'foo', :layout=>MainLast do
# ...
# end
class Layout
class << self
# Default layout used by new projects.
attr_accessor :default
end
def initialize #:nodoc:
@mapping = {}
end
# Expands list of symbols and path names into a full path, for example:
# puts default.expand(:source, :main, :java)
# => "src/main/java"
def expand(*args)
args = args.compact.reject { |s| s.to_s.empty? }.map(&:to_sym)
return '' if args.empty?
@mapping[args] ||= File.join(*[expand(*args[0..-2]), args.last.to_s].reject(&:empty?)) if args.size > 1
return @mapping[args] || args.first.to_s
end
# Resolves a list of symbols into a path.
def [](*args)
@mapping[args.map(&:to_sym)]
end
# Specifies the path resolved from a list of symbols.
def []=(*args)
@mapping[args[0...-1].map(&:to_sym)] = args.last
end
def initialize_copy(copy)
copy.instance_variable_set :@mapping, @mapping.clone
end
# Default layout has the following properties:
# * :source maps to the 'src' directory.
# * Anything under :source maps verbatim (e.g. :source, :main becomes 'src/main')
# * :target maps to the 'target' directory.
# * :target, :main maps to the 'target' directory as well.
# * Anything under :target, :main maps verbatim (e.g. :target, :main, :classes becomes 'target/classes')
# * Anything else under :target also maps verbatim (e.g. :target, :test becomes 'target/test')
class Default < Layout
def initialize
super
self[:source] = 'src'
self[:target, :main] = 'target'
end
end
self.default = Default.new
end
# A project definition is where you define all the tasks associated with
# the project you're building.
#
# The project itself will define several life cycle tasks for you. For example,
# it automatically creates a compile task that will compile all the source files
# found in src/main/java into target/classes, a test task that will compile source
# files from src/test/java and run all the JUnit tests found there, and a build
# task to compile and then run the tests.
#
# You use the project definition to enhance these tasks, for example, telling the
# compile task which class path dependencies to use. Or telling the project how
# to package an artifact, e.g. creating a JAR using package :jar.
#
# You can also define additional tasks that are executed by project tasks,
# or invoked from rake.
#
# Tasks created by the project are all prefixed with the project name, e.g.
# the project foo creates the task foo:compile. If foo contains a sub-project bar,
# the later will define the task foo:bar:compile. Since the compile task is
# recursive, compiling foo will also compile foo:bar.
#
# If you run:
# buildr compile
# from the command line, it will execute the compile task of the current project.
#
# Projects and sub-projects follow a directory heirarchy. The Buildfile is assumed to
# reside in the same directory as the top-level project, and each sub-project is
# contained in a sub-directory in the same name. For example:
# /home/foo
# |__ Buildfile
# |__ src/main/java
# |__ foo
# |__ src/main/java
#
# The default structure of each project is assumed to be:
# src
# |__main
# | |__java <-- Source files to compile
# | |__resources <-- Resources to copy
# | |__webapp <-- For WARs
# |__test
# | |__java <-- Source files to compile (tests)
# | |__resources <-- Resources to copy (tests)
# |__target <-- Packages created here
# | |__classes <-- Generated when compiling
# | |__resources <-- Copied (and filtered) from resources
# | |__test/classes <-- Generated when compiling tests
# | |__test/resources <-- Copied (and filtered) from resources
# |__reports <-- Test, coverage and other reports
#
# You can change the project layout by passing a new Layout to the project definition.
#
# You can only define a project once using #define. Afterwards, you can obtain the project
# definition using #project. The order in which you define projects is not important,
# project definitions are evaluated when you ask for them. Circular dependencies will not
# work. Rake tasks are only created after the project is evaluated, so if you need to access
# a task (e.g. compile) use project('foo').compile
instead of task('foo:compile')
.
#
# For example:
# define 'myapp', :version=>'1.1' do
#
# define 'wepapp' do
# compile.with project('myapp:beans')
# package :war
# end
#
# define 'beans' do
# compile.with DEPENDS
# package :jar
# end
# end
#
# puts projects.map(&:name)
# => [ 'myapp', 'myapp:beans', 'myapp:webapp' ]
# puts project('myapp:webapp').parent.name
# => 'myapp'
# puts project('myapp:webapp').compile.classpath.map(&:to_spec)
# => 'myapp:myapp-beans:jar:1.1'
class Project < Rake::Task
class << self
# :call-seq:
# define(name, properties?) { |project| ... } => project
#
# See Buildr#define.
def define(name, properties, &block) #:nodoc:
# Make sure a sub-project is only defined within the parent project,
# to prevent silly mistakes that lead to inconsistencies (e.g.
# namespaces will be all out of whack).
Buildr.application.current_scope == name.split(':')[0...-1] or
raise "You can only define a sub project (#{name}) within the definition of its parent project"
@projects ||= {}
raise "You cannot define the same project (#{name}) more than once" if @projects[name]
# Projects with names like: compile, test, build are invalid, so we have
# to make sure the project has not the name of an already defined task
raise "Invalid project name: #{name.inspect} is already used for a task" if Buildr.application.lookup(name)
Project.define_task(name).tap do |project|
# Define the project to prevent duplicate definition.
@projects[name] = project
# Set the project properties first, actions may use them.
properties.each { |name, value| project.send "#{name}=", value } if properties
# Setup to call before/after define extension callbacks
# Don't cache list of extensions, since project may add new extensions.
project.enhance do |project|
project.send :call_callbacks, :before_define
project.enhance do |project|
project.send :call_callbacks, :after_define
end
end
project.enhance do |project|
@on_define.each { |extension| extension[project] }
end if @on_define
# Enhance the project using the definition block.
project.enhance { project.instance_exec project, &block } if block
# Top-level project? Invoke the project definition. Sub-project? We don't invoke
# the project definiton yet (allow project calls to establish order of evaluation),
# but must do so before the parent project's definition is done.
project.parent.enhance { project.invoke } if project.parent
end
end
# :call-seq:
# project(name) => project
#
# See Buildr#project.
def project(*args, &block) #:nodoc:
options = args.pop if Hash === args.last
return define(args.first, options, &block) if block
rake_check_options options, :scope, :no_invoke if options
no_invoke = options && options[:no_invoke]
raise ArgumentError, 'Only one project name at a time' unless args.size == 1
@projects ||= {}
name = args.first.to_s
# Make sure parent project is evaluated (e.g. if looking for foo:bar, find foo first)
unless @projects[name]
parts = name.split(':')
project(parts.first, options || {}) if parts.size > 1
end
if options && options[:scope]
# We assume parent project is evaluated.
project = options[:scope].split(':').inject([[]]) { |scopes, scope| scopes << (scopes.last + [scope]) }.
map { |scope| @projects[(scope + [name]).join(':')] }.
select { |project| project }.last
end
project ||= @projects[name] # Not found in scope.
raise "No such project #{name}" unless project
project.invoke unless no_invoke || Buildr.application.current_scope.join(":").to_s == project.name.to_s
project
end
# :call-seq:
# projects(*names) => projects
#
# See Buildr#projects.
def projects(*names) #:nodoc:
options = names.pop if Hash === names.last
rake_check_options options, :scope, :no_invoke if options
no_invoke = options && options[:no_invoke]
@projects ||= {}
names = names.flatten
if options && options[:scope]
# We assume parent project is evaluated.
if names.empty?
parent = @projects[options[:scope].to_s] or raise "No such project #{options[:scope]}"
@projects.values.select { |project| project.parent == parent }.each { |project| project.invoke unless no_invoke }.
map { |project| [project] + projects(:scope => project, :no_invoke => no_invoke) }.flatten.sort_by(&:name)
else
names.uniq.map { |name| project(name, :scope => options[:scope], :no_invoke => no_invoke) }
end
elsif names.empty?
# Parent project(s) not evaluated so we don't know all the projects yet.
@projects.values.each { |project| project.invoke unless no_invoke }
@projects.keys.map { |name| project(name, :no_invoke => no_invoke) or raise "No such project #{name}" }.sort_by(&:name)
else
# Parent project(s) not evaluated, for the sub-projects we may need to find.
names.map { |name| name.split(':') }.select { |name| name.size > 1 }.map(&:first).uniq.each { |name| project(name, :no_invoke => no_invoke) }
names.uniq.map { |name| project(name, :no_invoke => no_invoke) or raise "No such project #{name}" }.sort_by(&:name)
end
end
# :call-seq:
# clear
#
# Discard all project definitions.
def clear
@projects.clear if @projects
end
# :call-seq:
# local_task(name)
# local_task(name) { |name| ... }
#
# Defines a local task with an optional execution message.
#
# A local task is a task that executes a task with the same name, defined in the
# current project, the project's with a base directory that is the same as the
# current directory.
#
# Complicated? Try this:
# buildr build
# is the same as:
# buildr foo:build
# But:
# cd bar
# buildr build
# is the same as:
# buildr foo:bar:build
#
# The optional block is called with the project name when the task executes
# and returns a message that, for example "Building project #{name}".
def local_task(*args, &block)
task *args do |task, args|
args = task.arg_names.map {|n| args[n]}
local_projects do |project|
info block.call(project.name) if block
task("#{project.name}:#{task.name}").invoke *args
end
end
end
# *Deprecated* Check the Extension module to see how extensions are handled.
def on_define(&block)
Buildr.application.deprecated 'This method is deprecated, see Extension'
(@on_define ||= []) << block if block
end
def scope_name(scope, task_name) #:nodoc:
task_name
end
def local_projects(dir = nil, &block) #:nodoc:
dir = File.expand_path(dir || Buildr.application.original_dir)
projects = @projects ? @projects.values : []
projects = projects.select { |project| project.base_dir == dir }
if projects.empty? && dir != Dir.pwd && File.dirname(dir) != dir
local_projects(File.dirname(dir), &block)
elsif block
if projects.empty?
warn "No projects defined for directory #{Buildr.application.original_dir}"
else
projects.each { |project| block[project] }
end
else
projects
end
end
# :call-seq:
# parent_task(task_name) => task_name or nil
#
# Returns a parent task, basically a task in a higher namespace. For example, the parent
# of 'foo:test:compile' is 'foo:compile' and the parent of 'foo:compile' is 'compile'.
def parent_task(task_name) #:nodoc:
namespace = task_name.split(':')
last_name = namespace.pop
namespace.pop
Buildr.application.lookup((namespace + [last_name]).join(':'), []) unless namespace.empty?
end
# :call-seq:
# project_from_task(task) => project
#
# Figure out project associated to this task and return it.
def project_from_task(task) #:nodoc:
project = Buildr.application.lookup('rake:' + task.to_s.gsub(/:[^:]*$/, ''))
project if Project === project
end
# Loaded extension modules.
def extension_modules #:nodoc:
@extension_modules ||= []
end
# Extension callbacks that apply to all projects
def global_callbacks #:nodoc:
@global_callbacks ||= []
end
end
# Project has visibility to everything in the Buildr namespace.
include Buildr
# The project name. For example, 'foo' for the top-level project, and 'foo:bar'
# for its sub-project.
attr_reader :name
# The parent project if this is a sub-project.
attr_reader :parent
def initialize(*args) #:nodoc:
super
split = name.split(':')
if split.size > 1
# Get parent project, but do not invoke it's definition to prevent circular
# dependencies (it's being invoked right now, so calling project will fail).
@parent = task(split[0...-1].join(':'))
raise "No parent project #{split[0...-1].join(':')}" unless @parent && Project === parent
end
# Inherit all global callbacks
@callbacks = Project.global_callbacks.dup
end
#
# Returns the root project for this project.
#
# If this project is a subproject it will find the top
# level project and return it, else it will return itself.
#
def root_project
p = project
while p.parent
p = p.parent
end
p
end
# :call-seq:
# base_dir => path
#
# Returns the project's base directory.
#
# The Buildfile defines top-level project, so it's logical that the top-level project's
# base directory is the one in which we find the Buildfile. And each sub-project has
# a base directory that is one level down, with the same name as the sub-project.
#
# For example:
# /home/foo/ <-- base_directory of project 'foo'
# /home/foo/Buildfile <-- builds 'foo'
# /home/foo/bar <-- sub-project 'foo:bar'
def base_dir
if @base_dir.nil?
if parent
# For sub-project, a good default is a directory in the parent's base_dir,
# using the same name as the project.
@base_dir = File.expand_path(name.split(':').last, parent.base_dir)
else
# For top-level project, a good default is the directory where we found the Buildfile.
@base_dir = Dir.pwd
end
end
@base_dir
end
# Returns the layout associated with this project.
def layout
@layout ||= (parent ? parent.layout : Layout.default).clone
end
# :call-seq:
# path_to(*names) => path
#
# Returns a path from a combination of name, relative to the project's base directory.
# Essentially, joins all the supplied names and expands the path relative to #base_dir.
# Symbol arguments are converted to paths based on the layout, so whenever possible stick
# to these. For example:
# path_to(:source, :main, :java)
# => 'src/main/java'
#
# Keep in mind that all tasks are defined and executed relative to the Buildfile directory,
# so you want to use #path_to to get the actual path within the project as a matter of practice.
#
# For example:
# path_to('foo', 'bar')
# => foo/bar
# path_to('/tmp')
# => /tmp
# path_to(:base_dir, 'foo') # same as path_to('foo")
# => /home/project1/foo
def path_to(*names)
File.expand_path(layout.expand(*names), base_dir)
end
alias :_ :path_to
# :call-seq:
# file(path) => Task
# file(path=>prereqs) => Task
# file(path) { |task| ... } => Task
#
# Creates and returns a new file task in the project. Similar to calling Rake's
# file method, but the path is expanded relative to the project's base directory,
# and the task executes in the project's base directory.
#
# For example:
# define 'foo' do
# define 'bar' do
# file('src') { ... }
# end
# end
#
# puts project('foo:bar').file('src').to_s
# => '/home/foo/bar/src'
def file(*args, &block)
task_name, arg_names, deps = Buildr.application.resolve_args(args)
task = Rake::FileTask.define_task(path_to(task_name))
task.set_arg_names(arg_names) unless arg_names.empty?
task.enhance Array(deps), &block
end
# :call-seq:
# task(name) => Task
# task(name=>prereqs) => Task
# task(name) { |task| ... } => Task
#
# Creates and returns a new task in the project. Similar to calling Rake's task
# method, but prefixes the task name with the project name and executes the task
# in the project's base directory.
#
# For example:
# define 'foo' do
# task 'doda'
# end
#
# puts project('foo').task('doda').name
# => 'foo:doda'
#
# When called from within the project definition, creates a new task if the task
# does not already exist. If called from outside the project definition, returns
# the named task and raises an exception if the task is not defined.
#
# As with Rake's task method, calling this method enhances the task with the
# prerequisites and optional block.
def task(*args, &block)
task_name, arg_names, deps = Buildr.application.resolve_args(args)
if task_name =~ /^:/
task = Buildr.application.switch_to_namespace [] do
Rake::Task.define_task(task_name[1..-1])
end
elsif Buildr.application.current_scope == name.split(':')
task = Rake::Task.define_task(task_name)
else
unless task = Buildr.application.lookup(task_name, name.split(':'))
raise "You cannot define a project task outside the project definition, and no task #{name}:#{task_name} defined in the project"
end
end
task.set_arg_names(arg_names) unless arg_names.empty?
task.enhance Array(deps), &block
end
# :call-seq:
# recursive_task(name=>prereqs) { |task| ... }
#
# Define a recursive task. A recursive task executes itself and the same task
# in all the sub-projects.
def recursive_task(*args, &block)
task_name, arg_names, deps = Buildr.application.resolve_args(args)
task = Buildr.options.parallel ? multitask(task_name) : task(task_name)
parent.task(task_name).enhance [task] if parent
task.set_arg_names(arg_names) unless arg_names.empty?
task.enhance Array(deps), &block
end
# :call-seq:
# project(name) => project
# project => self
#
# Same as Buildr#project. This method is called on a project, so a relative name is
# sufficient to find a sub-project.
#
# When called on a project without a name, returns the project itself. You can use that when
# setting project properties, for example:
# define 'foo' do
# project.version = '1.0'
# end
def project(*args, &block)
if Hash === args.last
options = args.pop
else
options = {}
end
if args.empty?
self
else
Project.project *(args + [{ :scope=>self.name }.merge(options)]), &block
end
end
# :call-seq:
# projects(*names) => projects
#
# Same as Buildr#projects. This method is called on a project, so relative names are
# sufficient to find sub-projects.
def projects(*args)
if Hash === args.last
options = args.pop
else
options = {}
end
Project.projects *(args + [{ :scope=>self.name }.merge(options)])
end
def inspect #:nodoc:
%Q{project(#{name.inspect})}
end
def callbacks #:nodoc:
# global + project_local callbacks for this project
@callbacks ||= []
end
def calledback #:nodoc:
# project-local callbacks that have been called
@calledback ||= {}
end
protected
# :call-seq:
# base_dir = dir
#
# Sets the project's base directory. Allows you to specify a base directory by calling
# this accessor, or with the :base_dir property when calling #define.
#
# You can only set the base directory once for a given project, and only before accessing
# the base directory (for example, by calling #file or #path_to).
# Set the base directory. Note: you can only do this once for a project,
# and only before accessing the base directory. If you try reading the
# value with #base_dir, the base directory cannot be set again.
def base_dir=(dir)
raise 'Cannot set base directory twice, or after reading its value' if @base_dir
@base_dir = File.expand_path(dir)
end
# Sets the project layout. Accepts Layout object or class (or for that matter, anything
# that can expand).
def layout=(layout)
raise 'Cannot set directory layout twice, or after reading its value' if @layout
@layout = layout.is_a?(Class) ? layout.new : layout
end
# :call-seq:
# define(name, properties?) { |project| ... } => project
#
# Define a new sub-project within this project. See Buildr#define.
def define(name, properties = nil, &block)
Project.define "#{self.name}:#{name}", properties, &block
end
def execute(args) #:nodoc:
Buildr.application.switch_to_namespace name.split(':') do
super
end
end
# Call all extension callbacks for a particular phase, e.g. :before_define, :after_define.
def call_callbacks(phase) #:nodoc:
remaining = @callbacks.select { |cb| cb.phase == phase }
known_callbacks = remaining.map { |cb| cb.name }
# call each extension in order
until remaining.empty?
callback = first_satisfied(remaining, known_callbacks)
if callback.nil?
hash = remaining.map { |cb| { cb.name => cb.dependencies} }
fail "Unsatisfied dependencies in extensions for #{phase}: #{hash.inspect}"
end
callback.blocks.each { |b| b.call(self) }
end
end
private
# find first callback with satisfied dependencies
def first_satisfied(r, known_callbacks)
remaining_names = r.map { |cb| cb.name }
res = r.find do |cb|
cb.dependencies.each do |dep|
fail "Unknown #{phase.inspect} extension dependency: #{dep.inspect}" unless known_callbacks.index(dep)
end
satisfied = cb.dependencies.find { |dep| remaining_names.index(dep) } == nil
cb if satisfied
end
r.delete res
end
end
# The basic mechanism for extending projects in Buildr are Ruby modules. In fact,
# base features like compiling and testing are all developed in the form of modules,
# and then added to the core Project class.
#
# A module defines instance methods that are then mixed into the project and become
# instance methods of the project. There are two general ways for extending projects.
# You can extend all projects by including the module in Project:
# class Project
# include MyExtension
# end
# You can also extend a given project instance and only that instance by extending
# it with the module:
# define 'foo' do
# extend MyExtension
# end
#
# Some extensions require tighter integration with the project, specifically for
# setting up tasks and properties, or for configuring tasks based on the project
# definition. You can do that by adding callbacks to the process.
#
# The easiest way to add callbacks is by incorporating the Extension module in your
# own extension, and using the various class methods to define callback behavior:
# * first_time -- This block will be called once for any particular extension.
# You can use this to setup top-level and local tasks.
# * before_define -- This block is called once for the project with the project
# instance, right before running the project definition. You can use this
# to add tasks and set properties that will be used in the project definition.
# * after_define -- This block is called once for the project with the project
# instance, right after running the project definition. You can use this to
# do any post-processing that depends on the project definition.
#
# This example illustrates how to write a simple extension:
# module LinesOfCode
# include Extension
#
# first_time do
# # Define task not specific to any projet.
# desc 'Count lines of code in current project'
# Project.local_task('loc')
# end
#
# before_define do |project|
# # Define the loc task for this particular project.
# Rake::Task.define_task 'loc' do |task|
# lines = task.prerequisites.map { |path| Dir['#{path}/**/*'] }.flatten.uniq.
# inject(0) { |total, file| total + File.readlines(file).count }
# puts "Project #{project.name} has #{lines} lines of code"
# end
# end
#
# after_define do |project|
# # Now that we know all the source directories, add them.
# task('loc'=>compile.sources + compile.test.sources)
# end
#
# # To use this method in your project:
# # loc path_1, path_2
# def loc(*paths)
# task('loc'=>paths)
# end
#
# end
#
# class Buildr::Project
# include LinesOfCode
# end
module Extension
# Extension callback details
class Callback #:nodoc:
attr_accessor :phase, :name, :dependencies, :blocks
def initialize(phase, name, dependencies, blocks)
@phase = phase
@name = name
@dependencies = dependencies
@blocks = (blocks ? (Array === blocks ? blocks : [blocks]) : [])
end
def merge(callback)
Callback.new(phase, name, @dependencies + callback.dependencies, @blocks + callback.blocks)
end
end
def self.included(base) #:nodoc:
base.extend ClassMethods
end
# Methods added to the extension module when including Extension.
module ClassMethods
def included(base) #:nodoc:
# When included in Project, add module instance, merge callbacks and call first_time.
if Project == base && !base.extension_modules.include?(module_callbacks)
base.extension_modules << module_callbacks
merge_callbacks(base.global_callbacks, module_callbacks)
first_time = module_callbacks.select { |c| c.phase == :first_time }
first_time.each do |c|
c.blocks.each { |b| b.call }
end
end
end
def extended(base) #:nodoc:
# When extending project, merge after_define callbacks and call before_define callback(s)
# immediately
if Project === base
merge_callbacks(base.callbacks, module_callbacks.select { |cb| cb.phase == :after_define })
calls = module_callbacks.select { |cb| cb.phase == :before_define }
calls.each do |cb|
cb.blocks.each { |b| b.call(base) } unless base.calledback[cb]
base.calledback[cb] = cb
end
end
end
# This block will be called once for any particular extension included in Project.
# You can use this to setup top-level and local tasks.
def first_time(&block)
module_callbacks << Callback.new(:first_time, self.name, [], block)
end
# This block is called once for the project with the project instance,
# right before running the project definition. You can use this to add
# tasks and set properties that will be used in the project definition.
#
# The block may be named and dependencies may be declared similar to Rake
# task dependencies:
#
# before_define(:my_setup) do |project|
# # do stuff on project
# end
#
# # my_setup code must run before :compile
# before_define(:compile => :my_setup)
#
def before_define(*args, &block)
if args.empty?
name = self.name
deps = []
else
name, args, deps = Buildr.application.resolve_args(args)
end
module_callbacks << Callback.new(:before_define, name, deps, block)
end
# This block is called once for the project with the project instance,
# right after running the project definition. You can use this to do
# any post-processing that depends on the project definition.
#
# The block may be named and dependencies may be declared similar to Rake
# task dependencies:
#
# after_define(:my_setup) do |project|
# # do stuff on project
# end
#
# # my_setup code must run before :compile (but only after project is defined)
# after_define(:compile => :my_setup)
#
def after_define(*args, &block)
if args.empty?
name = self.name
deps = []
else
name, args, deps = Buildr.application.resolve_args(args)
end
module_callbacks << Callback.new(:after_define, name, deps, block)
end
private
def module_callbacks
begin
const_get('Callbacks')
rescue
callbacks = []
const_set('Callbacks', callbacks)
end
end
def merge_callbacks(base, merge)
# index by phase and name
index = base.inject({}) { |hash,cb| { [cb.phase, cb.name] => cb } }
merge.each do |cb|
existing = index[[cb.phase, cb.name]]
if existing
base[base.index(existing)] = existing.merge(cb)
else
base << cb
end
index[[cb.phase, cb.name]] = cb
end
base
end
end
end
# :call-seq:
# define(name, properties?) { |project| ... } => project
#
# Defines a new project.
#
# The first argument is the project name. Each project must have a unique name.
# For a sub-project, the actual project name is created by prefixing the parent
# project's name.
#
# The second argument is optional and contains a hash or properties that are set
# on the project. You can only use properties that are supported by the project
# definition, e.g. :group and :version. You can also set these properties from the
# project definition.
#
# You pass a block that is executed in the context of the project definition.
# This block is used to define the project and tasks that are part of the project.
# Do not perform any work inside the project itself, as it will execute each time
# the Buildfile is loaded. Instead, use it to create and extend tasks that are
# related to the project.
#
# For example:
# define 'foo', :version=>'1.0' do
#
# define 'bar' do
# compile.with 'org.apache.axis2:axis2:jar:1.1'
# end
# end
#
# puts project('foo').version
# => '1.0'
# puts project('foo:bar').compile.classpath.map(&:to_spec)
# => 'org.apache.axis2:axis2:jar:1.1'
# % buildr build
# => Compiling 14 source files in foo:bar
def define(name, properties = nil, &block) #:yields:project
Project.define(name, properties, &block)
end
# :call-seq:
# project(name) => project
#
# Returns a project definition.
#
# When called from outside a project definition, must reference the project by its
# full name, e.g. 'foo:bar' to access the sub-project 'bar' in 'foo'. When called
# from inside a project, relative names are sufficient, e.g. project('foo').project('bar')
# will find the sub-project 'bar' in 'foo'.
#
# You cannot reference a project before the project is defined. When working with
# sub-projects, the project definition is stored by calling #define, and evaluated
# before a call to the parent project's #define method returns.
#
# However, if you call #project with the name of another sub-project, its definition
# is evaluated immediately. So the returned project definition is always complete,
# and you can access its definition (e.g. to find files relative to the base directory,
# or packages created by that project).
#
# For example:
# define 'myapp' do
# self.version = '1.1'
#
# define 'webapp' do
# # webapp is defined first, but beans is evaluated first
# compile.with project('beans')
# package :war
# end
#
# define 'beans' do
# package :jar
# end
# end
#
# puts project('myapp:beans').version
def project(*args, &block)
Project.project *args, &block
end
# :call-seq:
# projects(*names) => projects
#
# With no arguments, returns a list of all projects defined so far. When called on a project,
# returns all its sub-projects (direct descendants).
#
# With arguments, returns a list of named projects, fails on any name that does not exist.
# As with #project, you can use relative names when calling this method on a project.
#
# Like #project, this method evaluates the definition of each project before returning it.
# Be advised of circular dependencies.
#
# For example:
# files = projects.map { |prj| FileList[prj.path_to('src/**/*.java') }.flatten
# puts "There are #{files.size} source files in #{projects.size} projects"
#
# puts projects('myapp:beans', 'myapp:webapp').map(&:name)
# Same as:
# puts project('myapp').projects.map(&:name)
def projects(*args)
Project.projects *args
end
end