Class: Buildr::Compiler::Base

Inherits:
Object
  • Object
show all
Defined in:
lib/buildr/core/compile.rb

Overview

Base class for all compilers, with common functionality. Extend and over-ride as you see fit (see Javac as an example).

Direct Known Subclasses

Javac, Groovy::Groovyc, Scala::Scalac

Class Attribute Summary collapse

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(project, options) ⇒ Base

Construct a new compiler with the specified options. Note that options may change before the compiler is run.



111
112
113
114
 
# File 'lib/buildr/core/compile.rb', line 111

def initialize(project, options)
  @project = project
  @options = options
end

Class Attribute Details

.language ⇒ Object (readonly)

The compiled language (e.g. :java).



68
69
70
 
# File 'lib/buildr/core/compile.rb', line 68

def language
  @language
end

.packaging ⇒ Object (readonly)

The default packaging type (e.g. :jar).



78
79
80
 
# File 'lib/buildr/core/compile.rb', line 78

def packaging
  @packaging
end

.source_ext ⇒ Object (readonly)

Extension for source files (e.g. ‘java’). Defaults to language.



72
73
74
 
# File 'lib/buildr/core/compile.rb', line 72

def source_ext
  @source_ext
end

.sources ⇒ Object (readonly)

Source directories to use if none were specified (e.g. ‘java’). Defaults to #language.



70
71
72
 
# File 'lib/buildr/core/compile.rb', line 70

def sources
  @sources
end

.target ⇒ Object (readonly)

The target path (e.g. ‘classes’)



74
75
76
 
# File 'lib/buildr/core/compile.rb', line 74

def target
  @target
end

.target_ext ⇒ Object (readonly)

Extension for target files (e.g. ‘class’).



76
77
78
 
# File 'lib/buildr/core/compile.rb', line 76

def target_ext
  @target_ext
end

Instance Attribute Details

#options ⇒ Object (readonly)

Options for this compiler.



117
118
119
 
# File 'lib/buildr/core/compile.rb', line 117

def options
  @options
end

Class Method Details

.applies_to?(project, task) ⇒ Boolean

Returns true if this compiler applies to any source code found in the listed source directories. For example, Javac returns true if any of the source directories contains a .java file. The default implementation looks to see if there are any files in the specified path with the extension #source_ext.



84
85
86
87
88
89
 
# File 'lib/buildr/core/compile.rb', line 84

def applies_to?(project, task)
  paths = task.sources + [sources].flatten.map { |src| Array(project.path_to(:source, task.usage, src.to_sym)) }
  paths.flatten!
  ext_glob = Array(source_ext).join(',')
  paths.any? { |path| !Dir["#{path}/**/*.{#{ext_glob}}"].empty? }
end

.dependencies ⇒ Object

Returns additional dependencies required by this language. For example, since the test framework picks on these, you can use the JUnit framework with Scala. Defaults to obtaining a list of artifact specifications from the REQUIRES constant.



103
104
105
 
# File 'lib/buildr/core/compile.rb', line 103

def dependencies
  []
end

.specify(attrs) ⇒ Object

Implementations can use this method to specify various compiler attributes. For example:

specify :language=>:java, :target=>'classes', :target_ext=>'class', :packaging=>:jar



94
95
96
97
98
 
# File 'lib/buildr/core/compile.rb', line 94

def specify(attrs)
  attrs[:sources] ||= attrs[:language].to_s
  attrs[:source_ext] ||= attrs[:language].to_s
  attrs.each { |name, value| instance_variable_set("@#{name}", value) }
end

.to_sym ⇒ Object

The compiler’s identifier (e.g. :javac). Inferred from the class name.



63
64
65
 
# File 'lib/buildr/core/compile.rb', line 63

def to_sym
  @symbol ||= name.split('::').last.downcase.to_sym
end

Instance Method Details

#compile(sources, target, dependencies) ⇒ Object

Compile all files lists in sources (files and directories) into target using the specified dependencies.



134
135
136
 
# File 'lib/buildr/core/compile.rb', line 134

def compile(sources, target, dependencies)
  raise 'Not implemented'
end

#dependencies ⇒ Object

Returns additional dependencies required by this language. For example, since the test framework picks on these, you can use the JUnit framework with Scala.



140
141
142
 
# File 'lib/buildr/core/compile.rb', line 140

def dependencies
  self.class.dependencies
end

#needed?(sources, target, dependencies) ⇒ Boolean

Determines if the compiler needs to run by checking if the target files exist, and if any source files or dependencies are newer than corresponding target files.



121
122
123
124
125
126
127
128
129
130
 
# File 'lib/buildr/core/compile.rb', line 121

def needed?(sources, target, dependencies)
  map = compile_map(sources, target)
  return false if map.empty?
  return true unless File.exist?(target.to_s)
  source_files_not_yet_compiled = map.select { |source, target| !File.exist?(target) }.to_a
  trace "Compile needed because source file #{source_files_not_yet_compiled[0][0]} has no corresponding #{source_files_not_yet_compiled[0][1]}" unless source_files_not_yet_compiled.empty?
  return true if map.any? { |source, target| !File.exist?(target) || File.stat(source).mtime > File.stat(target).mtime }
  oldest = map.map { |source, target| File.stat(target).mtime }.min
  return dependencies.any? { |path| file(path).timestamp > oldest }
end