jarbler 0.1.8 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5de0d62c0ac312179bc506c3cda49ed463e72e11e9d0c153551fc90ce8aa2fee
-  data.tar.gz: 94c1e161336e09cf9e4188819298ee7dbffd6702b1b6d3909993911a5ae886c8
+  metadata.gz: 97f5261d55e15e23454414413af5f467bfdf5c2554916574269d6fa99f4a411a
+  data.tar.gz: 5a77de393585a7fa444157ebc2e7835d6d39e2e0e004ade0f840d9f2f9abcff9
 SHA512:
-  metadata.gz: 18f5af166aaa6a994521cfdf6efee1ddbbd5f70f40a04a2288095d9de83e54e3767b26e3321426d06622efcc9fd62e5962e8b6638dc6786de0d82d25180fb739
-  data.tar.gz: 7c3d03389ea1f41ab4e45e4988f0eae8e9fdb061bdf787922c27464ef46486c08543e3b2cad9ad8a862ba6e74f01629c776ad401a9a5ea2e1721c46a506a314e
+  metadata.gz: ad30f274db2a26f844df82f295b95f9bdcd9a023f35bbc83a6d2b7ec44b77a4dd0b8ca5ca66bb3f46818acf927d2e72efefb0f8b2669b058f5f51b9dacdb6d49
+  data.tar.gz: e07c531aa6082b3d186d2d3687d6a784b9b07593f4145e4d51bdd28247f57c710a35ed15196c18a0d3cb5a9f503808b242833709780b71442e0f293de1fe0db4

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [0.2.1] - 2024-06-13
+
+- Ruby files remain originally in jar if compile fails for a single file. 
+- Gems are compiled only if include_gems_to_compile=true
+
+## [0.2.0] - 2024-06-12
+
+- Add ahead of time compilation support for JRuby
+
 ## [0.1.6] - 2023-06-19
 
 - Bugfix: Do not clone default gems, because they are already included in the jruby jars standard library

data/README.md

@@ -4,8 +4,8 @@ Pack a Ruby application into an executable jar file.
 
 Jarbler creates a self executing Java jar file containing a Ruby application and all its Gem dependencies.
 
-This tool is inspired by the widely used jRuby runner Warbler. 
-The configured Ruby program is directly executed inside the JVM using the jRuby runtime jars.
+This tool is inspired by the widely used JRuby runner Warbler. 
+The configured Ruby program is directly executed inside the JVM using the JRuby runtime jars.
 
 ## Installation
 
@@ -31,7 +31,7 @@ To adjust Jarbler's configuration, modify the settings in config file ´config/j
 
 ### Preconditions
 * Dependency handling should be based on Bundler (existence of Gemfile is required)
-* The Ruby app should be capable of running with jRuby
+* The Ruby app should be capable of running with JRuby
 * Gems with native extensions should not be used (e.g. sassc)
   * if needed for development or test such Gems with native extensions should be moved to the development and test group in the Gemfile.
   * Otherwise the created jar file may not be executable on all platforms and Java versions.
@@ -50,22 +50,24 @@ To create a template config file with information about all the supported config
 
     $ jarble config
 
-The default configuration if focused on Ruby on Rails applications.<br>
+The default configuration is focused on Ruby on Rails applications.<br>
 
 ### Configuration options
-| Option            | Default value                                                                  | Description                                                         |
-|-------------------|--------------------------------------------------------------------------------|---------------------------------------------------------------------|
-| executable        | "bin/rails"                                                                    | The ruby file to run at execution of jar file                       |
-| executable_params | ["server", "-e", "production", "-p", "8080"]                                   | Command line parameters to be used for the ruby executable          |
-| excludes          | ["tmp/cache", "tmp/pids", ...] (see generated template file for whole content) | The files and dirs of the project to exlude from the include option |
-| includes          | ["app", "bin", "config", ...] (see generated template file for whole content)  | The files and dirs of the project to include in the jar file        |
-| jar_name          | &lt; Name of project dir &gt;.jar                                              | The name of the generated jar file                                  |
-| jruby_version     | The current most recent jRuby version                                          | The version of the jRuby runtime to use                             |
+| Option                  | Default value                                                                  | Description                                                                                                                                             |
+|-------------------------|--------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------|
+| compile_ruby_files      | false                                                                          | Ahead of time compilation of all .rb files of application and Gem dependencies to .class files. Only store .class files in jar. Requires JRuby runtime. |
+| executable              | "bin/rails"                                                                    | The ruby start file to run at execution of jar file. File extension .class is used automatically if start file is .rb and AOT compilation is used.      |
+| executable_params       | ["server", "-e", "production", "-p", "8080"]                                   | Command line parameters to be used for the ruby executable                                                                                              |
+| excludes                | ["tmp/cache", "tmp/pids", ...] (see generated template file for whole content) | The files and dirs of the project to exlude from the include option                                                                                     |
+| include_gems_to_compile | false                                                                          | Should .rb files of the project gems also be compiled if compile_ruby_files = true                                                                      |
+| includes                | ["app", "bin", "config", ...] (see generated template file for whole content)  | The files and dirs of the project to include in the jar file                                                                                            |
+| jar_name                | &lt; Name of project dir &gt;.jar                                              | The name of the generated jar file                                                                                                                      |
+| jruby_version           | The current most recent JRuby version                                          | The version of the JRuby runtime to use                                                                                                                 |
 
 
 ## Troubleshooting
 * Set DEBUG=true in environment to get additional runtime information
-* The temporary folder with the extracted app and jRuby runtime files is not deleted after execution if DEBUG is set.
+* The temporary folder with the extracted app and JRuby runtime files is not deleted after execution if DEBUG is set.
 
 ### Possible error messages
 * Gem::LoadError: You have already activated ..., but your Gemfile requires ... . Since ... is a default gem, you can either remove your dependency on it or try updating to a newer version of bundler that supports net-protocol as a default gem.

data/jarbler.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.email = ["Peter@ramm-oberhermsdorf.de"]
 
   spec.summary = "Pack a Ruby app into a Java jar file"
-  spec.description = "Pack a Ruby app combined with jRuby runtime and all its Gem dependencies into a jar file to simply run the app on any Java platform by '> java -jar file.jar'"
+  spec.description = "Pack a Ruby app combined with JRuby runtime and all its Gem dependencies into a jar file to simply run the app on any Java platform by '> java -jar file.jar'"
   spec.homepage = "https://github.com/rammpeter/jarbler"
   spec.license = "MIT"
   spec.required_ruby_version = ">= 2.6.0"

data/lib/jarbler/JarMain.java

@@ -87,6 +87,13 @@ class JarMain {
             executable = prop.getProperty("jarbler.executable");
             executable_params = prop.getProperty("jarbler.executable_params");
 
+            Boolean compile_ruby_files = Boolean.parseBoolean(prop.getProperty("jarbler.compile_ruby_files", "false"));
+            if (compile_ruby_files) {
+              debug("Set system property jruby.aot.loadClasses = true");
+              // ensure that .class files are loaded at require time if rb files are not present
+              System.setProperty("jruby.aot.loadClasses", "true");
+            }
+
             // throw exception if executable is null
             if (executable == null) {
                 throw new RuntimeException("Property 'executable' definition missing in jarbler.properties");
@@ -129,12 +136,12 @@ class JarMain {
                 }
             }
 
-            debug("jRuby program starts with the following arguments: ");
+            debug("JRuby program starts with the following arguments: ");
             for (String arg : mainArgs) {
                 debug(" - " + arg);
             }
 
-            debug("jRuby set property 'user.dir' to '" + app_root + "'");
+            debug("JRuby set property 'user.dir' to '" + app_root + "'");
             System.setProperty("user.dir", app_root);
             // call the method org.jruby.Main.main
             debug("Calling org.jruby.Main.main with: "+ mainArgs);

data/lib/jarbler/builder.rb

@@ -49,6 +49,7 @@ module Jarbler
             java_executable_params += "#{param} "
           end
           file.write("jarbler.executable_params=#{java_executable_params.strip}\n")
+          file.write("jarbler.compile_ruby_files=#{config.compile_ruby_files}\n")
         end
 
         # remove files and directories from excludes, if they exist (after copying the rails project and the gems)
@@ -62,6 +63,8 @@ module Jarbler
           end
         end
 
+        compile_ruby_files if config.compile_ruby_files
+
         exec_command "jar cfm #{config.jar_name} Manifest.txt *" # create the jar file
 
         # place the jar in project directory
@@ -202,7 +205,7 @@ module Jarbler
 
     # Copy the jruby-jars to the staging directory
     # @param [String] staging_dir Path to the staging directory
-    # @return [String] the minor ruby version of the jRuby jars with patch level set to 0
+    # @return [String] the minor ruby version of the JRuby jars with patch level set to 0
     def copy_jruby_jars_to_staging(staging_dir)
 
       # Ensure that jruby-jars gem is installed, otherwise install it. Accepts also bundler path in .bundle/config
@@ -211,7 +214,7 @@ module Jarbler
       raise "jruby-jars gem not installed in version #{config.jruby_version}" if installed.empty?
 
       jruby_jars_location = installed[0]&.full_gem_path
-      debug "jRuby jars installed at: #{jruby_jars_location}"
+      debug "JRuby jars installed at: #{jruby_jars_location}"
 
       # Get the location of the jruby-jars gem
       # spec = Gem::Specification.find_by_name('jruby-jars', config.jruby_version)
@@ -220,14 +223,14 @@ module Jarbler
       file_utils_copy("#{jruby_jars_location}/lib/jruby-core-#{config.jruby_version}-complete.jar", staging_dir)
       file_utils_copy("#{jruby_jars_location}/lib/jruby-stdlib-#{config.jruby_version}.jar", staging_dir)
 
-      # Get the according Ruby version for the current jRuby version
+      # Get the according Ruby version for the current JRuby version
       lines = exec_command "java -cp #{jruby_jars_location}/lib/jruby-core-#{config.jruby_version}-complete.jar org.jruby.Main --version"
       match_result = lines.match(/\(.*\)/)
-      raise "Could not determine Ruby version for jRuby #{config.jruby_version} in following output:\n#{lines}" unless match_result
+      raise "Could not determine Ruby version for JRuby #{config.jruby_version} in following output:\n#{lines}" unless match_result
       ruby_version = match_result[0].tr('()', '')
-      debug "Corresponding Ruby version for jRuby (#{config.jruby_version}): #{ruby_version}"
+      debug "Corresponding Ruby version for JRuby (#{config.jruby_version}): #{ruby_version}"
       ruby_minor_version = ruby_version.split('.')[0..1].join('.') + '.0'
-      debug "Corresponding Ruby minor version for jRuby (#{config.jruby_version}): #{ruby_minor_version}"
+      debug "Corresponding Ruby minor version for JRuby (#{config.jruby_version}): #{ruby_minor_version}"
       ruby_minor_version
     end
 
@@ -255,6 +258,38 @@ module Jarbler
       puts "Error copying #{source} to #{destination}"
       raise
     end
-  end
 
+    # Compile all Ruby files in the current directory (staging directory)
+    def compile_ruby_files
+      require 'jruby/jrubyc'
+
+      puts "Compiling all .rb files to .class files"
+      # Inform if used JRuby version is different from the intended runtime JRuby version
+      if JRUBY_VERSION != config.jruby_version
+        puts "Compiling .rb files to .class is done with JRuby version #{JRUBY_VERSION}, but intended runtime JRuby version for jar file  is #{config.jruby_version}"
+      end
+
+      ruby_files = Find.find('.').select { |f| f =~ /\.rb$/ }                   # find all Ruby files in the current directory
+
+      if !config.include_gems_to_compile
+        ruby_files = ruby_files.select { |f| !(f =~ /\.#{File::SEPARATOR}gems#{File::SEPARATOR}/) } # Exclude ./gems/* directories from compiling
+      end
+
+      ruby_files.each do |ruby_file|
+        debug "Compile Ruby file #{ruby_file}"
+        full_file_name = File.join(Dir.pwd, ruby_file)                          # full name including path is required by the JRuby compiler
+        begin
+          status = JRuby::Compiler::compile_argv([full_file_name])              # compile the Ruby file
+          if status == 0
+            File.delete(full_file_name)                                         # remove the original Ruby file to ensure that the compiled class file is used
+          else
+            raise "Return status != 0"
+          end
+        rescue Exception => e
+          puts "Error compiling Ruby file '#{ruby_file}': #{e.class}:#{e.message}"
+          puts "'#{ruby_file}' is not compiled and will be included in the jar file as original Ruby file"
+        end
+      end
+    end
+  end
 end

data/lib/jarbler/config.rb

@@ -3,7 +3,7 @@ require 'json'
 
 module Jarbler
   class Config
-    attr_accessor :jar_name, :includes, :excludes, :jruby_version, :executable, :executable_params
+    attr_accessor :jar_name, :includes, :excludes, :jruby_version, :executable, :executable_params, :compile_ruby_files, :include_gems_to_compile
 
     CONFIG_FILE = 'config/jarble.rb'
     # create instance of Config class with defaults or from config file
@@ -19,16 +19,22 @@ module Jarbler
         config = Config.new
       end
       config.define_jruby_version
+      # Replace .rb with .class if compile_ruby_files is true
+      config.executable = config.executable.sub(/\.rb$/, '.class') if config.compile_ruby_files
+
+      config.validate_values
       config
     end
 
     def initialize
-      @jar_name = File.basename(Dir.pwd) + '.jar'
-      @includes = %w(app bin config config.ru db Gemfile Gemfile.lock lib log public Rakefile script vendor tmp)
+      @compile_ruby_files = false
       @excludes = %w(tmp/cache tmp/pids tmp/sockets vendor/bundle vendor/cache vendor/ruby)
-      @jruby_version = nil  # determined automatically at runtime
       @executable = 'bin/rails'
       @executable_params = %w(server -e production -p 8080)
+      @include_gems_to_compile = false
+      @includes = %w(app bin config config.ru db Gemfile Gemfile.lock lib log public Rakefile script vendor tmp)
+      @jar_name = File.basename(Dir.pwd) + '.jar'
+      @jruby_version = nil  # determined automatically at runtime
       # execute additional block if given
       yield self if block_given?
     end
@@ -47,9 +53,9 @@ module Jarbler
 # config.excludes = #{excludes}
 # config.excludes << 'additional'
 
-# Use certail jRuby version
+# Use certain JRuby version
 # if not set (nil) then the version defined in .ruby-version
-# if not jRuby version defined here or in .ruby-version then the latest available jRuby version is used
+# if not JRuby version defined here or in .ruby-version then the latest available JRuby version is used
 # config.jruby_version = '9.2.3.0'
 # config.jruby_version = nil
 
@@ -58,6 +64,14 @@ module Jarbler
 
 # Additional command line parameters for the Ruby executable
 # config.executable_params = #{executable_params}
+
+# Compile the ruby files of the project to Java .class files with JRuby's ahead-of-time compiler?
+# the original ruby files are not included in the jar file, so source code is not visible
+# config.compile_ruby_files = #{compile_ruby_files}
+
+# Compile also the .rb files of the gems of the project to Java .class files?
+# config.include_gems_to_compile = #{include_gems_to_compile}
+
       ".split("\n"))
     end
 
@@ -83,15 +97,15 @@ module Jarbler
       puts "Jarbler: Created config file #{Dir.pwd}/#{CONFIG_FILE}"
     end
 
-    # define jRuby version if not set in config file
+    # define JRuby version if not set in config file
     def define_jruby_version
       unless @jruby_version # not defined in config file
         if File.exist?('.ruby-version')
           # read the file RAILS_ROOT/.ruby-version starting from char at position 6 to the end of the line
           self.jruby_version = File.read('.ruby-version')[6..20].strip
-          debug "jRuby version from .ruby-version file: #{jruby_version}"
+          debug "JRuby version from .ruby-version file: #{jruby_version}"
         else
-          # no .ruby-version file, use jRuby version of the latest Gem
+          # no .ruby-version file, use JRuby version of the latest Gem
           # Fetch the gem specification from Rubygems.org
           # search for the gem and get the JSON response
           response = Gem::SpecFetcher.fetcher.search_for_dependency(Gem::Dependency.new('jruby-jars'))
@@ -105,7 +119,7 @@ module Jarbler
           #jruby_jars_line = lines.match(/^jruby-jars \((.*)\)/)
           #raise "No jruby-jars gem found in rubygems.org!" unless jruby_jars_line
           #self.jruby_version = /\((.*?)\)/.match(jruby_jars_line.to_s)[1]
-          debug "jRuby version from latest jruby-jars gem: #{jruby_version}"
+          debug "JRuby version from latest jruby-jars gem: #{jruby_version}"
         end
       end
     end
@@ -113,5 +127,16 @@ module Jarbler
     def debug(msg)
       puts msg if ENV['DEBUG']
     end
+
+    def validate_values
+      raise "Invalid config value for jar name: #{jar_name}" unless jar_name =~ /\w+/
+      raise "Invalid config value for executable: #{executable}" unless executable =~ /\w+/
+      raise "Invalid config value for executable params: #{executable_params}" unless executable_params.is_a?(Array)
+      raise "Invalid config value for includes: #{includes}" unless includes.is_a?(Array)
+      raise "Invalid config value for excludes: #{excludes}" unless excludes.is_a?(Array)
+      raise "Invalid config value for compile_ruby_files: #{compile_ruby_files}" unless [true, false].include?(compile_ruby_files)
+      raise "compile_ruby_files = true is supported only with JRuby! Current runtime is '#{RUBY_ENGINE}'" if compile_ruby_files && (defined?(RUBY_ENGINE) && RUBY_ENGINE != 'jruby')
+      raise "include_gems_to_compile = true is supported only if compile_ruby_files = true!" if include_gems_to_compile && !compile_ruby_files
+    end
   end
 end

data/lib/jarbler/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Jarbler
-  VERSION = "0.1.8"
-  VERSION_DATE = "2024-03-04"
+  VERSION = "0.2.1"
+  VERSION_DATE = "2024-06-13"
 end

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: jarbler
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.2.1
 platform: ruby
 authors:
 - Peter Ramm
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-03-04 00:00:00.000000000 Z
+date: 2024-06-13 00:00:00.000000000 Z
 dependencies: []
-description: Pack a Ruby app combined with jRuby runtime and all its Gem dependencies
+description: Pack a Ruby app combined with JRuby runtime and all its Gem dependencies
   into a jar file to simply run the app on any Java platform by '> java -jar file.jar'
 email:
 - Peter@ramm-oberhermsdorf.de
@@ -42,7 +42,7 @@ metadata:
   homepage_uri: https://github.com/rammpeter/jarbler
   source_code_uri: https://github.com/rammpeter/jarbler
   changelog_uri: https://github.com/rammpeter/jarbler/CHANGELOG.md
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -57,8 +57,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
-signing_key:
+rubygems_version: 3.3.27
+signing_key: 
 specification_version: 4
 summary: Pack a Ruby app into a Java jar file
 test_files: []