jarbler 0.3.4 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d00ae03fa03fd70f85ce56da587974f9f2a5645ff977beb6c2a4e9188e92ce53
-  data.tar.gz: 7b1b592f4459f728b3838eaa6d40b9f60a78350413f8bbe34fe59c7160fd23ef
+  metadata.gz: 1496bf31678cf15945cd367d656a6717df35552c3deacf4e44d0f0d8267e26a0
+  data.tar.gz: 401efdc3ab67e9e913de4550ea108dc13899ececc0ab1b14267451e731803159
 SHA512:
-  metadata.gz: d4ca329fcd32d2833608ffff76dfecb923dacc72cc1027ed661aa6e2572f2d2a8b026c364597b831107e0e069604bd48ad54af79d5253787007efeba67464b20
-  data.tar.gz: 24fab155519254614a9b0ca86477d01a6c5e25f7394c2b0545eac82a3c2989fe72408a6100dc256eba2e68ba580143f1c47431f3acda2028d766a2343ab0ae4e
+  metadata.gz: 39a464b266c5f06ebf2270e117ba0f81a7fae012c70d5a18737b89e72ab9c3f99ea44d0aa5d898e55b4381789a21e7b2c2e1a1abbc3e781a0d10da12f272cce2
+  data.tar.gz: 449426ef9a89c170efc469fc87ad179c2c89438580fac0cecbf19c6b06d7af048f0e345f3569aa46a6d4578ef3422602ea5f6acc84b3102544da8a43f7b4863c

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
+## [0.3.6] - 2025-03-31
+
+- remove temporary folder with extracted jar content after termination of Ruby code even if Ruby code terminates the JVM hard with 'exit' or 'System.exit'
+- provide exit code of Ruby code as exit code of the jar file execution
+
+## [0.3.5] - 2025-03-22
+
+- new config attribute "config.compile_java_version" allows control of setting for "javac -source and -target" for AOT compilation
+- fix typo with smart quotes in config.rb
+
 ## [0.3.4] - 2025-03-07
 
 - Warning if Ruby-specific environment variables (GEM_HOME etc.) are set which may cause malfunction of  app in jar file

data/README.md

@@ -53,16 +53,17 @@ To create a template config file with information about all the supported config
 The default configuration is focused on Ruby on Rails applications.<br>
 
 ### Configuration options
-| Option                  | Default value                                                                                              | Description                                                                                                                                                                                    |
-|-------------------------|------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| compile_ruby_files      | false                                                                                                      | Ahead of time compilation of all .rb files of the application to .class files. Onl the .class files are stored in the jar file. The Gem dependencies are not compiled. 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_from_compile   | []                                                                                                         | The files and dirs of the project to exclude from the compilation of .rb files. Paths specifies the location in the jar file (e.g. ["app_root/file.rb"] )                                      |
-| excludes                | ["tmp/cache", "tmp/pids", ...] (see generated template file for whole content)                             | The files and dirs of the project to exclude 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           | A valid JRuby version from file '.ruby-version' or the current most recent version of the Gem 'jruby-jars' | The version of the JRuby runtime to use                                                                                                                                                        |
+| Option                  | Default value                                                                                              | Description                                                                                                                                                                                                                                                                                              |
+|-------------------------|------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| compile_java_version    | none                                                                                                       | Java version the compiled .class files should be compatible with. Controls the target and source version of the Java compiler if compile_ruby_files=true (javac -source and -target). E.g. "1.8" for Java 8. If not set then it generates the class file version according to your current Java version. |
+| compile_ruby_files      | false                                                                                                      | Ahead of time compilation of all .rb files of the application to .class files. Only the .class files are stored in the jar file. The Gem dependencies are not compiled. Requires JRuby as Ruby environment at compile time.                                                                              |
+| 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_from_compile   | []                                                                                                         | The files and dirs of the project to exclude from the compilation of .rb files. Paths specifies the location in the jar file (e.g. ["app_root/file.rb"] )                                                                                                                                                |
+| excludes                | ["tmp/cache", "tmp/pids", ...] (see generated template file for whole content)                             | The files and dirs of the project to exclude 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           | A valid JRuby version from file '.ruby-version' or the current most recent version of the Gem 'jruby-jars' | The version of the JRuby runtime to use                                                                                                                                                                                                                                                                  |
 
 
 ## Troubleshooting

data/lib/jarbler/JarMain.java

@@ -33,6 +33,9 @@ import java.security.ProtectionDomain;
 
 class JarMain {
 
+    // declare as class variable to be used in addShutdownHook
+    private static URLClassLoader classLoader = null;
+
     // executed by java -jar <jar file name>
     public static void main(String[] args) {
         debug("Start java process in jar file "+jar_file_name());
@@ -113,7 +116,7 @@ class JarMain {
             create_bundle_config(app_root, gem_home);
 
             // Load the Jar file
-            URLClassLoader classLoader = new URLClassLoader(new URL[]{
+            classLoader = new URLClassLoader(new URL[]{
                 jrubyCoreFile.toURI().toURL(),
                 jrubyStdlibFile.toURI().toURL()
                 //new URL("file:/" + jrubyCoreFile.getAbsolutePath()),
@@ -159,19 +162,39 @@ class JarMain {
                 debug(" - " + arg);
             }
 
+            // Add code to execute at System.exit
+            // ensure cleanup of the temporary directory also at hard exit in Ruby code like 'exit' or 'System.exit'
+            Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+                debug("Execute shutdown hook");
+                try {
+                    if (classLoader != null) {
+                        // Free the JRuby jars to allow deletion of the temporary directory
+                        classLoader.close();
+                        classLoader = null; // Remove reference
+                        System.gc(); // Suggest garbage collection
+                    }
+                    // remove the temp directory newFolder if not DEBUG mode
+                    if (debug_active()) {
+                        System.out.println("DEBUG mode is active, temporary folder is not removed at process termination: "+ newFolder.getAbsolutePath());
+                    } else {
+                        deleteFolder(newFolder);
+                    }
+                } catch (Exception e) {
+                    System.err.println("Exception in shutdown hook: "+ e.getMessage());
+                    e.printStackTrace();
+                }
+            }));
+
             // call the method org.jruby.Main.main
             debug("Calling org.jruby.Main.main with: "+ mainArgs);
             mainMethod.invoke(null, (Object)mainArgs.toArray(new String[mainArgs.size()]));
-            // TODO: evaluate return value
         } catch (Exception e) {
             e.printStackTrace();
+            System.exit(1); // signal unsuccessful termination
         } finally {
-            // remove the temp directory newFolder if not DEBUG mode
-            if (System.getenv("DEBUG") != null) {
-                System.out.println("DEBUG mode is active, temporary folder is not removed at process termination: "+ newFolder.getAbsolutePath());
-            } else {
-                deleteFolder(newFolder);
-            }
+            // Called only if the JVM is not terminated by System.exit before, see addShutdownHook
+            // This code is not executed if called 'exit' or 'System.exit' in Ruby code before
+            debug("Applicaton finished in finalize block");
         }
     }
 
@@ -240,24 +263,32 @@ class JarMain {
 
     }
 
+    private static boolean debug_active() {
+        String debug = System.getenv("DEBUG");
+        return debug != null && debug.toUpperCase().equals("TRUE");
+    }
+
     private static void debug(String msg) {
-        if (System.getenv("DEBUG") != null) {
+        if (debug_active()) {
             System.err.println(msg);
         }
     }
 
-   private static void deleteFolder(File file){
-      for (File subFile : file.listFiles()) {
-         if(subFile.isDirectory()) {
-            deleteFolder(subFile);
-         } else {
-            subFile.delete();
-         }
-      }
-      file.delete();
+    private static void deleteFolder(File file) {
+        try
+        {
+            if (file.isDirectory()) {
+               File[] entries = file.listFiles();
+               for (File currentFile: entries) {
+                   deleteFolder(currentFile);
+               }
+            }
+            file.delete();
+        } catch(Throwable t) {
+            System.err.println("Could not DELETE file: " + file.getAbsolutePath() + " - " + t.getMessage());
+        }
     }
 
-
     private static void create_bundle_config(String app_root, String gem_path) throws IOException {
         File bundle_config = new File(app_root + File.separator + ".bundle");
         bundle_config.mkdir();

data/lib/jarbler/builder.rb

@@ -19,8 +19,12 @@ module Jarbler
       app_root = Dir.pwd
       debug "Project dir: #{app_root}"
 
+      source_and_target = if config.compile_java_version
+                            "-source #{config.compile_java_version} -target #{config.compile_java_version}"
+                          end
+
       ruby_minor_version = copy_jruby_jars_to_staging(staging_dir) # Copy the jruby jars to the staging directory
-      exec_command "javac -nowarn -Xlint:deprecation -source 8 -target 8 -d #{staging_dir} #{__dir__}/JarMain.java" # Compile the Java files
+      exec_command "javac -nowarn -Xlint:deprecation #{source_and_target} -d #{staging_dir} #{__dir__}/JarMain.java" # Compile the Java files
 
       # Copy the application project to the staging directory
       FileUtils.mkdir_p("#{staging_dir}/app_root")
@@ -308,6 +312,8 @@ module Jarbler
       # 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}"
+        puts "Mismatch between the JRuby versions used for compile and runtime is not supported by JRuby and may cause sudden errors"
+        raise "JRuby version mismatch: #{JRUBY_VERSION} != #{config.jruby_version}"
       end
 
       # Compile all .rb files in the current directory tree, but not in the gems directory

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, :compile_ruby_files, :excludes_from_compile
+    attr_accessor :jar_name, :includes, :excludes, :jruby_version, :executable, :executable_params, :compile_ruby_files, :excludes_from_compile, :compile_java_version
 
     CONFIG_FILE = 'config/jarble.rb'
     # create instance of Config class with defaults or from config file
@@ -31,9 +31,10 @@ module Jarbler
         puts "No configuration file found at #{File.join(Dir.pwd, CONFIG_FILE)}. Using default values."
       end
       puts "Used configuration values are:"
+      puts "  compile_java_version:     #{config.compile_java_version}" if config.compile_ruby_files
       puts "  compile_ruby_files:       #{config.compile_ruby_files}"
       puts "  excludes:                 #{config.excludes}"
-      puts "  excludes_from_compile:    #{config.excludes_from_compile}"
+      puts "  excludes_from_compile:    #{config.excludes_from_compile}" if config.compile_ruby_files
       puts "  executable:               #{config.executable}"
       puts "  executable_params:        #{config.executable_params}"
       puts "  includes:                 #{config.includes}"
@@ -45,6 +46,7 @@ module Jarbler
 
     def initialize
       @compile_ruby_files = false
+      @compile_java_version = nil # not specified by default
       @excludes = %w(tmp/cache tmp/pids tmp/sockets vendor/bundle vendor/cache vendor/ruby)
       @excludes_from_compile = []
       @executable = 'bin/rails'
@@ -86,6 +88,11 @@ module Jarbler
 # the original ruby files are not included in the jar file, so source code is not visible
 # config.compile_ruby_files = #{compile_ruby_files}
 
+# Java version the compiled .class files should be compatible with
+# controls the target and source version of the Java compiler (javac -source and -target)
+# if not set then it generates the class file version according to your current Java version
+# config.compile_java_version = '1.8'
+
 # Directories or files to exclude from the compilation if compile_ruby_files = true
 # The paths map to the final location of files or dirs in the jar file, e.g. config.excludes_from_compile = ['gems', 'app_root/app/models']
 # config.excludes_from_compile = #{excludes_from_compile}
@@ -153,7 +160,7 @@ module Jarbler
 
     # Avoid exception if using depprecated config attribute include_gems_to_compile
     def include_gems_to_compile=(_value)
-      puts "Configuration attribute 'include_gems_to_compile' is deprecated. Use 'excludes_from_compile = [\”gems\”]' instead."
+      puts "Configuration attribute 'include_gems_to_compile' is deprecated. Use 'excludes_from_compile = [\"gems\"]' instead."
     end
 
     def validate_values

data/lib/jarbler/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Jarbler
-  VERSION = "0.3.4"
-  VERSION_DATE = "2025-03-07"
+  VERSION = "0.3.6"
+  VERSION_DATE = "2025-03-31"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jarbler
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.6
 platform: ruby
 authors:
 - Peter Ramm
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-07 00:00:00.000000000 Z
+date: 2025-04-01 00:00:00.000000000 Z
 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'