iconara-java_tools 0.1.1

data/README.textile

@@ -0,0 +1,51 @@
+h1. Java Tools
+
+Ruby wrappers for javac and jar that don't just exec.
+
+Ant is a nice tool for writing Java build scripts, but Rake is nicer. The only thing missing from Rake is a way to run javac and jar, and although it's easy to run these with exec you have to wait for the JVM to start for each invocation. In combination with JRuby this gem lets you run @javac@ and @jar@ in your Rake scripts without exec'ing, by using the programmatic interface to Javac and Java's ZIP file creation capabilities.
+
+h2. Example
+
+<pre><code>
+  require 'java_tools'
+
+
+  task :compile do
+    javac FileList['src/**/*.java'], :destination => 'build, :class_path => FileList['lib/*.jar']
+  end
+
+  task :dist => :compile do
+    jar 'dist/my-awsome-app.jar', FileList['build/**/*.class'], :base_dir => 'build'
+  end
+</code></pre>
+	
+There are more examples in the @examples@ directory.
+
+h2. Command style
+
+Many Rake add-ons look like this:
+
+<pre><code>
+  Spec::Rake::SpecTask.new(:spec) do |spec|
+    spec.spec_opts << '--options' << 'spec/spec.opts'
+    # ...
+  end
+</code></pre>
+
+I think it ruins the DSL illusion, and I prefer to write tasks that contain commands, more like how @cp@, @rm@ and @sh@ work in Rake.
+
+h2. Nailgun
+
+Don't forget that since JRuby 1.3 you can minimize the startup by using the built-in Nailgun support. Run
+
+@jruby --ng-server &@
+
+to start a Nailgun server and then run Rake with this command
+
+@jruby --ng -S rake@
+
+you'll notice that the startup time decreases significantly the second time you run it. To avoid having to write all that every time you want to build create an alias, I call mine @jrk@.
+
+h2. Upcomming
+
+Even though the whole rationale behind Java Tools is to avoid exec it wouldn't be much effort to support non-JRuby runtimes since at least the @javac@ command needs to build the command string anyway.

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rake/clean'
+
+
+task :default => :spec
+
+
+# Import all .rake-files in the tasks directory
+Dir['tasks/*.rake'].each do |tasks_file|
+  begin
+    load tasks_file
+  rescue Exception => e
+    $stderr.puts e.message
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.2

data/examples/compile/Rakefile

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/java_tools')
+
+require 'rake/clean'
+
+
+CLOBBER.include('build')
+
+
+task :default => :compile
+
+desc "Compile all classes"
+task :compile => 'build' do
+  javac FileList['src/**/*.java'], :destination => 'build', :verbose => true
+end
+
+directory 'build'

data/examples/compile/src/com/example/HelloWorld.java

@@ -0,0 +1,10 @@
+package	com.example;
+
+
+public class HelloWorld {
+	
+	public static void main( String[] args ) {
+		System.out.println("Hello world");
+	}
+	
+}

data/examples/package/Rakefile

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/java_tools')
+
+require 'rake/clean'
+
+
+CLOBBER.include('build')
+CLOBBER.include('dist')
+
+
+task :default => :package
+
+task :package => [:compile, 'dist'] do
+  jar 'dist/package.jar', FileList['build/**/*.class'], :base_dir => 'build', 
+                                                      :main_class => 'com.example.HelloWorld', 
+                                                        :manifest => {'X-Test', 'foo'},
+                                                         :verbose => true
+end
+
+task :compile => 'build' do
+  javac FileList['src/**/*.java'], :destination => 'build', :verbose => true
+end
+
+directory 'build'
+directory 'dist'

data/examples/package/src/com/example/HelloWorld.java

@@ -0,0 +1,10 @@
+package	com.example;
+
+
+public class HelloWorld {
+	
+	public static void main( String[] args ) {
+		System.out.println("Hello world");
+	}
+	
+}

data/java_tools.gemspec

