warbler 1.2.1 → 1.3.0.beta1

data/Gemfile

@@ -1,11 +1,14 @@
 source "http://rubygems.org/"
 
 gem "rake", ">= 0.8.7"
-gem "rdoc"
 gem "rubyzip"
 gem "jruby-jars"
 gem "jruby-rack"
-gem "rspec"
-gem "diff-lcs"
-gem "rcov", ">= 0.9.8"
-gem "hoe", ">= 2.3.2"
+
+group :development do
+  gem "rspec", "~> 1.3"
+  gem "diff-lcs"
+  gem "rcov", ">= 0.9.8"
+  gem "hoe", ">= 2.3.2"
+  gem "rdoc"
+end

data/History.txt

@@ -1,3 +1,8 @@
+== 1.3.0
+
+- Warbler can now package regular Ruby projects as executable jar
+  files. See the README.txt file for details.
+
 == 1.2.1
 
 - Add --directoryListings=false to Winstone launch by default. In some

data/Manifest.txt

@@ -5,46 +5,66 @@ Manifest.txt
 README.txt
 Rakefile
 bin/warble
-ext/Main.java
-ext/WarblerWar.java
-ext/WarblerWarService.java
+ext/JarMain.java
+ext/WarMain.java
+ext/WarblerJar.java
+ext/WarblerJarService.java
 lib/warbler
 lib/warbler.rb
 lib/warbler/application.rb
 lib/warbler/config.rb
 lib/warbler/gems.rb
+lib/warbler/jar.rb
 lib/warbler/task.rb
 lib/warbler/templates
 lib/warbler/templates/config.erb
 lib/warbler/templates/rack.erb
 lib/warbler/templates/rails.erb
+lib/warbler/traits
+lib/warbler/traits.rb
+lib/warbler/traits/bundler.rb
+lib/warbler/traits/gemspec.rb
+lib/warbler/traits/jar.rb
+lib/warbler/traits/merb.rb
+lib/warbler/traits/nogemspec.rb
+lib/warbler/traits/rack.rb
+lib/warbler/traits/rails.rb
+lib/warbler/traits/war.rb
 lib/warbler/version.rb
 lib/warbler/war.rb
-lib/warbler_war.jar
-spec/sample/app/controllers/application.rb
-spec/sample/app/helpers/application_helper.rb
-spec/sample/config/boot.rb
-spec/sample/config/database.yml
-spec/sample/config/environment.rb
-spec/sample/config/environments/development.rb
-spec/sample/config/environments/production.rb
-spec/sample/config/environments/test.rb
-spec/sample/config/initializers/inflections.rb
-spec/sample/config/initializers/mime_types.rb
-spec/sample/config/initializers/new_rails_defaults.rb
-spec/sample/config/routes.rb
-spec/sample/lib/tasks/utils.rake
-spec/sample/public/404.html
-spec/sample/public/422.html
-spec/sample/public/500.html
-spec/sample/public/favicon.ico
-spec/sample/public/index.html
-spec/sample/public/robots.txt
+lib/warbler_jar.jar
+spec/sample_jar/History.txt
+spec/sample_jar/Manifest.txt
+spec/sample_jar/README.txt
+spec/sample_jar/lib/sample_jar.rb
+spec/sample_jar/sample_jar.gemspec
+spec/sample_jar/test/test_sample_jar.rb
+spec/sample_war/app/controllers/application.rb
+spec/sample_war/app/helpers/application_helper.rb
+spec/sample_war/config/boot.rb
+spec/sample_war/config/database.yml
+spec/sample_war/config/environment.rb
+spec/sample_war/config/environments/development.rb
+spec/sample_war/config/environments/production.rb
+spec/sample_war/config/environments/test.rb
+spec/sample_war/config/initializers/inflections.rb
+spec/sample_war/config/initializers/mime_types.rb
+spec/sample_war/config/initializers/new_rails_defaults.rb
+spec/sample_war/config/routes.rb
+spec/sample_war/lib/tasks/utils.rake
+spec/sample_war/public/404.html
+spec/sample_war/public/422.html
+spec/sample_war/public/500.html
+spec/sample_war/public/favicon.ico
+spec/sample_war/public/index.html
+spec/sample_war/public/robots.txt
 spec/spec_helper.rb
 spec/warbler/application_spec.rb
 spec/warbler/config_spec.rb
 spec/warbler/gems_spec.rb
+spec/warbler/jar_spec.rb
 spec/warbler/task_spec.rb
+spec/warbler/traits_spec.rb
 spec/warbler/war_spec.rb
 warble.rb
 web.xml.erb

data/README.txt

@@ -1,18 +1,20 @@
 = Warbler
 
-Warbler is a gem to make a .war file out of a Rails, Merb, or Rack-based
-application. The intent is to provide a minimal, flexible, ruby-like way to
-bundle up all of your application files for deployment to a Java application
-server.
+Warbler is a gem to make a Java jar or war file out of any Ruby,
+Rails, Merb, or Rack application. Warbler provides a minimal,
+flexible, Ruby-like way to bundle up all of your application files for
+deployment to a Java environment.
 
 Warbler provides a sane set of out-of-the box defaults that should allow most
-Ruby web applications to assemble and Just Work.
+Ruby applications to assemble and Just Work.
 
 == Getting Started
 
 1. Install the gem: <tt>gem install warbler</tt>.
-2. Run warbler in the top directory of your Rails application: <tt>warble</tt>.
-3. Deploy your myapp.war file to your favorite Java application server.
+2. Run warbler in the top directory of your application: <tt>warble</tt>.
+3a. For a web project, deploy your myapp.war file to your favorite Java
+    application server.
+3b. For a standalone applications, just run it: <tt>java -jar myapp.jar</tt>.
 
 == Usage
 
@@ -21,23 +23,23 @@ defined tasks.
 
     $ warble -T
     warble compiled    # Feature: precompile all Ruby files
-    warble config      # Generate a configuration file to customize your war
+    warble config      # Generate a configuration file to customize your archive
     warble executable  # Feature: make an executable archive
-    warble gemjar      # Feature: package gem repository inside a jar
+    warble gemjar      # Feature: package gem repository inside a war
     warble pluginize   # Install Warbler tasks in your Rails application
     warble version     # Display version of Warbler
-    warble war         # Create the project .war file
-    warble war:clean   # Remove the .war file
+    warble war         # Create the project war file
+    warble war:clean   # Remove the project war file
     warble war:debug   # Dump diagnostic information
 
-Type <tt>warble</tt> or <tt>warble war</tt> to create the war file.
+Type <tt>warble</tt> to create the jar or war file.
 
 == Features
 
 Warbler "features" are small Rake tasks that run before the creation
-of the war file and make manipulations to the war file structure. For
+of the war file and make manipulations to the archive structure. For
 instance, the +executable+ feature makes your war file capable of
-running on its own (like a jar), without a servlet container:
+running on its own, without a servlet container:
 
     warble executable war
 
@@ -54,9 +56,11 @@ Currently, three features are available.
 * +gemjar+: This bundles all gems into a single gem file to reduce the
   number of files in the .war. This is mostly useful for Google
   AppEngine where the number of files per application has a limit.
+  (Note: not applicable for jar-based applications.)
 * +executable+: This bundles an embedded web server into the .war so
   that it can either be deployed into a traditional java web server or
   run as a standalone application using <tt>java -jar myapp.war</tt>.
+  (Note: jar-based applications are executable by default.)
 * +compiled+: This uses +jrubyc+ to precompile all .rb files in your
   application to .class files and includes those in the .war instead
   of the Ruby sources.
@@ -64,15 +68,50 @@ Currently, three features are available.
 Features may form the basis for a third-party plugin system in the
 future if there is demand.
 
-== Configuration
+== War or Jar?
+
+War-based projects are for Rails, Merb, or Rack-based web
+applications. They usually contain a <tt>config/environment.rb</tt>
+file, a <tt>config/init.rb</tt> file, or a <tt>config.ru</tt> file.
+The presence of these files are used to determine if the project
+is a web application, and thus a Java EE compatible war file is built
+for the project.
+
+Jar-based projects are for standalone Ruby applications. Usually a
+Ruby application has a launcher script in the <tt>bin</tt> directory
+and Ruby code in the <tt>lib</tt> directory. Warbler packages the
+application so that <tt>java -jar myapp.jar</tt> runs the launcher
+script.
+
+== Jar Files
+
+=== Gem Specification (gemspec) Files
+
+If your project has a <tt>.gemspec</tt> file in the top directory, it
+will be used to configure the project's dependencies, launcher script,
+require paths, and the files to be included in the archive. For best
+results make sure your gemspec specifies all of the following
+attributes:
+
+* +default_executable+
+* +files+
+* +require_paths+
+* runtime dependencies added with +add_dependency+
+
+If your project do not have a <tt>.gemspec</tt>, Warbler will attempt
+to guess the launcher from the contents of the <tt>bin</tt> directory
+and use the <tt>lib</tt> directory as the lone require path. All files
+in the project will be included in the archive.
 
 === Bundler
 
 Applications that use Bundler[http://gembundler.com/], detected via
-presence of a +Gemfile+, will have the gems packaged up into the war
-file along with the Gemfile. The Bundler groups named +:development+
-and +:test+ will be excluded by default, unless you specify with
-+config.bundle_without+ in +config/warble.rb+.
+presence of a +Gemfile+, will have the gems packaged up into the
+archive along with the Gemfile. The Bundler groups named
++:development+ and +:test+ will be excluded by default, unless you
+specify with +config.bundle_without+ in +config/warble.rb+.
+
+== War Files
 
 === Rails applications
 
@@ -120,13 +159,7 @@ of how to configure Warbler to package Camping and Sinatra apps.
   uses? Gem.loaded_specs is available, but the application needs to be
   loaded first before its contents are reliable.
 
-=== Custom configuration
-
-The default configuration puts application files (+app+, +config+, +lib+,
-+log+, +vendor+, +tmp+) under the .war file's WEB-INF directory, and files in
-+public+ in the root of the .war file. Any Java .jar files stored in lib will
-automatically be placed in WEB-INF/lib for placement on the web app's
-classpath.
+== Custom configuration
 
 If the default settings are not appropriate for your application, you can
 customize Warbler's behavior. To customize files, libraries, and gems included
@@ -139,6 +172,14 @@ Finally, edit the config/warble.rb to your taste. The generated
 config/warble.rb file is fully-documented with the available options
 and default values.
 
+=== War layout
+
+The default configuration puts application files (+app+, +config+, +lib+,
++log+, +vendor+, +tmp+) under the .war file's WEB-INF directory, and files in
++public+ in the root of the .war file. Any Java .jar files stored in lib will
+automatically be placed in WEB-INF/lib for placement on the web app's
+classpath.
+
 === Web.xml
 
 Java web applications are configured mainly through this file, and Warbler

data/Rakefile

@@ -16,7 +16,7 @@ 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/**/*.*"
+                    "ext/**/*", "lib/**/*", "spec/**/*.rb", "spec/sample*/**/*.*"
                    ].to_a.reject{|f| f=~%r{spec/sample/(MANIFEST|link|web.xml)}}.sort.uniq
 
 begin
@@ -33,7 +33,7 @@ begin
     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*']
+    p.clean_globs += %w(MANIFEST web.xml init.rb).map{|f| "spec/sample*/#{f}*" }
   end
   hoe.spec.files = MANIFEST
   hoe.spec.dependencies.delete_if { |dep| dep.name == "hoe" }
@@ -61,6 +61,8 @@ end
 Spec::Rake::SpecTask.new("spec:rcov") do |t|
   t.spec_opts ||= []
   t.spec_opts << "--options" << "spec/spec.opts"
+  t.rcov_opts ||= []
+  t.rcov_opts << "-x" << "/gems/"
   t.rcov = true
 end
 
@@ -76,16 +78,25 @@ begin
   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}"
+    :classpath => "${java.class.path}:${sun.boot.class.path}",
+    :includeantRuntime => false
   end
 
   task :jar => :compile do
-    ant.jar :basedir => "pkg/classes", :destfile => "lib/warbler_war.jar", :includes => "*.class"
+    ant.jar :basedir => "pkg/classes", :destfile => "lib/warbler_jar.jar", :includes => "*.class"
   end
 rescue LoadError
   task :jar do
-    puts "Run 'jar' with JRuby >= 1.5 to re-compile the java war booster"
+    puts "Run 'jar' with JRuby >= 1.5 to re-compile the java jar booster"
   end
 end
 
-task :package => :jar
+# Make sure jar gets compiled before the gem is built
+task Rake::Task['gem'].prerequisites.first => :jar
+
+task :warbler_jar => 'pkg' do
+  ruby "-rubygems", "-Ilib", "-S", "bin/warble"
+  mv "warbler.jar", "pkg/warbler-#{Warbler::VERSION}.jar"
+end
+
+task :package => :warbler_jar

data/ext/JarMain.java

@@ -0,0 +1,147 @@
+/**
+ * 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.File;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+public class JarMain implements Runnable {
+    public static final String MAIN = "/" + JarMain.class.getName().replace('.', '/') + ".class";
+
+    private String[] args;
+    private String path, jarfile;
+    private boolean debug;
+    private File extractRoot;
+
+    public JarMain(String[] args) throws Exception {
+        this.args = args;
+        URL mainClass = getClass().getResource(MAIN);
+        this.path = mainClass.toURI().getSchemeSpecificPart();
+        this.jarfile = mainClass.getFile().replace("!" + MAIN, "").replace("file:", "");
+        this.debug = isDebug();
+        this.extractRoot = File.createTempFile("jruby", "extract");
+        this.extractRoot.delete();
+        this.extractRoot.mkdirs();
+        Runtime.getRuntime().addShutdownHook(new Thread(this));
+    }
+
+    private URL[] extractJRuby() throws Exception {
+        JarFile jf = new JarFile(this.jarfile);
+        List<String> jarNames = new ArrayList<String>();
+        for (Enumeration<JarEntry> eje = jf.entries(); eje.hasMoreElements(); ) {
+            String name = eje.nextElement().getName();
+            if (name.startsWith("META-INF/lib") && name.endsWith(".jar")) {
+                jarNames.add("/" + name);
+            }
+        }
+
+        List<URL> urls = new ArrayList<URL>();
+        for (String name : jarNames) {
+            urls.add(extractJar(name));
+        }
+
+        return (URL[]) urls.toArray(new URL[urls.size()]);
+    }
+
+    private URL extractJar(String jarpath) throws Exception {
+        InputStream jarStream = new URL("jar:" + path.replace(MAIN, jarpath)).openStream();
+        String jarname = jarpath.substring(jarpath.lastIndexOf("/") + 1, jarpath.lastIndexOf("."));
+        File jarFile = new File(extractRoot, jarname + ".jar");
+        jarFile.deleteOnExit();
+        FileOutputStream outStream = new FileOutputStream(jarFile);
+        try {
+            byte[] buf = new byte[65536];
+            int bytesRead = 0;
+            while ((bytesRead = jarStream.read(buf)) != -1) {
+                outStream.write(buf, 0, bytesRead);
+            }
+        } finally {
+            jarStream.close();
+            outStream.close();
+        }
+        debug(jarname + ".jar extracted to " + jarFile.getPath());
+        return jarFile.toURI().toURL();
+    }
+
+    private int launchJRuby(URL[] jars) throws Exception {
+        System.setProperty("org.jruby.embed.class.path", "");
+        URLClassLoader loader = new URLClassLoader(jars);
+        Class scriptingContainerClass = Class.forName("org.jruby.embed.ScriptingContainer", true, loader);
+        Object scriptingContainer = scriptingContainerClass.newInstance();
+
+        Method argv = scriptingContainerClass.getDeclaredMethod("setArgv", new Class[] {String[].class});
+        argv.invoke(scriptingContainer, new Object[] {args});
+        Method setClassLoader = scriptingContainerClass.getDeclaredMethod("setClassLoader", new Class[] {ClassLoader.class});
+        setClassLoader.invoke(scriptingContainer, new Object[] {loader});
+        debug("invoking " + jarfile + " with: " + Arrays.deepToString(args));
+
+        Method runScriptlet = scriptingContainerClass.getDeclaredMethod("runScriptlet", new Class[] {String.class});
+        return ((Number) runScriptlet.invoke(scriptingContainer, new Object[] {
+                    "begin\n" +
+                    "require 'META-INF/init.rb'\n" +
+                    "require 'META-INF/main.rb'\n" +
+                    "0\n" +
+                    "rescue SystemExit => e\n" +
+                    "e.status\n" +
+                    "end"
+                })).intValue();
+    }
+
+    private int start() throws Exception {
+        URL[] u = extractJRuby();
+        return launchJRuby(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(extractRoot);
+    }
+
+    public static void main(String[] args) {
+        try {
+            int exit = new JarMain(args).start();
+            System.exit(exit);
+        } catch (Exception e) {
+            Throwable t = e;
+            while (t.getCause() != null && t.getCause() != t) {
+                t = t.getCause();
+            }
+
+            if (isDebug()) {
+                t.printStackTrace();
+            }
+            System.exit(1);
+        }
+    }
+
+    private static boolean isDebug() {
+        return System.getProperty("warbler.debug") != null;
+    }
+}

data/ext/{Main.java → WarMain.java}

@@ -13,8 +13,8 @@ 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 class WarMain implements Runnable {
+    public static final String MAIN = "/" + WarMain.class.getName().replace('.', '/') + ".class";
     public static final String WINSTONE_JAR = "/WEB-INF/winstone.jar";
 
     private String[] args;
@@ -22,7 +22,7 @@ public class Main implements Runnable {
     private boolean debug;
     private File webroot;
 
-    public Main(String[] args) throws Exception {
+    public WarMain(String[] args) throws Exception {
         this.args = args;
         URL mainClass = getClass().getResource(MAIN);
         this.path = mainClass.toURI().getSchemeSpecificPart();
@@ -94,7 +94,7 @@ public class Main implements Runnable {
 
     public static void main(String[] args) {
         try {
-            new Main(args).start();
+            new WarMain(args).start();
         } catch (Exception e) {
             System.err.println("error: " + e.toString());
             if (isDebug()) {

data/ext/{WarblerWar.java → WarblerJar.java}

@@ -7,9 +7,14 @@
 import java.io.Closeable;
 import java.io.File;
 import java.io.FileInputStream;
+import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
+import java.io.InputStream;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
 import java.util.zip.ZipOutputStream;
 
 import org.jruby.Ruby;
@@ -21,16 +26,17 @@ 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.ByteList;
 import org.jruby.util.JRubyFile;
 
-public class WarblerWar {
+public class WarblerJar {
     public static void create(Ruby runtime) {
-        RubyModule task = runtime.getClassFromPath("Warbler::War");
-        task.defineAnnotatedMethods(WarblerWar.class);
+        RubyModule task = runtime.getClassFromPath("Warbler::Jar");
+        task.defineAnnotatedMethods(WarblerJar.class);
     }
 
     @JRubyMethod
-    public static IRubyObject create_war(ThreadContext context, IRubyObject recv, IRubyObject war_path, IRubyObject entries) {
+    public static IRubyObject create_jar(ThreadContext context, IRubyObject recv, IRubyObject jar_path, IRubyObject entries) {
         final Ruby runtime = recv.getRuntime();
 
         if (!(entries instanceof RubyHash)) {
@@ -39,7 +45,7 @@ public class WarblerWar {
 
         RubyHash hash = (RubyHash) entries;
         try {
-            FileOutputStream file = newFile(war_path);
+            FileOutputStream file = newFile(jar_path);
             try {
                 ZipOutputStream zip = new ZipOutputStream(file);
                 addEntries(context, zip, hash);
@@ -57,6 +63,32 @@ public class WarblerWar {
         return runtime.getNil();
     }
 
+    @JRubyMethod
+    public static IRubyObject entry_in_jar(ThreadContext context, IRubyObject recv, IRubyObject jar_path, IRubyObject entry) {
+        final Ruby runtime = recv.getRuntime();
+        try {
+            InputStream entryStream = getStream(jar_path.convertToString().getUnicodeValue(),
+                                                entry.convertToString().getUnicodeValue());
+            try {
+                byte[] buf = new byte[16384];
+                ByteList blist = new ByteList();
+                int bytesRead = -1;
+                while ((bytesRead = entryStream.read(buf)) != -1) {
+                    blist.append(buf, 0, bytesRead);
+                }
+                IRubyObject stringio = runtime.getModule("StringIO");
+                return stringio.callMethod(context, "new", runtime.newString(blist));
+            } finally {
+                close(entryStream);
+            }
+        } catch (IOException e) {
+            if (runtime.isDebug()) {
+                e.printStackTrace();
+            }
+            throw runtime.newIOErrorFromException(e);
+        }
+    }
+
     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++) {
@@ -77,7 +109,12 @@ public class WarblerWar {
             if (value.isNil() || (f = getFile(value)).isDirectory()) {
                 zip.putNextEntry(new ZipEntry(entryName + "/"));
             } else {
-                FileInputStream inFile = openFile(f);
+                String path = f.getPath();
+                if (!f.exists()) {
+                    path = value.convertToString().getUnicodeValue();
+                }
+
+                InputStream inFile = getStream(path, null);
                 try {
                     zip.putNextEntry(new ZipEntry(entryName));
                     byte[] buf = new byte[16384];
@@ -92,12 +129,8 @@ public class WarblerWar {
         }
     }
 
-    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 FileOutputStream newFile(IRubyObject jar_path) throws IOException {
+        return new FileOutputStream(getFile(jar_path));
     }
 
     private static File getFile(IRubyObject path) {
@@ -108,8 +141,41 @@ public class WarblerWar {
     private static void close(Closeable c) {
         try {
             c.close();
-        } catch (IOException e) {
+        } catch (Exception e) {
+        }
+    }
+
+    private static Pattern PROTOCOL = Pattern.compile("^[a-z][a-z0-9]+:");
+
+    private static InputStream getStream(String jar, String entry) throws IOException {
+        Matcher m = PROTOCOL.matcher(jar);
+        while (m.find()) {
+            jar = jar.substring(m.end());
+            m = PROTOCOL.matcher(jar);
         }
+
+        String[] path = jar.split("!/");
+        InputStream stream = new FileInputStream(path[0]);
+        for (int i = 1; i < path.length; i++) {
+            stream = entryInJar(stream, path[i]);
+        }
+
+        if (entry == null) {
+            return stream;
+        }
+
+        return entryInJar(stream, entry);
     }
 
+    private static InputStream entryInJar(InputStream jar, String entry) throws IOException {
+        ZipInputStream jstream = new ZipInputStream(jar);
+        ZipEntry zentry = null;
+        while ((zentry = jstream.getNextEntry()) != null) {
+            if (zentry.getName().equals(entry)) {
+                return jstream;
+            }
+            jstream.closeEntry();
+        }
+        throw new FileNotFoundException("entry '" + entry + "' not found in " + jar);
+    }
 }

data/ext/{WarblerWarService.java → WarblerJarService.java}

@@ -8,9 +8,9 @@ import java.io.IOException;
 import org.jruby.Ruby;
 import org.jruby.runtime.load.BasicLibraryService;
 
-public class WarblerWarService implements BasicLibraryService {
+public class WarblerJarService implements BasicLibraryService {
     public boolean basicLoad(final Ruby runtime) throws IOException {
-        WarblerWar.create(runtime);
+        WarblerJar.create(runtime);
         return true;
     }
 }