jarbler 0.3.2 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d57d186383ffc6bf5de8396b10fa81aa47947bedb96f36ef67d4cbecef2ca2fb
-  data.tar.gz: 64c3888a99ec67bbf0e4ac0c3c85a5d2f8cd042a84403ad879a02476c8c62a80
+  metadata.gz: 2b0f184ae1d09ac0464ed7c607600571e77873ae91a1aa2c20578856cd2b8404
+  data.tar.gz: 0dce28c9d7e4856d5903da84f8ea4f5ec5f173931fe4fca6ec5e8e849bbcbc4b
 SHA512:
-  metadata.gz: 4ef50f2616b885cca428943bcc6baf4d0db106da0e7620339981378ef2321ccd6b336c7c992a10531e670b6c63baa80d14f37512e8890b9136593047267adbcb
-  data.tar.gz: f4b1644168cdc90c5314b65cf616b1d096bec65888de485b490744f68b9577867c9a3625f8dbc7e443c11c7b57ea125210ce45a159f3e8ad477f559d8610f910
+  metadata.gz: 7b4383469571b3ce72c7e97123f8a8a0b25834848970921ae84dd445f3ea9268fec77193b796dddd2444831d5854e477d13d912de9d962fea3bcdd74ecb9d56d
+  data.tar.gz: dfcfdd76de3397adabb0e8677c09dedc112486387addeca59f8b85b50b40f8d7230c337b61c191f2d2752eb1cf9514011905579818add6665cce66dc38db0b66

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [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
+- Accept jar file locations with blanks in the path, especially for Windows
+- Setting `compile_ruby_files=true` compiles only .rb file of the application, but does not compile the .rb files in Gems.<br/>
+  Compiling the Gems also remains an open task.
+- Bugfix: Accept spaces in the path to the jar file, especially for Windows
+
 ## [0.3.1] - 2024-07-02
 
 - Use file .ruby-version to define the JRuby version for the jar file only if .ruby-version contains a valid jRuby version

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 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_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

@@ -10,6 +10,7 @@ import java.util.jar.JarFile;
 import java.util.jar.JarInputStream;
 import java.util.jar.JarOutputStream;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Properties;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;
@@ -42,26 +43,28 @@ class JarMain {
                 debug(" - " + arg);
             }
         }
+
         // create a new folder in temp directory
         File newFolder = new File(System.getProperty("java.io.tmpdir") + File.separator + UUID.randomUUID().toString());
         newFolder.mkdir();