@@ -0,0 +1,58 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{java_tools}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Theo Hultberg"]
+  s.date = %q{2009-08-05}
+  s.description = %q{Ant is a nice tool for writing Java build scripts, but Rake is nicer. The only thing missing from Rake is a way to run javac and jar, and although it's easy to run these as shell scripts you have to wait for the JVM to start. In combination with JRuby this gem lets you run javac and jar in your Rake scripts without exec'ing.}
+  s.email = %q{theo@iconara.net}
+  s.extra_rdoc_files = [
+    "README.textile"
+  ]
+  s.files = [
+    "README.textile",
+     "Rakefile",
+     "VERSION",
+     "examples/compile/Rakefile",
+     "examples/compile/src/com/example/HelloWorld.java",
+     "examples/package/Rakefile",
+     "examples/package/src/com/example/HelloWorld.java",
+     "java_tools.gemspec",
+     "lib/java_tools.rb",
+     "lib/java_tools/jar.rb",
+     "lib/java_tools/javac.rb",
+     "spec/jar_cmd_spec.rb",
+     "spec/jar_spec.rb",
+     "spec/javac_cmd_spec.rb",
+     "spec/javac_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "tasks/gem.rake",
+     "tasks/spec.rake"
+  ]
+  s.homepage = %q{http://github.com/iconara/java_tools}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.3}
+  s.summary = %q{Ruby wrappers for javac and jar that don't just exec}
+  s.test_files = [
+    "spec/jar_cmd_spec.rb",
+     "spec/jar_spec.rb",
+     "spec/javac_cmd_spec.rb",
+     "spec/javac_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/java_tools/jar.rb

@@ -0,0 +1,147 @@
+require 'java'
+
+
+module JavaTools
+
+  include_class 'java.io.FileOutputStream'
+  include_class 'java.util.zip.ZipOutputStream'
+  include_class 'java.util.zip.ZipEntry'
+  
+
+  class Jar
+  
+    attr_accessor :base_dir,    # string
+                  :compression, # number (0-9)
+                  :verbose      # boolean
+                  
+    attr_reader :output
+                
+    def initialize( output, files = nil, base_dir = nil )
+      @output      = output
+      @base_dir    = base_dir
+      @entries     = { } # archive_path => JarEntry
+      @verbose     = false
+      @compression = 1
+      
+      self.manifest = { }
+      
+      add_files(files) unless files.nil? || files.empty?
+    end
+  
+    def manifest=( manifest_hash )
+      @manifest = default_manifest
+      
+      manifest_hash.each do |key, value|
+        raise ArgumentError, "Malformed attribute name #{key}" if key !~ /^[\w\d][\w\d\-_]*$/
+        
+        remove_manifest_attribute(key)
+        
+        @manifest[key] = value
+      end
+    end
+    
+    def remove_manifest_attribute( name )
+      @manifest.delete_if do |key, value|
+        key.downcase == name.downcase
+      end      
+    end
+    
+    def main_class=( class_name )
+      if class_name
+        @manifest['Main-Class'] = class_name
+      else
+        remove_manifest_attribute('Main-Class')
+      end
+    end
+    
+    def default_manifest
+      {
+        'Built-By' => "JavaTools v#{JavaTools::version}",
+        'Manifest-Version' => '1.0'
+      }
+    end
+    
+    def manifest_string
+      @manifest.keys.inject("") do |str, key|
+        str + "#{key}: #{@manifest[key]}\n"
+      end
+    end
+    
+    def commit_manifest
+      add_blob(manifest_string, 'META-INF/MANIFEST.MF')
+    end
+    
+    def add_file( file_path, archive_path = nil )
+      archive_path = find_archive_path(file_path, @base_dir) unless archive_path
+      
+      if File.directory?(file_path)
+        raise ArgumentError, "\"#{file_path}\" is a directory"
+      elsif ! File.exists?(file_path)
+        raise ArgumentError, "\"#{file_path}\" does not exist"
+      end
+      
+      @entries[archive_path || file_path] = File.new(file_path)
+    end
+    
+    def add_files( files, base_dir = nil )
+      files.each do |file|
+        add_file(file, find_archive_path(file, base_dir || @base_dir))
+      end
+    end
+    
+    def add_blob( str, archive_path )
+      @entries[archive_path] = StringIO.new(str)
+    end
+    
+    def remove_entry( archive_path )
+      @entries.delete(archive_path)
+    end
+    
+    def entries
+      @entries.keys
+    end
+    
+    def execute( io = $stderr )
+      raise "Output not set" unless @output
+      
+      compression_flag = @compression == 0 ? '0' : ''
+      
+      io.puts "jar -c#{compression_flag}f #{@output} …" if @verbose
+      
+      commit_manifest
+      create_zipfile
+    end
+    
+    def create_zipfile
+      buffer_size = 65536
+      
+      zipstream = ZipOutputStream.new(FileOutputStream.new(@output))
+      
+      @entries.each do |path, io|
+        while buffer = io.read(buffer_size)
+          zipstream.put_next_entry(ZipEntry.new(path))
+          zipstream.write(buffer.to_java_bytes, 0, buffer.length)
+          zipstream.close_entry
+        end
+        
+        io.close
+      end
+            
+      zipstream.close
+    end
+    
+    def find_archive_path( path, base_dir )
+      if base_dir
+        prefix = base_dir + (base_dir =~ /\/$/ ? '' : '/')
+      
+        if 0 == path.index(prefix)
+          return path.slice(prefix.length, path.length - prefix.length)
+        end
+      end
+      
+      path
+    end
+    
+  end
+  
+end

data/lib/java_tools/javac.rb

@@ -0,0 +1,79 @@
+require 'java'
+
+
+module JavaTools
+
+  # must use include_class instead of import because import interferes with Rake's import
+  include_class 'java.io.PrintWriter'
+  include_class 'java.io.StringWriter'
+
+
+  class Javac
+
+    attr_accessor :source_files,         # array
+                  :source_path,          # array
+                  :destination,          # string
+                  :class_path,           # array
+                  :deprecation_warnings, # boolean
+                  :warnings,             # boolean
+                  :encoding,             # string
+                  :verbose               # boolean
+
+    def initialize( *source_files )
+      @source_files = source_files || [ ]
+  
+      @source_path          = [ ]
+      @destination          = 'build'
+      @class_path           = [ ]
+      @deprecation_warnings = true
+      @warnings             = true
+      @encoding             = nil
+      @verbose              = false
+    end
+
+    def command_args
+      args = [ ]
+      args << '-sourcepath' << @source_path.join(':') unless @source_path.empty?
+      args << '-d' << @destination unless (@destination.nil? || @destination =~ /^\s*$/)
+      args << '-classpath' << @class_path.join(':') unless @class_path.empty?
+      args << '-deprecation' unless @deprecation_warnings
+      args << '-nowarn' unless @warnings
+      args << '-encoding' << @encoding if @encoding
+      args + @source_files
+    end
+  
+    def command_string
+      args = [ ]
+      args << '-sourcepath' << @source_path.join(':') unless @source_path.empty?
+      args << '-d' << @destination unless (@destination.nil? || @destination =~ /^\s*$/)
+      args << '-classpath' << @class_path.join(':') unless @class_path.empty?
+      args << '-deprecation' unless @deprecation_warnings
+      args << '-nowarn' unless @warnings
+      args << '-encoding' << @encoding if @encoding
+
+      "javac #{args.join(' ')} …"
+    end
+
+    def execute( io = $stderr )
+      output_writer = StringWriter.new
+  
+      args = command_args.to_java(java.lang.String)
+  
+      result = com.sun.tools.javac.Main.compile(args, PrintWriter.new(output_writer))
+      
+      io.puts command_string if @verbose
+      
+      output_str = output_writer.to_s
+      
+      io.puts output_str if output_str !~ /^\s*$/
+  
+      if 0 == result
+        true
+      else
+        false
+      end
+    end
+
+  end
+  
+end

data/lib/java_tools.rb

@@ -0,0 +1,60 @@
+raise "JavaTools requires JRuby" unless RUBY_PLATFORM =~ /\bjava\b/
+
+
+require File.expand_path(File.dirname(__FILE__)) + '/java_tools/javac'
+require File.expand_path(File.dirname(__FILE__)) + '/java_tools/jar'
+
+
+module JavaTools
+  
+  def self.version
+    version_file = File.join(File.dirname(__FILE__), '..', 'VERSION')
+    
+    File.open(version_file) do |f|
+      f.readline.strip
+    end
+  end
+
+  def self.configure_command( command, options )
+    options.each do |option, value|
+      setter_name = "#{option}="
+      
+      if command.respond_to? setter_name
+        command.send(setter_name, value)
+      else
+        raise ArgumentError, "Invalid option: #{option}"
+      end
+    end
+  end
+  
+end
+
+def javac( source_files, options = nil )
+  obj = JavaTools::Javac.new(*source_files)
+  
+  if block_given?
+    yield obj
+  elsif options
+    JavaTools::configure_command(obj, options)
+  end
+  
+  obj.execute
+end
+
+def jar( output, files = nil, options = nil )
+  base_dir = nil
+  
+  if options && options[:base_dir]
+    base_dir = options[:base_dir]
+  end
+  
+  obj = JavaTools::Jar.new(output, files, base_dir)
+  
+  if block_given?
+    yield obj
+  elsif options
+    JavaTools::configure_command(obj, options)
+  end
+  
+  obj.execute
+end

data/spec/jar_cmd_spec.rb

@@ -0,0 +1,112 @@
+describe "jar command" do
+  
+  it "should pass the first argument to the constructor of Jar" do
+    output = 'archive.jar'
+    
+    instance = create_non_exec_jar(output)
+    
+    Jar.should_receive(:new).with(output, nil, nil).and_return(instance)
+    
+    jar output
+  end
+  
+  it "should pass the first and second arguments to the constructor of Jar" do
+    output = 'archive.jar'
+    files  = ['one/two.class', 'three/four.txt']
+    
+    Jar.should_receive(:new).with(output, files, nil).and_return do
+      instance = mock('JarInstance')
+      instance.should_receive(:execute)
+      instance
+    end
+    
+    jar output, files
+  end
+  
+  it "should yield a Jar object if a block is given" do
+    instance = create_non_exec_jar('archive.jar')
+    
+    Jar.should_receive(:new).and_return(instance)
+    
+    jar('archive.jar') do |conf|
+      conf.should be_instance_of(Jar)
+    end
+  end
+  
+  it "should set properties on the yielded Jar instance" do
+    base_dir    = 'build'
+    compression = 3
+    
+    instance = create_non_exec_jar('archive.jar')
+    
+    Jar.should_receive(:new).and_return do
+      instance.should_receive(:base_dir=).with(base_dir)
+      instance.should_receive(:compression=).with(compression)
+      instance
+    end
+    
+    jar('archive.jar') do |conf|
+      conf.base_dir    = base_dir
+      conf.compression = compression
+    end
+  end
+  
+  it "should call #execute after yielding" do
+    Jar.should_receive(:new).and_return do
+      instance = mock('JarInstance')
+      instance.should_receive(:execute)
+      instance
+    end
+    
+    jar('archive.jar') { }
+  end
+  
+  it "should call #execute in non-yield mode" do
+    instance = create_non_exec_jar('archive.jar')
+    
+    Jar.should_receive(:new).and_return(instance)
+    
+    jar 'archive.jar', :compression => 4
+  end
+  
+  it "should set the properties specified in the options parameter" do
+    base_dir    = 'build'
+    compression = 4
+    
+    Jar.should_receive(:new).and_return do
+      instance = mock('JarInstance')
+      instance.should_receive(:base_dir=).with(base_dir)
+      instance.should_receive(:compression=).with(compression)
+      instance.should_receive(:verbose=).with(false)
+      instance.should_receive(:execute)
+      instance
+    end
+    
+    jar 'archive.jar', ['build/two/three.class'], :base_dir => base_dir, :compression => compression, :verbose => false
+  end
+  
+  it "should raise an exception for an invalid option" do
+    lambda {
+      jar 'archive.jar', ['Main.class'], :bogus => 'option'
+    }.should raise_error(ArgumentError)
+  end
+  
+  it "should pass the base_dir option straight to the constructor" do
+    output   = 'output.jar'
+    files    = [__FILE__]
+    base_dir = File.dirname(__FILE__)
+    
+    instance = create_non_exec_jar(output, files)
+    
+    Jar.should_receive(:new).with(output, files, base_dir).and_return(instance)
+    
+    jar output, files, :base_dir => base_dir
+  end
+  
+  def create_non_exec_jar( output, files = nil )
+    instance = Jar.new(output, files)
+    instance.should_receive(:execute) # stop the real #execute from being called    
+    instance
+  end
+  
+end

data/spec/jar_spec.rb

@@ -0,0 +1,259 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+
+describe Jar do
+  
+  before(:each) do
+    @output = 'archive.jar'
+    @jar    = Jar.new(@output)
+  end
+  
+  describe " defaults" do
+    
+    it "should set the output file specified in the constructor" do
+      @jar.output.should == @output
+    end
+    
+    it "should have a default compression rate between 0 and 9" do
+      (@jar.compression >= 0).should be_true
+      (@jar.compression <= 9).should be_true
+    end
+    
+    it "should have a default manifest" do
+      @jar.manifest_string.should_not be_nil
+    end
+    
+    it "should have no entries" do
+      @jar.entries.should be_empty
+    end
+    
+  end
+  
+  describe "#initialize" do
+    
+    it "should take a path to the output file as parameters" do
+      output = 'path/to/output.jar'
+      
+      jar = Jar.new(output)
+      
+      jar.output.should == output
+    end
+    
+    it "should take a path to the output and a list of files as parameters" do
+      output = 'output.jar'
+      files  = [__FILE__]
+      
+      jar = Jar.new(output, files)
+      
+      jar.output.should == output
+      jar.entries.should == [__FILE__]
+    end
+    
+  end
+  
+  describe "#archive_path" do
+    
+    it "should remove the base dir path from the archive path" do
+      @jar.find_archive_path('build/com/example/HelloWorld.class', 'build').should == 'com/example/HelloWorld.class'
+    end
+    
+    it "should not remove anything from a file not in the base dir path" do
+      @jar.find_archive_path('some/other/path', 'build').should == 'some/other/path'
+    end
+    
+    it "should not remove anything from a file path if the base dir path is nil" do
+      @jar.find_archive_path('some/other/path', nil).should == 'some/other/path'
+    end
+    
+  end
+  
+  describe " manifest" do
+    
+    it "should include the Built-By key" do
+      @jar.manifest_string.include?('Built-By').should be_true
+    end
+    
+    it "should include added attributes" do
+      @jar.manifest = {'abc' => '123'}
+      
+      @jar.manifest_string.include?('abc: 123').should be_true
+    end
+    
+    it "should write the attributes on the right format" do
+      @jar.manifest = {'one' => '1', 'two' => '2', 'three' => '3'}
+      
+      @jar.manifest_string.include?("one: 1\n").should be_true
+      @jar.manifest_string.include?("two: 2\n").should be_true
+      @jar.manifest_string.include?("three: 3\n").should be_true
+    end
+        
+    it "should not begin with whitespace" do
+      @jar.manifest_string[0..1].should_not match(/\s/)
+    end
+    
+    it "should reject an empty attribute name" do
+      lambda {
+        @jar.manifest = {'' => '432'}
+      }.should raise_error(ArgumentError)
+    end
+
+    it "should reject nil as attribute name" do
+      lambda {
+        @jar.manifest = {nil => 'Hello world'}
+      }.should raise_error(ArgumentError)
+    end
+    
+    it "should reject an attribute name containing a space" do
+      lambda {
+        @jar.manifest = {'Hello World' => 'foo'}
+      }.should raise_error(ArgumentError)
+    end
+    
+    it "should reject an attribute name containing a colon" do
+      lambda {
+        @jar.manifest = {'Hello:World' => 'foo'}
+      }.should raise_error(ArgumentError)
+    end
+    
+    it "should accept a variety of legal attribute names" do
+      lambda {
+        @jar.manifest = {
+          'Manifest-Version' => 'foo',
+          'Created-By' => 'foo',
+          'Signature-Version' => 'foo',
+          'Class-Path' => 'foo'
+        }
+      }.should_not raise_error
+    end
+    
+    it "should ignore case when setting attributes" do
+      @jar.manifest = {'Hello' => 'World', 'hello' => 'Theo'}
+      
+      @jar.manifest_string.include?('Hello: World').should be_false
+      @jar.manifest_string.include?('hello: Theo').should be_true
+    end
+        
+  end
+  
+  describe "#main_class=" do
+    
+    it "should set the Main-Class attribute" do
+      @jar.main_class = 'com.example.Main'
+      
+      @jar.manifest_string.include?('Main-Class: com.example.Main').should be_true
+    end
+    
+  end
+
+  describe "#add_file" do
+    
+    it "should add an entry" do
+      path = __FILE__
+      
+      @jar.add_file(path)
+      
+      @jar.entries.include?(path).should be_true
+    end
+    
+    it "should add an entry at the specified archive path" do
+      path = __FILE__
+      archive_path = 'some/other/path.rb'
+      
+      @jar.add_file(path, archive_path)
+      
+      @jar.entries.include?(path).should be_false
+      @jar.entries.include?(archive_path).should be_true
+    end
+    
+    it "should raise an exception if the file doesn't exist" do
+      lambda {
+        @jar.add_file('some/bogus/path')
+      }.should raise_error(ArgumentError)
+    end
+    
+    it "should raise an exception if the argument is a directory" do
+      lambda {
+        @jar.add_file(File.dirname(__FILE__))
+      }.should raise_error(ArgumentError)
+    end
+            
+  end
+  
+  describe "#add_blob" do
+    
+    it "should add an entry" do
+      archive_path = 'some/path/to/a/file.txt'
+      
+      @jar.add_blob('one two three', archive_path)
+      
+      @jar.entries.include?(archive_path).should be_true
+    end
+            
+  end
+  
+  describe "#add_files" do
+    
+    it "should add all files" do
+      files = Dir.glob(File.dirname(__FILE__) + '/*.rb')
+      
+      @jar.add_files(files)
+      
+      files.each do |file|
+        @jar.entries.include?(file).should be_true
+      end
+    end
+    
+    it "should remove the base dir from all file paths" do
+      files = Dir.glob(File.dirname(__FILE__) + '/*.rb').map { |f| File.expand_path(f) }
+      base_dir = File.expand_path(File.dirname(__FILE__ + '/..'))
+      
+      @jar.add_files(files, base_dir)
+      
+      files.each do |file|
+        @jar.entries.include?(file.gsub(base_dir + '/', '')).should be_true
+      end
+    end
+    
+    it "should raise an exception if any of the files is a directory" do
+      files = [__FILE__, File.dirname(__FILE__)]
+      
+      lambda {
+        @jar.add_files(files)
+      }.should raise_error(ArgumentError)
+    end
+    
+    it "should raise an exception if any file doesn't exist" do
+      files = [__FILE__, 'some/bogus/path.txt']
+      
+      lambda {
+        @jar.add_files(files)
+      }.should raise_error(ArgumentError)
+    end
+    
+  end
+  
+  describe "#remove_entry" do
+    
+    it "should remove an added file" do
+      @jar.add_file(__FILE__)
+      @jar.remove_entry(__FILE__)
+
+      @jar.entries.include?(__FILE__).should be_false
+    end
+    
+    it "should remove an added blob" do
+      @jar.add_blob('foobar', 'foo/bar')
+      @jar.remove_entry('foo/bar')
+      
+      @jar.entries.include?('foo/bar').should be_false
+    end
+    
+    it "should not do anything when removing an entry that does not exist" do
+      lambda {
+        @jar.remove_entry('non/existent/entry')
+      }.should_not change(@jar, :entries)
+    end
+    
+  end
+  
+end

data/spec/javac_cmd_spec.rb

@@ -0,0 +1,92 @@
+describe "javac command" do
+  
+  it "should pass the first argument to the constructor of Javac" do
+    files = ['one/two.java', 'three/four.java']
+    
+    instance = Javac.new(*files)
+    instance.should_receive(:execute) # stop the real execute from being called
+    
+    Javac.should_receive(:new).with(*files).and_return(instance)
+    
+    javac files
+  end
+  
+  it "should yield a Javac object if a block is given" do
+    # prepare a stub that prevents the real #execute being called
+    instance = Javac.new
+    instance.should_receive(:execute)
+    
+    Javac.should_receive(:new).and_return(instance)
+    
+    javac('Main.java') do |conf|
+      conf.should be_instance_of(Javac)
+    end
+  end
+  
+  it "should set properties on the yielded Javac instance" do
+    destination = 'build'
+    source_path = ['xyz', 'abc']
+    
+    instance = Javac.new('Main.java')
+    
+    Javac.should_receive(:new).and_return do
+      instance.should_receive(:destination=).with(destination)
+      instance.should_receive(:source_path=).with(source_path)
+      instance.should_receive(:execute) # stop the real execute from being called
+      instance
+    end
+    
+    javac('Main.java') do |conf|
+      conf.destination = destination
+      conf.source_path = source_path
+    end
+  end
+  
+  it "should call #execute after yielding" do
+    Javac.should_receive(:new).and_return do
+      instance = mock('JavacInstance')
+      instance.should_receive(:execute)
+      instance
+    end
+    
+    javac('Main.java') { }
+  end
+  
+  it "should call #execute in non-yield mode" do
+    files = ['one/two.java', 'three/four.java']
+    
+    instance = Javac.new(*files)
+    
+    Javac.should_receive(:new).with(*files).and_return do
+      instance.should_receive(:execute)
+      instance
+    end
+    
+    javac files, :destination => 'build'
+  end
+  
+  it "should set the properties specified in the options parameter" do
+    files       = ['one/two.java', 'three/four.java']
+    destination = 'build'
+    source_path = ['src', 'common/src']
+    
+    instance = mock('JavacInstance')
+    
+    Javac.should_receive(:new).with(*files).and_return do
+      instance.should_receive(:destination=).with(destination)
+      instance.should_receive(:source_path=).with(source_path)
+      instance.should_receive(:warnings=).with(false)
+      instance.should_receive(:execute) # stop the real execute from being called
+      instance
+    end
+    
+    javac files, :destination => destination, :source_path => source_path, :warnings => false
+  end
+  
+  it "should raise an exception for an invalid option" do
+    lambda {
+      javac ['Main.java'], :bogus => 'option'
+    }.should raise_error(ArgumentError)
+  end
+  
+end

data/spec/javac_spec.rb

@@ -0,0 +1,157 @@
+describe Javac do
+  
+  before(:each) do
+    @javac = Javac.new
+  end
+  
+  describe " defaults" do
+    
+    it "should default to an empty array as source path" do
+      @javac.source_path.should be_empty
+    end
+    
+    it "should default to using 'build' as destination" do
+      @javac.destination.should == 'build'
+    end
+    
+    it "should have an empty source files list" do
+      @javac.source_files.should be_empty
+    end
+    
+    it "should have an empty classpath" do
+      @javac.class_path.should be_empty
+    end
+    
+    it "should compile with deprecation warnings" do
+      @javac.deprecation_warnings.should be_true
+    end
+    
+    it "should have no specified encoding" do
+      @javac.encoding.should be_nil
+    end
+    
+    it "should show warnings" do
+      @javac.warnings.should be_true
+    end
+    
+  end
+  
+  describe '#initialize' do
+    
+    it "should take the source files as arguments to the constructor" do
+      f1 = 'one/two/three.java'
+      f2 = 'four/five/six.java'
+      
+      javac = Javac.new(f1, f2)
+      
+      javac.source_files.include?(f1).should be_true
+      javac.source_files.include?(f2).should be_true
+    end
+    
+  end
+    
+  describe "#command_string" do
+    
+    it "should include all named source files in the command args" do
+      source_files = ['Main.java', 'com/example/Something.java']
+  
+      @javac.source_files = source_files
+  
+      source_files.each do |file_name|
+        @javac.command_args.include?(file_name)
+      end
+    end
+
+    it "should set the sourcepath to include the specified directory" do
+      @javac.source_path = ['path/to/src']
+  
+      @javac.command_string.should include('-sourcepath path/to/src')
+    end
+    
+    it "should set the sourcepath to include the specified directories" do
+      @javac.source_path = ['path/to/src', 'another/path', 'sources']
+  
+      @javac.command_string.should include('-sourcepath path/to/src:another/path:sources')
+    end
+    
+    it "should not add the sourcepath flag if source_path is empty" do
+      @javac.source_path = [ ]
+      
+      @javac.command_string.should_not include('-sourcepath')
+    end
+
+    it "should set the destination directory to the specified directory" do
+      @javac.destination = 'path/to/build'
+  
+      @javac.command_string.should include('-d path/to/build')
+    end
+  
+    it "should not add the d flag if destination is nil" do
+      @javac.destination = nil
+      
+      @javac.command_string.should_not include('-d')
+    end
+    
+    it "should not add the d flag if destination is an empty string" do
+      @javac.destination = ""
+      
+      @javac.command_string.should_not include('-d')
+    end
+    
+    it "should not add the d flag if destination is only whitespace" do
+      @javac.destination = "  \t"
+    
+      @javac.command_string.should_not include('-d')
+    end
+    
+    it "should set the deprecation flag when deprecation_warnings is false" do
+      @javac.deprecation_warnings = false
+      
+      @javac.command_string.should include('-deprecation')
+    end
+    
+    it "should not set the deprecation flag when deprecation_warnings is true" do
+      @javac.deprecation_warnings = true
+      
+      @javac.command_string.should_not include('-deprecation') 
+    end
+    
+    it "should set the classpath to the specified directory" do
+      @javac.class_path = ['path/to/classes']
+
+      @javac.command_string.should include('-classpath path/to/classes')
+    end
+    
+    it "should set the classpath to the specified directories and files" do
+      @javac.class_path = ['path/to/classes', 'lib/dependency.jar']
+
+      @javac.command_string.should include('-classpath path/to/classes:lib/dependency.jar')
+    end
+    
+    it "should not set the encoding flag if encoding is nil" do
+      @javac.encoding = nil
+      
+      @javac.command_string.should_not include('-encoding')
+    end
+    
+    it "should set the encoding flag when encoding is set" do
+      @javac.encoding = 'Shift_JIS'
+      
+      @javac.command_string.should include('-encoding Shift_JIS')
+    end
+    
+    it "should set the nowarn flag when warnings is false" do
+      @javac.warnings = false
+      
+      @javac.command_string.should include('-nowarn')
+    end
+    
+    it "should not set the nowarn flag when warnings is true" do
+      @javac.warnings = true
+      
+      @javac.command_string.should_not include('-nowarn')
+    end
+
+  end
+  
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--color
+--require spec/spec_helper
+--format specdoc

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+include JavaTools

data/tasks/gem.rake

@@ -0,0 +1,15 @@
+require 'jeweler'
+
+
+Jeweler::Tasks.new do |gemspec|
+  gemspec.name = "java_tools"
+  gemspec.summary = "Ruby wrappers for javac and jar that don't just exec"
+  gemspec.description = "Ant is a nice tool for writing Java build scripts, but Rake is nicer. The only thing missing from Rake is a way to run javac and jar, and although it's easy to run these as shell scripts you have to wait for the JVM to start. In combination with JRuby this gem lets you run javac and jar in your Rake scripts without exec'ing."
+  gemspec.email = "theo@iconara.net"
+  gemspec.homepage = "http://github.com/iconara/java_tools"
+  gemspec.authors = ["Theo Hultberg"]
+  gemspec.files.exclude '**/.gitignore'
+#  gemspec.platform = 'java'
+end
+
+CLEAN.include('pkg')

data/tasks/spec.rake

@@ -0,0 +1,9 @@
+require 'spec/rake/spectask'
+  
+
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.spec_opts << '--options' << 'spec/spec.opts'
+  spec.libs << 'lib'
+  spec.ruby_opts << '-rjava_tools'
+  spec.warning = true
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: iconara-java_tools
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Theo Hultberg
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-05 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Ant is a nice tool for writing Java build scripts, but Rake is nicer. The only thing missing from Rake is a way to run javac and jar, and although it's easy to run these as shell scripts you have to wait for the JVM to start. In combination with JRuby this gem lets you run javac and jar in your Rake scripts without exec'ing.
+email: theo@iconara.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+files: 
+- README.textile
+- Rakefile
+- VERSION
+- examples/compile/Rakefile
+- examples/compile/src/com/example/HelloWorld.java
+- examples/package/Rakefile
+- examples/package/src/com/example/HelloWorld.java
+- java_tools.gemspec
+- lib/java_tools.rb
+- lib/java_tools/jar.rb
+- lib/java_tools/javac.rb
+- spec/jar_cmd_spec.rb
+- spec/jar_spec.rb
+- spec/javac_cmd_spec.rb
+- spec/javac_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- tasks/gem.rake
+- tasks/spec.rake
+has_rdoc: false
+homepage: http://github.com/iconara/java_tools
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Ruby wrappers for javac and jar that don't just exec
+test_files: 
+- spec/jar_cmd_spec.rb
+- spec/jar_spec.rb
+- spec/javac_cmd_spec.rb
+- spec/javac_spec.rb
+- spec/spec_helper.rb