Module: Java::Commands

Defined in:
lib/buildr/java/commands.rb

Overview

JDK commands: java, javac, javadoc, etc.

Class Method Summary collapse

Class Method Details

.apt(*args) ⇒ Object

:call-seq:

apt(*files, options)

Runs Apt with the specified arguments.

The last argument may be a Hash with additional options:

  • :compile – If true, compile source files to class files.

  • :source – Specifies source compatibility with a given JVM release.

  • :output – Directory where to place the generated source files, or the generated class files when compiling.

  • :classpath – One or more file names, tasks or artifact specifications. These are all expanded into artifacts, and all tasks are invoked.



81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/buildr/java/commands.rb', line 81

def apt(*args)
  options = Hash === args.last ? args.pop : {}
  rake_check_options options, :compile, :source, :output, :classpath

  files = args.flatten.map(&:to_s).
    collect { |arg| File.directory?(arg) ? FileList["#{arg}/**/*.java"] : arg }.flatten
  cmd_args = [ trace?(:apt) ? '-verbose' : '-nowarn' ]
  if options[:compile]
    cmd_args << '-d' << options[:output].to_s
  else
    cmd_args << '-nocompile' << '-s' << options[:output].to_s
  end
  cmd_args << '-source' << options[:source] if options[:source]
  cp = classpath_from(options)
  cmd_args << '-classpath' << cp.join(File::PATH_SEPARATOR) unless cp.empty?
  cmd_args += files
  unless Buildr.application.options.dryrun
    info 'Running apt'
    trace (['apt'] + cmd_args).join(' ')
    Java.load
    ::Java::com.sun.tools.apt.Main.process(cmd_args.to_java(::Java::java.lang.String)) == 0 or
      fail 'Failed to process annotations, see errors above'
  end
end

.java(*args, &block) ⇒ Object

:call-seq:

java(class, *args, options?)

Runs Java with the specified arguments.

Each argument should be provided as separate array value, e.g.

java("-jar", "yuicompressor-2.4.2.jar", "--type","css",
     "src/main/webapp/styles/styles-all.css",
     "-o", "src/main/webapp/styles/styles-all-min.css")

The last argument may be a Hash with additional options:

  • :classpath – One or more file names, tasks or artifact specifications. These are all expanded into artifacts, and all tasks are invoked.

  • :java_args – Any additional arguments to pass (e.g. -hotspot, -xms)

  • :properties – Hash of system properties (e.g. ‘path’=>base_dir).

  • :name – Shows this name, otherwise shows the first argument (the class name).

  • :verbose – If true, prints the command and all its argument.



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/buildr/java/commands.rb', line 43

def java(*args, &block)
  options = Hash === args.last ? args.pop : {}
  options[:verbose] ||= trace?(:java)
  rake_check_options options, :classpath, :java_args, :properties, :name, :verbose

  name = options[:name]
  if name.nil?
    name = "java #{args.first}"
  end

  cmd_args = [path_to_bin('java')]
  cp = classpath_from(options)
  cmd_args << '-classpath' << cp.join(File::PATH_SEPARATOR) unless cp.empty?
  options[:properties].each { |k, v| cmd_args << "-D#{k}=#{v}" } if options[:properties]
  cmd_args += (options[:java_args] || (ENV['JAVA_OPTS'] || ENV['JAVA_OPTIONS']).to_s.split).flatten
  cmd_args += args.flatten.compact
  unless Buildr.application.options.dryrun
    info "Running #{name}" if name && options[:verbose]
    block = lambda { |ok, res| fail "Failed to execute #{name}, see errors above" unless ok } unless block
    cmd_args = cmd_args.map(&:inspect).join(' ') if Util.win_os?
    sh(*cmd_args) do |ok, ps|
      block.call ok, ps
    end
  end
end

.javac(*args) ⇒ Object

:call-seq:

javac(*files, options)

Runs Javac with the specified arguments.

The last argument may be a Hash with additional options:

  • :output – Target directory for all compiled class files.

  • :classpath – One or more file names, tasks or artifact specifications. These are all expanded into artifacts, and all tasks are invoked.

  • :sourcepath – Additional source paths to use.

  • :javac_args – Any additional arguments to pass (e.g. -extdirs, -encoding)

  • :name – Shows this name, otherwise shows the working directory.



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
 
# File 'lib/buildr/java/commands.rb', line 118

def javac(*args)
  options = Hash === args.last ? args.pop : {}
  rake_check_options options, :classpath, :sourcepath, :output, :javac_args, :name

  files = args.flatten.each { |f| f.invoke if f.respond_to?(:invoke) }.map(&:to_s).
    collect { |arg| File.directory?(arg) ? FileList["#{File.expand_path(arg)}/**/*.java"] : File.expand_path(arg) }.flatten
  name = options[:name] || Dir.pwd

  cmd_args = []
  cp = classpath_from(options)
  cmd_args << '-classpath' << cp.join(File::PATH_SEPARATOR) unless cp.empty?
  cmd_args << '-sourcepath' << [options[:sourcepath]].flatten.join(File::PATH_SEPARATOR) if options[:sourcepath]
  cmd_args << '-d' << File.expand_path(options[:output].to_s) if options[:output]
  cmd_args += options[:javac_args].flatten if options[:javac_args]
  cmd_args += files
  unless Buildr.application.options.dryrun
    mkdir_p options[:output] if options[:output]
    info "Compiling #{files.size} source files in #{name}"
    trace (['javac'] + cmd_args).join(' ')
    Java.load
    ::Java::com.sun.tools.javac.Main.compile(cmd_args.to_java(::Java::java.lang.String)) == 0 or
      fail 'Failed to compile, see errors above'
  end
end

.javadoc(*args) ⇒ Object

:call-seq:

javadoc(*files, options)

Runs Javadocs with the specified files and options.

This method accepts the following special options:

  • :output – The output directory

  • :classpath – Array of classpath dependencies.

  • :sourcepath – Array of sourcepaths (paths or tasks).

  • :name – Shows this name, otherwise shows the working directory.

All other options are passed to Javadoc as following:

  • true – As is, for example, :author=>true becomes -author

  • false – Prefixed, for example, :index=>false becomes -noindex

  • string – Option with value, for example, :windowtitle=>‘My project’ becomes -windowtitle “My project”

  • array – Option with set of values separated by spaces.



159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
 
# File 'lib/buildr/java/commands.rb', line 159

def javadoc(*args)
  options = Hash === args.last ? args.pop : {}
  fail "No output defined for javadoc" if options[:output].nil?
  options[:output] = File.expand_path(options[:output].to_s)
  cmd_args = [ '-d', options[:output], trace?(:javadoc) ? '-verbose' : '-quiet' ]
  options.reject { |key, value| [:output, :name, :sourcepath, :classpath].include?(key) }.
    each { |key, value| value.invoke if value.respond_to?(:invoke) }.
    each do |key, value|
      case value
      when true, nil
        cmd_args << "-#{key}"
      when false
        cmd_args << "-no#{key}"
      when Hash
        value.each { |k,v| cmd_args << "-#{key}" << k.to_s << v.to_s }
      else
        cmd_args += Array(value).map { |item| ["-#{key}", item.to_s] }.flatten
      end
    end
  [:sourcepath, :classpath].each do |option|
    options[option].to_a.flatten.tap do |paths|
      cmd_args << "-#{option}" << paths.flatten.map(&:to_s).join(File::PATH_SEPARATOR) unless paths.empty?
    end
  end
  files = args.each {|arg| arg.invoke if arg.respond_to?(:invoke)}.collect {|arg| arg.is_a?(Project) ? arg.compile.sources.collect{|dir| Dir["#{File.expand_path(dir.to_s)}/**/*.java"]} : File.expand_path(arg.to_s) }
  cmd_args += files.flatten.uniq.map(&:to_s)
  name = options[:name] || Dir.pwd
  unless Buildr.application.options.dryrun
    info "Generating Javadoc for #{name}"
    trace (['javadoc'] + cmd_args).join(' ')
    Java.load
    ::Java::com.sun.tools.javadoc.Main.execute(cmd_args.to_java(::Java::java.lang.String)) == 0 or
      fail 'Failed to generate Javadocs, see errors above'
  end
end