+
         try {
-            // Get the path of the jar file
-            String jarPath = JarMain.class.getProtectionDomain().getCodeSource().getLocation().getPath();
-
-            // remove the leading slash if path is a windows path
-            String os = System.getProperty("os.name").toLowerCase();
-            boolean isWindows = os.contains("windows");
-            if (os.contains("windows") && jarPath.startsWith("/") && jarPath.indexOf(':') != -1) {
-                jarPath = jarPath.substring(1); // remove the leading slash
-            }
 
-            // get the absolute path of the jar file, especially if it contains spaces in Windows
-            String aboluteJarPath = new File(jarPath).getAbsolutePath();
+            // Ensure that environment does not inject external dependencies
+            checkEnvForToxicEntries();
+
+            // Get the path of the jar file with valid characters for spaces etc., especially for Windows
+            URL jarPathUrl = JarMain.class.getProtectionDomain().getCodeSource().getLocation();
+
+            // Convert the URL to a URI, then to a File
+            File jarFile = new File(jarPathUrl.toURI());
+
+            // Get the absolute path of the file
+            String jarPath = jarFile.getAbsolutePath();
 
             // extract the jarFile by unzipping it (not using the jar utility which may not be available)
-            System.out.println("Extracting files from "+aboluteJarPath+" to "+ newFolder.getAbsolutePath());
-            unzip(aboluteJarPath, newFolder.getAbsolutePath());
+            System.out.println("Extracting files from "+jarPath+" to "+ newFolder.getAbsolutePath());
+            unzip(jarPath, newFolder.getAbsolutePath());
 
             String app_root = newFolder.getAbsolutePath()+File.separator+"app_root";
 
@@ -87,8 +90,9 @@ class JarMain {
 
             Properties prop = new Properties();
             prop.load(new FileInputStream(newFolder.getAbsolutePath()+File.separator+"jarbler.properties"));
-            executable = prop.getProperty("jarbler.executable");
-            executable_params = prop.getProperty("jarbler.executable_params");
+            executable          = prop.getProperty("jarbler.executable");
+            executable_params   = prop.getProperty("jarbler.executable_params");
+            String gem_home_suffix     = prop.getProperty("jarbler.gem_home_suffix");
 
             Boolean compile_ruby_files = Boolean.parseBoolean(prop.getProperty("jarbler.compile_ruby_files", "false"));
             if (compile_ruby_files) {
@@ -102,8 +106,11 @@ class JarMain {
                 throw new RuntimeException("Property 'executable' definition missing in jarbler.properties");
             }
 
+            // single path to the gems directory
+            String gem_home = newFolder.getAbsolutePath()+File.separator+"gems";
+
             // create the bundle config file with the path of the gems
-            create_bundle_config(app_root, newFolder.getAbsolutePath()+File.separator+"gems");
+            create_bundle_config(app_root, gem_home);
 
             // Load the Jar file
             URLClassLoader classLoader = new URLClassLoader(new URL[]{
@@ -112,7 +119,6 @@ class JarMain {
                 //new URL("file:/" + jrubyCoreFile.getAbsolutePath()),
                 //new URL("file:/" + jrubyStdlibFile.getAbsolutePath())
             });
-
             // Load the class
             Class<?> clazz = classLoader.loadClass("org.jruby.Main");
 
@@ -139,16 +145,24 @@ class JarMain {
                 }
             }
 
+            debug("JRuby set property 'user.dir' to '" + app_root + "'");
+            System.setProperty("user.dir", app_root);
+
+            // GEM_HOME not explicitely set because this is done by Bundle.setup based on the .bundle/config file
+            // Setting GEM_HOME explicitely may cause problems with the JRuby runtime (Gem::GemNotFoundException: can't find gem bundler (= 2.6.3) with executable bundle)
+            //String full_gem_home = gem_home + File.separator + gem_home_suffix.replace("/", File.separator);
+            //debug("JRuby set property 'jruby.gem.home' to '" + full_gem_home + "'");
+            //System.setProperty("jruby.gem.home", full_gem_home);
+
             debug("JRuby program starts with the following arguments: ");
             for (String arg : mainArgs) {
                 debug(" - " + arg);
             }
 
-            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);
             mainMethod.invoke(null, (Object)mainArgs.toArray(new String[mainArgs.size()]));
+            // TODO: evaluate return value
         } catch (Exception e) {
             e.printStackTrace();
         } finally {
@@ -228,7 +242,7 @@ class JarMain {
 
     private static void debug(String msg) {
         if (System.getenv("DEBUG") != null) {
-            System.out.println(msg);
+            System.err.println(msg);
         }
     }
 
@@ -269,4 +283,38 @@ class JarMain {
         }
         return jarFileName;
     }
+
+    /**
+     * Check environment for entries that may inluence execution of Ruby code.
+     * @param errorSummary The current error summary
+     */
+    private static void checkEnvForToxicEntries(){
+        StringBuilder errorSummary = new StringBuilder("");
+        String toxicEntries[] = {
+            "BUNDLE_BIN_PATH",
+            "BUNDLE_GEMFILE",
+            "BUNDLER_SETUP",
+            "BUNDLER_VERSION",
+            "GEM_HOME",
+            "GEM_PATH",
+            "RUBYLIB",
+            "RUBYOPT",
+            "RUBYPATH",
+            "RUBYSHELL"
+        };
+
+        Arrays.stream(toxicEntries).forEach(entry -> {
+            String envVal = System.getenv(entry);
+            if (envVal != null) {
+                errorSummary.append("Found environment variable '"+entry+"' with value '"+envVal+"'\n");
+                debug("Possibly toxic environment variable found: '"+entry+"'! Remove it from environment before execution of jar file if it causes errors.");
+            }
+        });
+
+        if (!errorSummary.toString().isEmpty()){
+            System.err.println("The follwing environment variables may influence the execution of the packaged Ruby code.");
+            System.err.println("Please remove this environment entries before the execution of the jar file if they cause errors.");
+            System.err.println(errorSummary);
+        }
+    }
 }

data/lib/jarbler/builder.rb

@@ -4,6 +4,7 @@ require 'bundler'
 require 'find'
 require 'fileutils'
 require 'yaml'
+require 'open3'
 
 module Jarbler
   class Builder
@@ -18,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")
@@ -50,6 +55,7 @@ module Jarbler
           end
           file.write("jarbler.executable_params=#{java_executable_params.strip}\n")
           file.write("jarbler.compile_ruby_files=#{config.compile_ruby_files}\n")
+          file.write("jarbler.gem_home_suffix=jruby/#{ruby_minor_version}\n")  # Extension after BUNDLE_PATH for local Gems
         end
 
         # remove files and directories from excludes, if they exist (after copying the rails project and the gems)
@@ -86,30 +92,20 @@ module Jarbler
 
     private
 
-
-    # Check if there is an additional local bundle path in .bundle/config
-    # @param rails_root [String] the rails root directory
-    # @return [String] the local bundle path or nil if not configured
-    def bundle_config_bundle_path(rails_root)
-      bundle_path = nil # default
-      if File.exist?("#{rails_root}/.bundle/config")
-        bundle_config = YAML.load_file("#{rails_root}/.bundle/config")
-        if bundle_config && bundle_config['BUNDLE_PATH']
-          bundle_path = "#{rails_root}/#{bundle_config['BUNDLE_PATH']}"
-          debug "Local Gem path configured in #{rails_root}/.bundle/config: #{bundle_path}"
-        end
-      end
-      bundle_path
-    end
-
     # Copy the needed Gems to the staging directory
     # @param staging_dir [String] the staging directory
     # @param ruby_minor_version [String] the corresponding ruby minor version of the jruby jars version
     # @return [void]
     def copy_needed_gems_to_staging(staging_dir, ruby_minor_version)
       gem_target_location = "#{staging_dir}/gems/jruby/#{ruby_minor_version}"
+      FileUtils.mkdir_p("#{gem_target_location}/bin")
+      FileUtils.mkdir_p("#{gem_target_location}/build_info")
+      FileUtils.mkdir_p("#{gem_target_location}/cache")
+      FileUtils.mkdir_p("#{gem_target_location}/doc")
+      FileUtils.mkdir_p("#{gem_target_location}/extensions")
       FileUtils.mkdir_p("#{gem_target_location}/gems")
       FileUtils.mkdir_p("#{gem_target_location}/specifications")
+      FileUtils.mkdir_p("#{gem_target_location}/bundler/bin")
       FileUtils.mkdir_p("#{gem_target_location}/bundler/gems")
 
       needed_gems = gem_dependencies  # get the full names of the dependencies
@@ -123,21 +119,34 @@ module Jarbler
         if spec.source.is_a?(Bundler::Source::Git)
           # Copy the Gem from bundler/gems including the gemspec
           file_utils_copy(spec.gem_dir, "#{gem_target_location}/bundler/gems")
+          spec.executables.each do |executable|
+            file_utils_copy("#{spec.bin_dir}/#{executable}", "#{gem_target_location}/bundler/bin")
+          end
         else  # Gem is from rubygems
+          # TODO: Gemfile could request a different version of default gem compared to the one jruby jars
+          #       Should the default gems are also copied to the staging directory?
           unless spec.default_gem?  # Do not copy default gems, because they are already included in the jruby jars standard library
             # copy the Gem and gemspec separately
             file_utils_copy(spec.gem_dir, "#{gem_target_location}/gems")
-            file_utils_copy("#{spec.gem_dir}/../../specifications/#{needed_gem[:full_name]}.gemspec", "#{gem_target_location}/specifications")
+            # spec.loaded_from contains the path to the gemspec file including the path prefix "default/" for default gems
+            file_utils_copy(spec.loaded_from, "#{gem_target_location}/specifications")
+            spec.executables.each do |executable|
+              file_utils_copy("#{spec.bin_dir}/#{executable}", "#{gem_target_location}/bin")
+            end
           end
         end
       end
+    rescue Exception => e
+      debug("Builder.copy_needed_gems_to_staging: Failed with staging dir = '#{staging_dir}' and ruby minor version = #{ruby_minor_version} with #{e.class}\n#{e.message}")
+      raise
     end
 
     # Read the default/production dependencies from Gemfile.lock and Gemfile
     # @return [Array] Array with Hashes containing: name, version, full_name
     def gem_dependencies
       needed_gems = []
-      lockfile_specs = Bundler::LockfileParser.new(Bundler.read_file(Bundler.default_lockfile)).specs
+      lockfile_parser = Bundler::LockfileParser.new(Bundler.read_file(Bundler.default_lockfile))
+      lockfile_specs = lockfile_parser.specs
 
       Bundler.setup # Load Gems specified in Gemfile, ensure that Gem path also includes the Gems loaded into bundler dir
       # filter Gems needed for production
@@ -156,10 +165,18 @@ module Jarbler
           debug "Direct Gem dependency: #{lockfile_spec.full_name}"
           add_indirect_dependencies(lockfile_specs, lockfile_spec, needed_gems)
         else
-          debug "Gem #{gemfile_spec.name} not found in Gemfile.lock"
+          if gemfile_spec.name == 'bundler'
+            debug "Gem bundler found in Gemfile.lock but not in specs, use version #{Bundler::VERSION}"
+            needed_gems << { full_name: "bundler-#{lockfile_parser.bundler_version}", name: 'bundler', version: lockfile_parser.bundler_version }
+          else
+            debug "Gem #{gemfile_spec.name} not found in specs: in Gemfile.lock"
+          end
         end
       end
-      needed_gems.uniq.sort{|a,b| a[:full_name] <=> b[:full_name]}
+      needed_gems.uniq.sort{|a,b| a[:full_name] <=> b[:full_name]}              # full_name also contains version
+    rescue Exception => e
+      debug("Builder.gem_dependencies: Failed with #{e.class}\n#{e.message}")
+      raise
     end
 
     # recurively find all indirect dependencies
@@ -180,13 +197,16 @@ module Jarbler
           debug "Gem #{lockfile_spec_dep.name} not found in Gemfile.lock"
         end
       end
+    rescue Exception => e
+      debug("Builder.add_indirect_dependencies: Failed with #{e.class}\n#{e.message}")
+      raise
     end
 
     # Output debug message if DEBUG environment variable is set
     # @param [String] msg Message to output
     # @return [void]
     def debug(msg)
-      puts msg if ENV['DEBUG']
+      puts "#{Time.now.strftime('%Y-%m-%d %H:%M:%S')} #{msg}" if ENV['DEBUG']
     end
 
     # Get the config object
@@ -201,6 +221,9 @@ module Jarbler
        debug ""
       end
       @config
+    rescue Exception => e
+      debug("Builder.config: Failed with #{e.class}\n#{e.message}")
+      raise
     end
 
     # Copy the jruby-jars to the staging directory
@@ -208,12 +231,26 @@ module Jarbler
     # @return [String] the minor ruby version of the JRuby jars with patch level set to 0
     def copy_jruby_jars_to_staging(staging_dir)
 
+      debug "Copying JRuby Jars to staging dir: #{staging_dir}"
       # Ensure that jruby-jars gem is installed, otherwise install it. Accepts also bundler path in .bundle/config
-      installer = Gem::DependencyInstaller.new
-      installed = installer.install('jruby-jars', config.jruby_version)
+      installed = nil                                                           # ensure that installed is defined outside of the block
+      tries = 5
+      tries.times do |try|
+        begin
+          installer = Gem::DependencyInstaller.new
+          installed = installer.install('jruby-jars', config.jruby_version)
+          break                                                               # escape loop if successful
+        rescue Exception, RuntimeError => e
+          debug "Builder.copy_jruby_jars_to_staging: Failed to install jruby-jars #{try}. try with #{e.class}\n#{e.message}"
+          raise if try == tries - 1                                           # last try not successful
+          sleeptime = 5
+          debug "Builder.copy_jruby_jars_to_staging: Waiting #{sleeptime} seconds to prevent from Gem::RemoteFetcher::FetchError: IOError: closed stream"
+          sleep sleeptime                                                     # wait x seconds before next try
+        end
+      end
       raise "jruby-jars gem not installed in version #{config.jruby_version}" if installed.empty?
 
-      jruby_jars_location = installed[0]&.full_gem_path
+      jruby_jars_location = installed[0]&.full_gem_path                         # need to be the first installed Gem
       debug "JRuby jars installed at: #{jruby_jars_location}"
 
       # Get the location of the jruby-jars gem
@@ -232,16 +269,24 @@ module Jarbler
       ruby_minor_version = ruby_version.split('.')[0..1].join('.') + '.0'
       debug "Corresponding Ruby minor version for JRuby (#{config.jruby_version}): #{ruby_minor_version}"
       ruby_minor_version
+    rescue Exception => e
+      debug "Builder.copy_jruby_jars_to_staging: Failed to copy JRuby jars to staging dir '#{jruby_jars_location}' with #{e.class}\n#{e.message}"
+      debug "Stack trace of exception:\n#{e.backtrace.join("\n")}"
+      raise
     end
 
     # Execute the command in OS and return the output
     # @param [String] command Command to execute
     # @return [String] the output of the command
     def exec_command(command)
-      lines = `#{command}`
-      raise "Command \"#{command}\"failed with return code #{$?} and output:\n#{lines}" unless $?.success?
-      debug "Command \"#{command}\" executed successfully with following output:\n#{lines}"
-      lines
+      debug("Execute by Open3.capture3: #{command}")
+      stdout, stderr, status = Open3.capture3(command)
+      debug "Command \"#{command}\" executed with return code #{status}!\nstdout:\n#{stdout}\n\nstderr:\n#{stderr}\n"
+      raise "Command \"#{command}\" failed with return code #{status}!\nstdout:\n#{stdout}\n\nstderr:\n#{stderr}\n" unless status.success?
+      "stdout:\n#{stdout}\nstderr:\n#{stderr}\n"
+    rescue Exception => e
+      debug "Builder.exec_command: Failed to execute command '#{command}' with #{e.class}\n#{e.message}"
+      raise
     end
 
     # Copy file or directory with error handling
@@ -254,8 +299,8 @@ module Jarbler
       else
         FileUtils.cp(source, destination)
       end
-    rescue Exception
-      puts "Error copying #{source} to #{destination}"
+    rescue Exception => e
+      debug "Builder.file_utils_copy: Failed to copy '#{source}' to '#{destination}' with #{e.class}\n#{e.message}"
       raise
     end
 
@@ -267,9 +312,12 @@ 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
 
-      ruby_files = Find.find('.').select { |f| f =~ /\.rb$/ }                   # find all Ruby files in the current directory
+      # Compile all .rb files in the current directory tree, but not in the gems directory
+      ruby_files = Find.find('.').select { |f| f =~ /\.rb$/ && !f.include?("#{File::SEPARATOR}gems#{File::SEPARATOR}") }                   # find all Ruby files in the current directory
 
       # Exclude named files or directories from compiling
       config.excludes_from_compile.each do |exclude|
@@ -291,6 +339,9 @@ module Jarbler
           puts "'#{ruby_file}' is not compiled and will be included in the jar file as original Ruby file"
         end
       end
+    rescue Exception => e
+      puts "Builder.compile_ruby_files: Failed to compile Ruby files with #{e.class}\n#{e.message}"
+      raise
     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, :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}
@@ -143,12 +150,6 @@ module Jarbler
         @jruby_version = response&.first&.first&.first&.version&.to_s
         raise "Unable to determine the latest available version of jruby-jars gem!\nResponse = #{response.inspect}" unless @jruby_version
 
-        #command = "gem search --remote jruby-jars"
-        #lines = `#{command}`
-        #raise "Command \"#{command}\" failed with return code #{$?} and output:\n#{lines}" unless $?.success?
-        #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 "Jarbler::Config.define_jruby_version: JRuby version from latest jruby-jars gem: #{jruby_version}"
       end
     end
@@ -159,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.2"
-  VERSION_DATE = "2025-03-01"
+  VERSION = "0.3.5"
+  VERSION_DATE = "2025-03-22"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jarbler
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.5
 platform: ruby
 authors:
 - Peter Ramm
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-01 00:00:00.000000000 Z
+date: 2025-03-22 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'
@@ -34,6 +34,7 @@ files:
 - lib/jarbler/builder.rb
 - lib/jarbler/config.rb
 - lib/jarbler/version.rb
+- log/.keep
 - sig/jarbler.rbs
 homepage: https://github.com/rammpeter/jarbler
 licenses: