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

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.



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

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

Class Attribute Details

.language ⇒ Object (readonly)

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



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

def language
  @language
end

.packaging ⇒ Object (readonly)

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



80
81
82
 
# File 'lib/buildr/core/compile.rb', line 80

def packaging
  @packaging
end

.source_ext ⇒ Object (readonly)

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



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

def source_ext
  @source_ext
end

.sources ⇒ Object (readonly)

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



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

def sources
  @sources
end

.target ⇒ Object (readonly)

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



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

def target
  @target
end

.target_ext ⇒ Object (readonly)

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



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

def target_ext
  @target_ext
end

Instance Attribute Details

#options ⇒ Object (readonly)

Options for this compiler.



124
125
126
 
# File 'lib/buildr/core/compile.rb', line 124

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.

Returns:

  • (Boolean) 


86
87
88
89
90
91
92
93
94
95
96
97
98
 
# File 'lib/buildr/core/compile.rb', line 86

def applies_to?(project, task)
  paths = task.sources + [sources].flatten.map { |src| Array(project.path_to(:source, task.usage, src.to_sym)) }
  paths.flatten!

  paths.each { |path|
    Find.find(path) {|found|
      if (!File.directory?(found)) && found.match(/.*\.#{Array(source_ext).join('|')}/)
        return true
      end
      } if File.exist? path.to_s
    }
  false
end

.dependencies ⇒ Object

Returns additional dependencies required by this language.



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

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



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

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.



65
66
67
 
# File 'lib/buildr/core/compile.rb', line 65

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.



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

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

#dependencies ⇒ Object

Returns additional dependencies required by this language.



146
147
148
 
# File 'lib/buildr/core/compile.rb', line 146

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.

Returns:

  • (Boolean) 


128
129
130
131
132
133
134
135
136
137
 
# File 'lib/buildr/core/compile.rb', line 128

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