pangolin 0.3.0

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2009 Theo Hultberg
+
+Licensed 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.

data/README.rdoc

@@ -0,0 +1,72 @@
+= Pangolin
+
+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.
+
+== Example
+
+  require 'pangolin'
+
+
+  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
+
+  task :test => :compile do
+    test_classes = FileList['build/**/Test*.class'].pathmap('%{build/,}X').gsub('/', '.')
+
+    junit test_classes, :class_path => FileList['build', 'lib/*.jar']
+  end
+	
+There are more examples in the +examples+ directory.
+
+== Installation
+
+The new way, from Gemcutter:
+
+  sudo jruby -S gem install pangolin
+
+To add Gemcutter as a gem source, run these commands:
+
+  jruby -S gem install gemcutter
+  jruby -S gem tumble
+
+To add GitHub as a gem source, run this command:
+
+  jruby -S gem sources -a http://gems.github.com
+
+== Command style
+
+Many Rake add-ons look like this:
+
+  Spec::Rake::SpecTask.new(:spec) do |spec|
+    spec.spec_opts << '--options' << 'spec/spec.opts'
+    # ...
+  end
+
+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.
+
+== 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+.
+
+== Upcomming
+
+Even though the whole rationale behind Pangolin 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.
+
+== Pangolin?
+
+Pangolins eats ants for breakfast.

data/Rakefile

@@ -0,0 +1,40 @@
+require 'rake/clean'
+
+
+task :default => :prepare
+
+task :prepare do
+  require 'open-uri'
+  
+  junit_url  = "http://downloads.sourceforge.net/project/junit/junit/4.7/junit-4.7.jar"
+  ext_dir    = 'lib/pangolin/ext'
+  local_path = "#{ext_dir}/junit.jar"
+  
+  unless File.exists?(local_path)
+    mkdir_p ext_dir
+    
+    $stderr.print 'Downloading JUnit 4.7... '
+  
+    File.open(local_path, 'w') do |f|
+      f.write(open(junit_url).read)
+    end
+  
+    $stderr.puts 'done'
+  end
+end
+
+# This is a workaround for a silly bug in RubyGems on JRuby:
+# when running a rakefile as part of an install the 2>&1 redirect ends
+# ends up as an argument to Rake, and Rake complains, which makes the
+# build fail. The workaround is to declare a task with this name.
+task '2>&1' => :default
+
+
+# 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.3.0

data/examples/compile/Rakefile

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/pangolin')
+
+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/examples/test/Rakefile

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/java_tools')
+
+require 'rake/clean'
+
+
+CLOBBER.include('build')
+
+
+task :default => :test
+
+task :compile => 'build' do
+  javac FileList['{src,test}/**/*.java'], :destination => 'build',
+                                           :class_path => FileList['lib/*.jar'],
+                                              :verbose => true
+end
+
+task :test => :compile do
+  junit FileList['build/**/Test*.class'].pathmap('%{build/,}X').gsub('/', '.'), :class_path => ['build/'], :colorize => true
+end
+
+directory 'build'

data/examples/test/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/test/test/com/example/TestHelloWorld.java

@@ -0,0 +1,31 @@
+package com.example;
+
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertEquals;
+
+
+public class TestHelloWorld {
+
+	private HelloWorld helloWorld;
+	
+
+	@Before
+	public void setUp( ) {
+		helloWorld = new HelloWorld();
+	}
+	
+	@Test
+	public void testTheObvious( ) {
+		assertNotNull(helloWorld);
+	}
+	
+	@Test
+	public void testThatFails( ) {
+		assertEquals(1, 2);
+	}
+
+}

data/java_tools.gemspec

@@ -0,0 +1,74 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{java_tools}
+  s.version = "0.2.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Theo Hultberg"]
+  s.date = %q{2009-10-08}
+  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.extensions = ["Rakefile"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "examples/compile/Rakefile",
+     "examples/compile/src/com/example/HelloWorld.java",
+     "examples/package/Rakefile",
+     "examples/package/src/com/example/HelloWorld.java",
+     "examples/test/Rakefile",
+     "examples/test/src/com/example/HelloWorld.java",
+     "examples/test/test/com/example/TestHelloWorld.java",
+     "java_tools.gemspec",
+     "lib/java_tools.rb",
+     "lib/java_tools/jar.rb",
+     "lib/java_tools/javac.rb",
+     "lib/java_tools/junit.rb",
+     "lib/java_tools/output/formatting.rb",
+     "spec/jar_cmd_spec.rb",
+     "spec/jar_spec.rb",
+     "spec/javac_cmd_spec.rb",
+     "spec/javac_spec.rb",
+     "spec/junit_cmd_spec.rb",
+     "spec/junit_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb",
+     "tasks/gem.rake",
+     "tasks/rdoc.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/junit_cmd_spec.rb",
+     "spec/junit_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/pangolin.rb

@@ -0,0 +1,143 @@
+raise "Pangolin requires JRuby" unless RUBY_PLATFORM =~ /\bjava\b/
+
+
+require File.expand_path(File.dirname(__FILE__)) + '/pangolin/output/formatting'
+require File.expand_path(File.dirname(__FILE__)) + '/pangolin/javac'
+require File.expand_path(File.dirname(__FILE__)) + '/pangolin/jar'
+require File.expand_path(File.dirname(__FILE__)) + '/pangolin/junit'
+
+
+
+module Pangolin # :nodoc:
+  
+  def self.version # :nodoc:
+    version_file = File.join(File.dirname(__FILE__), '..', 'VERSION')
+    
+    File.open(version_file) do |f|
+      f.readline.strip
+    end
+  end
+  
+  def self.exec_command( obj, options, block )
+    if block
+      block.call(obj)
+    elsif options
+      configure_command(obj, options)
+    end
+
+    obj.execute or fail("Execution failed, see above")
+  end
+  
+  def self.configure_command( command, options ) # :nodoc:
+    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
+
+class Exception # :nodoc:
+  alias exception_backtrace backtrace
+  
+  # Elide JRuby backtraces to remove all the internal stuff
+  def backtrace
+    exception_backtrace.reject do |line|
+      line =~ /^(org\/jruby|com\/mysql|sun\/|java\/)/
+    end
+  end
+end
+
+# Javac can be run in either command or yield mode: command mode
+# looks roughly like this:
+#
+#   javac [file1, file2], :destination => 'build'
+#
+# and yield mode like this:
+#
+#   javac(file1, file2) do |conf|
+#     conf.destination = 'build'
+#   end
+#
+# In command mode you pass a hash with the configuration directives
+# (listed below) and in yield mode an object is passed to the block,
+# and the configuration directives should be set on that.
+#
+# The possible configuration directives are:
+# * +source_path+
+# * +destination+
+# * +class_path+
+# * +deprecation_warnings+
+# * +warnings+
+# * +encoding+
+# * +verbose+
+#
+# The directives are the same as the properties of Pangolin::Javac.
+#
+def javac( source_files, options = nil, &block )
+  Pangolin::exec_command(Pangolin::Javac.new(*source_files), options, block)
+end
+
+# Jar can be run in either command or yield mode: command mode
+# looks roughly like this:
+#
+#   jar 'output.jar', [file1, file2], :base_dir => 'build'
+#
+# and yield mode like this:
+#
+#   jar('output.jar', [file1, file2]) do |conf|
+#     conf.base_dir = 'build'
+#   end
+#
+# In command mode you pass a hash with the configuration directives
+# (listed below) and in yield mode an object is passed to the block,
+# and the configuration directives should be set on that.
+#
+# The possible configuration directives are:
+# * +base_dir+
+# * +compression+
+# * +verbose+
+#
+# The directives are the same as the properties of Pangolin::Jar.
+#
+def jar( output, files = nil, options = nil, &block )
+  base_dir = nil
+  
+  if options && options[:base_dir]
+    base_dir = options[:base_dir]
+  end
+  
+  Pangolin::exec_command(Pangolin::Jar.new(output, files, base_dir), options, block)
+end
+
+# Junit can be run in either command or yield mode: command mode
+# looks roughly like this:
+#
+#   junit ['TestFoo', 'TestBar'], :class_path => ['build']
+#
+# (where +TestFoo+ and +TestBar+ are classes available from the class path).
+#
+# Yield mode looks like this:
+#
+#   junit ['TestFoo', 'TestBar'] do |conf|
+#     conf.class_path = ['build']
+#   end
+#
+# In command mode you pass a hash with the configuration directives
+# (listed below) and in yield mode an object is passed to the block,
+# and the configuration directives should be set on that.
+#
+# The possible configuration directives are:
+# * +class_path+
+# * +colorize+
+#
+# The directives are the same as the properties of Pangolin::Junit.
+#
+def junit( classes, options = nil, &block )
+  Pangolin::exec_command(Pangolin::Junit.new(*classes), options, block)
+end