puck 1.0.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1d3c8ed8c414ffb5241dd8dd7b903686ea9d1bf5
+  data.tar.gz: 67e2972eaafcac0792998786d3d65b96942dc4f2
+SHA512:
+  metadata.gz: 32db0d6f29e15a77dc05cb24078c18333c1bf2de228ee1bf8b5fcd113c1eab0c1a4308d972411b6690e1f6da2f2b828376e704d94eba27e63cdcc0c4a20b89cd
+  data.tar.gz: 9fd222f28c53f4d6f61a4532b14d56cbd077d09efccdd68b05a334f891084e930cf541ac6e97d989bf4d6e0fe6637d8d6b0fe0daa50f8f59e82c52e1b0fa3fe9

data/.yardopts

@@ -0,0 +1,4 @@
+--no-private
+--markup markdown
+lib/**/*.rb
+-- README

data/bin/puck

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require 'puck'
+
+
+Puck::Jar.new(Puck::Configuration.get).create

data/lib/puck.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+
+module Puck
+  PuckError = Class.new(StandardError)
+  GemNotFoundError = Class.new(PuckError)
+end
+
+require 'puck/configuration'
+require 'puck/dependency_resolver'
+require 'puck/jar'

data/lib/puck/bootstrap.rb

@@ -0,0 +1,12 @@
+if ARGV.any?
+  file_name = ARGV.shift
+  PUCK_BIN_PATH.each do |dir|
+    relative_path = File.join(dir, file_name)
+    if File.exists?("classpath:/#{relative_path}")
+      $0 = relative_path
+      load(relative_path)
+      return
+    end
+  end
+  abort(%(No "#{file_name}" in #{PUCK_BIN_PATH.join(File::PATH_SEPARATOR)}))
+end

data/lib/puck/configuration.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+require 'optparse'
+
+
+module Puck
+  # @private
+  class Configuration
+    def initialize(defaults={})
+      @argv = defaults[:argv] || ARGV
+    end
+
+    def self.get(defaults={})
+      new(defaults).get
+    end
+
+    def get
+      command_line_options
+    end
+
+    private
+
+    SCALAR_ARGS = [:app_name, :app_dir, :build_dir, :jruby_complete].freeze
+    LIST_ARGS = [:extra_files].freeze
+    ARG_PREFIX = '--'.freeze
+
+    def command_line_options
+      state = nil
+      option = nil
+      @argv.each_with_object({}) do |arg, options|
+        if arg.start_with?(ARG_PREFIX)
+          option = arg.sub(/^--/, '').gsub('-', '_').to_sym
+          if LIST_ARGS.include?(option)
+            options[option] = []
+            state = :list
+          else
+            state = :scalar
+          end
+        else
+          case state
+          when :list
+            options[option] << arg
+          when :scalar
+            options[option] = arg
+            option = nil
+            state = nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/puck/dependency_resolver.rb

@@ -0,0 +1,75 @@
+require 'stringio'
+require 'bundler'
+
+module Puck
+  # @private
+  class DependencyResolver
+    def resolve_gem_dependencies(options = {})
+      gem_home = options[:gem_home] || ENV['GEM_HOME']
+      gemfile = options[:gemfile] || File.expand_path('Gemfile', options[:app_dir] || Dir.pwd)
+      lockfile = options[:lockfile] || "#{gemfile}.lock"
+      groups = options[:gem_groups] || [:default]
+
+      bundler_specs = contained_bundler(gem_home, gemfile, lockfile, groups)
+      bundler_specs.delete_if { |spec| spec[:name] == 'bundler' }
+      bundler_specs.map do |spec|
+        base_path = spec[:full_gem_path].chomp('/')
+        load_paths = spec[:load_paths].map do |load_path|
+          unless load_path.start_with?(base_path)
+            raise PuckError, 'Unsupported load path "%s" in gem "%s"' % [load_path, bundler_spec.name]
+          end
+          load_path[base_path.size + 1, load_path.length - base_path.size - 1]
+        end
+        {
+          :name => spec[:name],
+          :versioned_name => spec[:full_name],
+          :base_path => base_path,
+          :load_paths => load_paths,
+          :bin_path => spec[:bindir],
+        }
+      end
+    end
+
+    private
+
+    def contained_bundler(gem_home, gemfile, lockfile, groups)
+      Bundler.with_clean_env do
+        scripting_container = Java::OrgJrubyEmbed::ScriptingContainer.new(Java::OrgJrubyEmbed::LocalContextScope::SINGLETHREAD)
+        scripting_container.compat_version = Java::OrgJruby::CompatVersion::RUBY1_9
+        scripting_container.current_directory = Dir.pwd
+        scripting_container.environment = Hash[ENV.merge('GEM_HOME' => gem_home).map { |k,v| [k.to_java, v.to_java] }]
+        scripting_container.put('arguments', Marshal.dump([gemfile, lockfile, groups]).to_java_bytes)
+        begin
+          line = __LINE__ + 1 # as __LINE__ represents next statement line i JRuby, and that becomes difficult to offset
+          unit = scripting_container.parse(StringIO.new(<<-"EOS").to_inputstream, __FILE__, line)
+            begin
+              require 'bundler'
+              gemfile, lockfile, groups = Marshal.load(String.from_java_bytes(arguments))
+              definition = Bundler::Definition.build(gemfile, lockfile, false)
+              ENV['BUNDLE_WITHOUT'] = (definition.groups - groups).join(':')
+              specs = definition.specs.map do |gem_spec|
+                {
+                  :name => gem_spec.name,
+                  :full_name => gem_spec.full_name,
+                  :full_gem_path => gem_spec.full_gem_path,
+                  :load_paths => gem_spec.load_paths,
+                  :bindir => gem_spec.bindir,
+                }
+              end
+              Marshal.dump([specs]).to_java_bytes
+            rescue => e
+              Marshal.dump([nil, e.class, e.message, e.backtrace]).to_java_bytes
+            end
+          EOS
+          result, error, message, backtrace = Marshal.load(String.from_java_bytes(unit.run))
+          if error
+            raise error, message, Array(backtrace)+caller
+          end
+          result
+        ensure
+          scripting_container.terminate
+        end
+      end
+    end
+  end
+end

data/lib/puck/jar.rb

@@ -0,0 +1,168 @@
+# encoding: utf-8
+
+require 'fileutils'
+require 'tmpdir'
+require 'pathname'
+require 'set'
+require 'ant'
+require 'puck/version'
+
+begin
+  require 'jruby-jars'
+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]
+      @dependency_resolver = @configuration[:dependency_resolver] || DependencyResolver.new
+    end
+
+    # Create the Jar file using the instance's configuration.
+    #
+    # @return The path to the Jar file
+    #
+    def create
+      FileUtils.mkdir_p(@configuration[:build_dir])
+
+      Dir.mktmpdir do |tmp_dir|
+        output_path = File.join(@configuration[:build_dir], @configuration[:jar_name])
+        project_dir = Pathname.new(@configuration[:app_dir]).expand_path.cleanpath
+        extra_files = @configuration[:extra_files] || []
+        jruby_complete_path = @configuration[:jruby_complete]
+
+        if !(defined? JRubyJars) && !(jruby_complete_path && File.exists?(jruby_complete_path))
+          raise PuckError, 'Cannot build Jar: jruby-jars must be installed, or :jruby_complete must be specified'
+        end
+
+        gem_dependencies = @dependency_resolver.resolve_gem_dependencies(@configuration)
+        create_jar_bootstrap!(tmp_dir, gem_dependencies)
+
+        ant = Ant.new(output_level: 1)
+        ant.jar(destfile: output_path) do
+          manifest do
+            attribute name: 'Main-Class', value: 'org.jruby.JarBootstrapMain'
+            attribute name: 'Created-By', value: "Puck v#{Puck::VERSION}"
+          end
+
+          zipfileset dir: tmp_dir, includes: 'jar-bootstrap.rb'
+
+          if jruby_complete_path
+            zipfileset src: jruby_complete_path
+          else
+            zipfileset src: JRubyJars.core_jar_path
+            zipfileset src: JRubyJars.stdlib_jar_path
+          end
+
+          %w[bin lib].each do |sub_dir|
+            path = project_dir + sub_dir
+            if File.exists?(path)
+              zipfileset dir: path, prefix: File.join(JAR_APP_HOME, sub_dir)
+            end
+          end
+
+          extra_files.each do |ef|
+            path = Pathname.new(ef).expand_path.cleanpath
+            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
+
+          gem_dependencies.each do |spec|
+            base_path = Pathname.new(spec[:base_path]).expand_path.cleanpath
+            unless project_dir == base_path
+              zipfileset dir: spec[:base_path], prefix: File.join(JAR_GEM_HOME, spec[:versioned_name])
+            end
+          end
+        end
+
+        output_path
+      end
+    end
+
+    # @deprecated Use #create
+    def create!
+      create
+    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 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 << '#{JAR_GEM_HOME}/#{spec[:versioned_name]}/#{spec[:bin_path]}'")
+        end
+        io.puts
+        gem_dependencies.each do |spec|
+          spec[:load_paths].each do |load_path|
+            io.puts(%($LOAD_PATH << 'classpath:#{JAR_GEM_HOME}/#{spec[:versioned_name]}/#{load_path}'))
+          end
+        end
+        io.puts
+        io.puts(File.read(File.expand_path('../bootstrap.rb', __FILE__)))
+      end
+    end
+  end
+end

data/lib/puck/version.rb

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

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: puck
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: java
+authors:
+- Theo Hultberg
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-02-12 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:
+- theo@iconara.net
+executables:
+- puck
+extensions: []
+extra_rdoc_files: []
+files:
+- .yardopts
+- bin/puck
+- lib/puck.rb
+- lib/puck/bootstrap.rb
+- lib/puck/configuration.rb
+- lib/puck/dependency_resolver.rb
+- lib/puck/jar.rb
+- lib/puck/version.rb
+homepage: http://github.com/iconara/puck
+licenses:
+- Apache License 2.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: puck
+rubygems_version: 2.2.2
+signing_key:
+specification_version: 4
+summary: Packs your JRuby app as a standalone Jar file
+test_files: []
+has_rdoc: