rdmopensource-warbler 1.1.0

data/Rakefile

@@ -0,0 +1,92 @@
+#--
+# Copyright (c) 2010 Engine Yard, Inc.
+# Copyright (c) 2007-2009 Sun Microsystems, Inc.
+# This source code is available under the MIT license.
+# See the file LICENSE.txt for details.
+#++
+
+begin
+  require 'bundler'
+  Bundler.setup
+rescue LoadError
+  puts "Please install Bundler and run 'bundle install' to ensure you have all dependencies"
+end
+
+require 'spec/rake/spectask'
+require 'spec/rake/verify_rcov'
+
+MANIFEST = FileList["History.txt", "Manifest.txt", "README.txt", "Gemfile",
+                    "LICENSE.txt", "Rakefile", "*.erb", "*.rb", "bin/*",
+                    "ext/**/*", "lib/**/*", "spec/**/*.rb", "spec/sample/**/*.*"
+                   ].to_a.reject{|f| f=~%r{spec/sample/(MANIFEST|link|web.xml)}}.sort.uniq
+
+begin
+  File.open("Manifest.txt", "w") {|f| MANIFEST.each {|n| f << "#{n}\n"} }
+  require 'hoe'
+  require File.dirname(__FILE__) + '/lib/warbler/version'
+  hoe = Hoe.spec("warbler") do |p|
+    p.version = Warbler::VERSION
+    p.rubyforge_name = "caldersphere"
+    p.url = "http://caldersphere.rubyforge.org/warbler"
+    p.author = "Nick Sieger"
+    p.email = "nick@nicksieger.com"
+    p.summary = "Warbler chirpily constructs .war files of your Rails applications."
+    p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+    p.description = p.paragraphs_of('README.txt', 1...2).join("\n\n")
+    p.extra_deps += [['rake', '>= 0.8.7'], ['jruby-jars', '>= 1.4.0'], ['jruby-rack', '>= 1.0.0'], ['rubyzip', '>= 0.9.4']]
+    p.clean_globs += ['spec/sample/MANIFEST*', 'spec/sample/web.xml*']
+  end
+  hoe.spec.files = MANIFEST
+  hoe.spec.dependencies.delete_if { |dep| dep.name == "hoe" }
+  hoe.spec.rdoc_options += ["-SHN", "-f", "darkfish"]
+
+  task :gemspec do
+    File.open("#{hoe.name}.gemspec", "w") {|f| f << hoe.spec.to_ruby }
+  end
+  task :package => :gemspec
+rescue LoadError
+  puts "You really need Hoe installed to be able to package this gem"
+end
+
+# Leave my tasks alone, Hoe
+%w(default spec rcov).each do |task|
+  Rake::Task[task].prerequisites.clear
+  Rake::Task[task].actions.clear
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts ||= []
+  t.spec_opts << "--options" << "spec/spec.opts"
+end
+
+Spec::Rake::SpecTask.new("spec:rcov") do |t|
+  t.spec_opts ||= []
+  t.spec_opts << "--options" << "spec/spec.opts"
+  t.rcov = true
+end
+
+RCov::VerifyTask.new(:rcov => "spec:rcov") do |t|
+  t.threshold = 100
+end
+
+task :default => :spec
+
+begin
+  require 'ant'
+  directory "pkg/classes"
+  task :compile => "pkg/classes" do |t|
+    ant.javac :srcdir => "ext", :destdir => t.prerequisites.first,
+    :source => "1.5", :target => "1.5", :debug => true,
+    :classpath => "${java.class.path}:${sun.boot.class.path}"
+  end
+
+  task :jar => :compile do
+    ant.jar :basedir => "pkg/classes", :destfile => "lib/warbler_war.jar", :includes => "*.class"
+  end
+rescue LoadError
+  task :jar do
+    puts "Run 'jar' with JRuby >= 1.5 to re-compile the java war booster"
+  end
+end
+
+task :package => :jar

data/bin/warble

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+#
+#--
+# Copyright (c) 2010 Engine Yard, Inc.
+# Copyright (c) 2007-2009 Sun Microsystems, Inc.
+# This source code is available under the MIT license.
+# See the file LICENSE.txt for details.
+#++
+
+require 'warbler'
+Warbler::Application.new.run

data/ext/Main.java

@@ -0,0 +1,110 @@
+/**
+ * Copyright (c) 2010 Engine Yard, Inc.
+ * This source code is available under the MIT license.
+ * See the file LICENSE.txt for details.
+ */
+
+import java.net.URLClassLoader;
+import java.net.URL;
+import java.lang.reflect.Method;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.util.Arrays;
+
+public class Main implements Runnable {
+    public static final String MAIN = "/" + Main.class.getName().replace('.', '/') + ".class";
+    public static final String WINSTONE_JAR = "/WEB-INF/winstone.jar";
+
+    private String[] args;
+    private String path, warfile;
+    private boolean debug;
+    private File webroot;
+
+    public Main(String[] args) throws Exception {
+        this.args = args;
+        URL mainClass = getClass().getResource(MAIN);
+        this.path = mainClass.toURI().getSchemeSpecificPart();
+        this.warfile = mainClass.getFile().replace("!" + MAIN, "").replace("file:", "");
+        this.debug = isDebug();
+        this.webroot = File.createTempFile("winstone", "webroot");
+        this.webroot.delete();
+        this.webroot.mkdirs();
+        this.webroot = new File(this.webroot, new File(warfile).getName());
+        Runtime.getRuntime().addShutdownHook(new Thread(this));
+    }
+
+    private URL extractWinstone() throws Exception {
+        InputStream jarStream = new URL("jar:" + path.replace(MAIN, WINSTONE_JAR)).openStream();
+        File jarFile = File.createTempFile("winstone", ".jar");
+        jarFile.deleteOnExit();
+        FileOutputStream outStream = new FileOutputStream(jarFile);
+        try {
+            byte[] buf = new byte[4096];
+            int bytesRead = 0;
+            while ((bytesRead = jarStream.read(buf)) != -1) {
+                outStream.write(buf, 0, bytesRead);
+            }
+        } finally {
+            jarStream.close();
+            outStream.close();
+        }
+        debug("winstone.jar extracted to " + jarFile.getPath());
+        return jarFile.toURI().toURL();
+    }
+
+    private void launchWinstone(URL jar) throws Exception {
+        URLClassLoader loader = new URLClassLoader(new URL[] {jar});
+        Class klass = Class.forName("winstone.Launcher", true, loader);
+        Method main = klass.getDeclaredMethod("main", new Class[] {String[].class});
+        String[] newargs = new String[args.length + 2];
+        newargs[0] = "--warfile=" + warfile;
+        newargs[1] = "--webroot=" + webroot;
+        System.arraycopy(args, 0, newargs, 2, args.length);
+        debug("invoking Winstone with: " + Arrays.deepToString(newargs));
+        main.invoke(null, new Object[] {newargs});
+    }
+
+    private void start() throws Exception {
+        URL u = extractWinstone();
+        launchWinstone(u);
+    }
+
+    private void debug(String msg) {
+        if (debug) {
+            System.out.println(msg);
+        }
+    }
+
+    private void delete(File f) {
+        if (f.isDirectory()) {
+            File[] children = f.listFiles();
+            for (int i = 0; i < children.length; i++) {
+                delete(children[i]);
+            }
+        }
+        f.delete();
+    }
+
+    public void run() {
+        delete(webroot.getParentFile());
+    }
+
+    public static void main(String[] args) {
+        try {
+            new Main(args).start();
+        } catch (Exception e) {
+            System.err.println("error: " + e.toString());
+            if (isDebug()) {
+                e.printStackTrace();
+            }
+            System.exit(1);
+        }
+    }
+
+    private static boolean isDebug() {
+        return System.getProperty("warbler.debug") != null;
+    }
+}
+

data/ext/WarblerWar.java

@@ -0,0 +1,115 @@
+/**
+ * Copyright (c) 2010 Engine Yard, Inc.
+ * This source code is available under the MIT license.
+ * See the file LICENSE.txt for details.
+ */
+
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyHash;
+import org.jruby.RubyModule;
+import org.jruby.RubyString;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.util.JRubyFile;
+
+public class WarblerWar {
+    public static void create(Ruby runtime) {
+        RubyModule task = runtime.getClassFromPath("Warbler::War");
+        task.defineAnnotatedMethods(WarblerWar.class);
+    }
+
+    @JRubyMethod
+    public static IRubyObject create_war(ThreadContext context, IRubyObject recv, IRubyObject war_path, IRubyObject entries) {
+        final Ruby runtime = recv.getRuntime();
+
+        if (!(entries instanceof RubyHash)) {
+            throw runtime.newArgumentError("expected a hash for the second argument");
+        }
+
+        RubyHash hash = (RubyHash) entries;
+        try {
+            FileOutputStream file = newFile(war_path);
+            try {
+                ZipOutputStream zip = new ZipOutputStream(file);
+                addEntries(context, zip, hash);
+                zip.finish();
+            } finally {
+                close(file);
+            }
+        } catch (IOException e) {
+            if (runtime.isDebug()) {
+                e.printStackTrace();
+            }
+            throw runtime.newIOErrorFromException(e);
+        }
+
+        return runtime.getNil();
+    }
+
+    private static void addEntries(ThreadContext context, ZipOutputStream zip, RubyHash entries) throws IOException {
+        RubyArray keys = entries.keys().sort(context, Block.NULL_BLOCK);
+        for (int i = 0; i < keys.getLength(); i++) {
+            IRubyObject key = keys.entry(i);
+            IRubyObject value = entries.op_aref(context, key);
+            addEntry(context, zip, key.convertToString().getUnicodeValue(), value);
+        }
+    }
+
+    private static void addEntry(ThreadContext context, ZipOutputStream zip, String entryName, IRubyObject value) throws IOException {
+        if (value.respondsTo("read")) {
+            RubyString str = (RubyString) value.callMethod(context, "read").checkStringType();
+            byte[] contents = str.getByteList().getUnsafeBytes();
+            zip.putNextEntry(new ZipEntry(entryName));
+            zip.write(contents);
+        } else {
+            File f;
+            if (value.isNil() || (f = getFile(value)).isDirectory()) {
+                zip.putNextEntry(new ZipEntry(entryName + "/"));
+            } else {
+                FileInputStream inFile = openFile(f);
+                try {
+                    zip.putNextEntry(new ZipEntry(entryName));
+                    byte[] buf = new byte[16384];
+                    int bytesRead = -1;
+                    while ((bytesRead = inFile.read(buf)) != -1) {
+                        zip.write(buf, 0, bytesRead);
+                    }
+                } finally {
+                    close(inFile);
+                }
+            }
+        }
+    }
+
+    private static FileOutputStream newFile(IRubyObject war_path) throws IOException {
+        return new FileOutputStream(getFile(war_path));
+    }
+
+    private static FileInputStream openFile(File file) throws IOException {
+        return new FileInputStream(file);
+    }
+
+    private static File getFile(IRubyObject path) {
+        return JRubyFile.create(path.getRuntime().getCurrentDirectory(),
+                                path.convertToString().getUnicodeValue());
+    }
+
+    private static void close(Closeable c) {
+        try {
+            c.close();
+        } catch (IOException e) {
+        }
+    }
+
+}

data/ext/WarblerWarService.java

@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2010 Engine Yard, Inc.
+ * This source code is available under the MIT license.
+ * See the file LICENSE.txt for details.
+ */
+
+import java.io.IOException;
+import org.jruby.Ruby;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class WarblerWarService implements BasicLibraryService {
+    public boolean basicLoad(final Ruby runtime) throws IOException {
+        WarblerWar.create(runtime);
+        return true;
+    }
+}
+

data/lib/warbler.rb

@@ -0,0 +1,37 @@
+#--
+# Copyright (c) 2010 Engine Yard, Inc.
+# Copyright (c) 2007-2009 Sun Microsystems, Inc.
+# This source code is available under the MIT license.
+# See the file LICENSE.txt for details.
+#++
+
+# Warbler is a lightweight, flexible, Rake-based system for packaging your Rails apps
+# into .war files.
+module Warbler
+  WARBLER_HOME = File.expand_path(File.dirname(__FILE__) + '/..') unless defined?(WARBLER_HOME)
+
+  class << self
+    # An instance of Warbler::Application used by the +warble+ command.
+    attr_accessor :application
+    # Set Warbler.framework_detection to false to disable
+    # auto-detection based on application configuration.
+    attr_accessor :framework_detection
+    attr_writer :project_application
+  end
+
+  # Warbler loads the project Rakefile in a separate Rake application
+  # from the one where the Warbler tasks are run.
+  def self.project_application
+    application.load_project_rakefile if application
+    @project_application || Rake.application
+  end
+  self.framework_detection = true
+end
+
+require 'warbler/version'
+require 'warbler/gems'
+require 'warbler/config'
+require 'warbler/war'
+require 'warbler/task'
+require 'warbler/application'
+require 'warbler/runtime'

data/lib/warbler/application.rb

@@ -0,0 +1,67 @@
+#--
+# Copyright (c) 2010 Engine Yard, Inc.
+# Copyright (c) 2007-2009 Sun Microsystems, Inc.
+# This source code is available under the MIT license.
+# See the file LICENSE.txt for details.
+#++
+
+require 'rake'
+
+# Extension of Rake::Application that allows the +warble+ command to
+# report its name properly and inject its own tasks without a
+# Rakefile.
+class Warbler::Application < Rake::Application
+  def initialize
+    super
+    Warbler.application = self
+    @project_loaded = false
+  end
+
+  # Sets the application name and loads Warbler's own tasks
+  def load_rakefile
+    @name = 'warble'
+
+    # Load the main warbler tasks
+    Warbler::Task.new
+
+    task :default => :war
+
+    desc "Generate a configuration file to customize your war"
+    task :config => "war:config"
+
+    desc "Install Warbler tasks in your Rails application"
+    task :pluginize => "war:pluginize"
+
+    desc "Feature: package gem repository inside a jar"
+    task :gemjar => "war:gemjar"
+
+    desc "Feature: make an executable archive"
+    task :executable => "war:executable"
+
+    desc "Display version of Warbler"
+    task :version => "war:version"
+  end
+
+  # Loads the project Rakefile in a separate application
+  def load_project_rakefile
+    return if @project_loaded
+    # Load any application rakefiles to aid in autodetecting applications
+    app = Warbler.project_application = Rake::Application.new
+    Rake.application = app
+    Rake::Application::DEFAULT_RAKEFILES.each do |rf|
+      if File.exist?(rf)
+        load rf
+        break
+      end
+    end
+    Rake.application = self
+    @project_loaded = true
+  end
+
+  # Run the application: The equivalent code for the +warble+ command
+  # is simply <tt>Warbler::Application.new.run</tt>.
+  def run
+    Rake.application = self
+    super
+  end
+end