puck 1.0.0.pre1 → 1.0.0.pre2

data/lib/puck/bootstrap.rb

@@ -1,10 +1,12 @@
 if ARGV.any?
   file_name = ARGV.shift
-  bootstrap_path = __FILE__.sub('jar-bootstrap.rb', "META-INF/app.home/bin/#{file_name}")
-  begin
-    load(bootstrap_path)
-  rescue LoadError => e
-    abort(e.message)
+  PUCK_BIN_PATH.each do |dir|
+    path = __FILE__.sub('jar-bootstrap.rb', File.join(dir, file_name))
+    if File.exists?(path)
+      load(path)
+      return
+    end
   end
+  abort(%(No "#{file_name}" in #{PUCK_BIN_PATH.join(File::PATH_SEPARATOR)}))
 end
  

data/lib/puck/configuration.rb

@@ -4,6 +4,7 @@ require 'optparse'
 
 
 module Puck
+  # @private
   class Configuration
     def initialize(defaults={})
       @argv = defaults[:argv] || ARGV

data/lib/puck/jar.rb

@@ -14,15 +14,70 @@ rescue LoadError
 end
 
 module Puck
+  # Creates a standalone Jar file from your application.
+  #
+  # The Jar will contain your application code (which is assumed to be in the
+  # "lib" directory), bin files (assumed to be in the "bin" directory), all the
+  # gems in your default group (i.e. those that are not in a `group` block in
+  # your Gemfile), including gems loaded from git, or from a path. It will also
+  # contain a JRuby runtime so that to run it you only need a Java runtime.
+  #
+  # The Jar file will be configured so that you can run your application's bin
+  # files by passing their name as the first argument after the Jar file (see example below).
+  #
+  # @example Creating a Jar from a Rake task
+  #   task :jar do
+  #     Puck::Jar.new.create!
+  #   end
+  #
+  # @example Configuring the Jar file
+  #   task :jar do
+  #     jar = Puck::Jar.new(
+  #       extra_files: Dir['config/*.yml'],
+  #       jruby_complete: 'build/custom-jruby-complete.jar'
+  #     )
+  #     jar.create!
+  #   end
+  #
+  # @example Running a bin file
+  #     java -jar path/to/application.jar my-bin-file arg1 arg2
+  #
   class Jar
+    # Create a new instance with the specified configuration.
+    #
+    # Puck tries to use sane defaults like assuming that the application name
+    # is the same as the name of the directory containing the "lib" directory.
+    #
+    # @param [Hash] configuration
+    # @option configuration [String] :extra_files a list of files to include in
+    #   the Jar. The paths must be below the `:app_dir`.
+    # @option configuration [String] :gem_groups ([:default]) a list of gem
+    #   groups to include in the Jar. Remember to include the default group if
+    #   you override this option.
+    # @option configuration [String] :jruby_complete a path to the
+    #   `jruby-complete.jar` that you want to use. If you don't specify this
+    #   option you need to have `jruby-jars` in your `Gemfile` (it contains
+    #   the equivalent of `jruby-complete.jar`. This option is mostly useful
+    #   when you have a customized JRuby runtime that you want to use.
+    # @option configuration [String] :app_dir (Dir.pwd)
+    #   the application's base directory (i.e. the directory that contains the
+    #   "lib" directory)
+    # @option configuration [String] :app_name (File.basename(configuration[:app_dir]))
+    #   the name of the application, primarily used to name the Jar
+    # @option configuration [String] :build_dir ("build") the directory where
+    #   the Jar file will be created
+    #
     def initialize(configuration={})
       @configuration = configuration.dup
       @configuration[:app_dir] ||= Dir.pwd
       @configuration[:app_name] ||= File.basename(@configuration[:app_dir])
       @configuration[:build_dir] ||= File.join(@configuration[:app_dir], 'build')
       @configuration[:jar_name] ||= @configuration[:app_name] + '.jar'
+      @configuration[:gem_groups] ||= [:default]
     end
 
+    # Create the Jar file using the instance's configuration.
+    #
     def create!
       FileUtils.mkdir_p(@configuration[:build_dir])
 
@@ -33,7 +88,7 @@ module Puck
         jruby_complete_path = @configuration[:jruby_complete]
 
         if !(defined? JRubyJars) && !(jruby_complete_path && File.exists?(jruby_complete_path))
-          raise ArgumentError, 'Cannot build Jar: jruby-jars must be installed, or :jruby_complete must be specified'
+          raise PuckError, 'Cannot build Jar: jruby-jars must be installed, or :jruby_complete must be specified'
         end
 
         gem_dependencies = resolve_gem_dependencies
@@ -56,12 +111,12 @@ module Puck
           end
 
           %w[bin lib].each do |sub_dir|
-            zipfileset dir: project_dir + sub_dir, prefix: "META-INF/app.home/#{sub_dir}"
+            zipfileset dir: project_dir + sub_dir, prefix: File.join(JAR_APP_HOME, sub_dir)
           end
 
           extra_files.each do |ef|
             path = Pathname.new(ef).expand_path.cleanpath
-            prefix = 'META-INF/app.home/' + path.relative_path_from(project_dir).dirname.to_s
+            prefix = File.join(JAR_APP_HOME, path.relative_path_from(project_dir).dirname.to_s)
             zipfileset dir: path.dirname, prefix: prefix, includes: path.basename
           end
 
@@ -72,10 +127,16 @@ module Puck
       end
     end
 
+    private
+
+    JAR_APP_HOME = 'META-INF/app.home'.freeze
+    JAR_GEM_HOME = 'META-INF/gem.home'.freeze
+    JAR_JRUBY_HOME = 'META-INF/jruby.home'.freeze
+
     def resolve_gem_dependencies
       gem_specs = Bundler::LockfileParser.new(File.read('Gemfile.lock')).specs.group_by(&:name)
       definition = Bundler::Definition.build('Gemfile', 'Gemfile.lock', false)
-      dependencies = definition.dependencies.select { |d| d.groups.include?(:default) }.map(&:name)
+      dependencies = definition.dependencies.select { |d| (d.groups & @configuration[:gem_groups]).any? }.map(&:name)
       specs = resolve_gem_specs(gem_specs, dependencies)
       specs = specs.map do |bundler_spec|
         case bundler_spec.source
@@ -91,14 +152,16 @@ module Puck
           gem_spec = Gem::Specification.load(gemspec_path)
           load_paths = gem_spec.load_paths.map do |load_path|
             index = load_path.index(gem_spec.full_name)
-            'META-INF/gem.home/' + load_path[index, load_path.length - index]
+            File.join(JAR_GEM_HOME, load_path[index, load_path.length - index])
           end
+          bin_path = File.join(JAR_GEM_HOME, gem_spec.full_name, gem_spec.bindir)
           {
             :name => gem_spec.name,
             :versioned_name => gem_spec.full_name,
             :base_path => base_path,
-            :jar_path => "META-INF/gem.home/#{gem_spec.full_name}",
-            :load_paths => load_paths
+            :jar_path => File.join(JAR_GEM_HOME, gem_spec.full_name),
+            :load_paths => load_paths,
+            :bin_path => bin_path,
           }
         else
           nil
@@ -117,6 +180,11 @@ module Puck
 
     def create_jar_bootstrap!(tmp_dir, gem_dependencies)
       File.open(File.join(tmp_dir, 'jar-bootstrap.rb'), 'w') do |io|
+        io.puts(%(PUCK_BIN_PATH = ['/#{JAR_APP_HOME}/bin', '/#{JAR_JRUBY_HOME}/bin']))
+        gem_dependencies.each do |spec|
+          io.puts("PUCK_BIN_PATH << '/#{spec[:bin_path]}'")
+        end
+        io.puts
         gem_dependencies.each do |spec|
           spec[:load_paths].each do |load_path|
             io.puts(%($LOAD_PATH << 'classpath:#{load_path}'))

data/lib/puck/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Puck
-  VERSION = '1.0.0.pre1'.freeze
+  VERSION = '1.0.0.pre2'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: puck
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre1
+  version: 1.0.0.pre2
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-07-19 00:00:00.000000000 Z
+date: 2013-07-20 00:00:00.000000000 Z
 dependencies: []
 description: Puck takes your app and packs it along with all your gems and a complete JRuby runtime in a standalone Jar file that can be run with just `java -jar …`
 email:
@@ -53,3 +53,4 @@ signing_key:
 specification_version: 3
 summary: Packs your JRuby app as a standalone Jar file
 test_files: []
+has_rdoc: