jarbler 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bc9683c3fba322e4476646046c54b7c61ae7b6fa3d4c9865d1223fad0db590ee
+  data.tar.gz: 5e64e298302111c5fbcc606c8aad86ba93b454daece192318c33b3eca6696ccb
+SHA512:
+  metadata.gz: 0edc420a59cb4e48364c0155c0cee0f2449b32264de8f3967cf790b82df541a367d7206b4a5dbf0461561be9e88fee79d8ba7bdc737d6ca2eda951a97cc5e0d9
+  data.tar.gz: 4e7d227903baacaaf8960f333c9f3beaee96dd5c399a45ab724620af04fbdfcbb5ed1ccce9a1955907d563ce2888b1d9a0b174dc2dadb85d557960e30ca7608c

data/.ruby-version

@@ -0,0 +1 @@
+ruby-3.2.2

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-04-12
+
+- Initial release

data/Gemfile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in jarbler.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+group(:test)  do
+  gem 'minitest'
+  gem 'minitest-reporters'
+  # needed for minitests
+  gem 'jruby-jars'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Peter Ramm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+# Jarbler
+Pack a Ruby application into an executable jar file.
+
+Jarbler allows you to create an self executing Java jar file containing your Ruby application.
+
+This tool is inspired by the widely used jRuby runner Warbler. 
+In contrast to Warbler no Java servlet container is needed for execution.
+Instead the configured executable is executed using the jRuby runtime jars.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add jarbler --group "development"
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install jarbler
+
+## Usage
+
+To create a jar file simply run "jarble" in your application's root directory.
+
+    $ jarble
+    
+To adjust Jarbler's configuration, modify the settings in config file ´config/jarble.rb´. The template for this config file you create by executing
+
+    $ jarble config
+
+### Preconditions
+* 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.
+
+## Run the created jar file
+The jar file created by Jarbler can be executed by
+
+    $ java -jar <jar filename>
+    
+Additional command line parameters are passed through to the executed Ruby app (like "-p 8900" for different network port number with bin/rails)
+
+## Configuration
+
+The file config/jarble.rb contains the configuration for Jarbler. 
+To create a template config file with information about the supported configuration options, execute:
+
+    $ jarble config
+
+The default configuration supports Ruby on Rails applications.<br>
+The executable is set to "bin/rails" by default.<br>
+The default executable parameters are  "server -p 8080 -e production".
+
+## Troubleshooting
+* Set DEBUG=true in environment to get additional runtime information
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/rammpeter/jarbler. <br>
+Any feedback about usage experience or missing features is also appreciated.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+task default: %i[]
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end

data/bin/jarble

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'jarbler'
+
+# call config if arguments are passed and argument = 'config'
+# otherwise call Jarbler.run
+if ARGV.empty?
+  Jarbler.run
+else
+  if  ARGV[0] == 'config' && ARGV.length == 1
+    Jarbler.config
+  else
+    puts "Invalid argument! Valid arguments are:"
+    puts "- no argument: build the jar"
+    puts "- config: create a template config file at #{Jarbler::Config::CONFIG_FILE}"
+  end
+end
+

data/build_gem.sh

@@ -0,0 +1,18 @@
+# Steps for creating gem
+rake test
+if [ $? -ne 0 ]; then
+  echo "Tests failed."
+  exit 1
+fi
+
+gem build
+if [ $? -ne 0 ]; then
+  echo "Gem build failed."
+  exit 1
+fi
+
+gem install jarbler-0.1.0.gem
+if [ $? -ne 0 ]; then
+  echo "Gem install failed."
+  exit 1
+fi

data/jarbler.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "lib/jarbler/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "jarbler"
+  spec.version = Jarbler::VERSION
+  spec.authors = ["Peter Ramm"]
+  spec.email = ["Peter@ramm-oberhermsdorf.de"]
+
+  spec.summary = "Create jar file from Rails app"
+  spec.description = "Pack a Rails application into an executable jar file"
+  spec.homepage = "https://github.com/rammpeter/jarbler"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+  
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/rammpeter/jarbler"
+  spec.metadata["changelog_uri"] = "https://github.com/rammpeter/jarbler/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor])
+    end
+  end
+  spec.bindir = "bin"
+  spec.executables << 'jarble'
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/jarbler/JarMain.java

@@ -0,0 +1,209 @@
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Enumeration;
+import java.util.UUID;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.jar.JarInputStream;
+import java.util.jar.JarOutputStream;
+import java.util.ArrayList;
+import java.util.Properties;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Constructor;
+import java.net.MalformedURLException;
+import java.lang.ClassNotFoundException;
+import java.lang.NoSuchMethodException;
+import java.lang.IllegalAccessException;
+import java.lang.InstantiationException;
+
+
+class JarMain {
+
+    // executed by java -jar <jar file name>
+    // No arguments are passed
+    public static void main(String[] args) {
+        debug("Start java process in jar file");
+        if (args.length > 0) {
+            debug("Java command line arguments are: ");
+            for (String arg : args) {
+                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
+            }
+
+            // extract the jarFile by executing jar -xf jarFileName
+            System.out.println("Extracting files from "+jarPath+" to "+ newFolder.getAbsolutePath());
+            unzip(jarPath, newFolder.getAbsolutePath());
+
+
+            // get the file name of the jruby jar file in newFolder
+            File[] files = newFolder.listFiles();
+            // get the existing file from files where prefix is jruby-core* and suffix is .jar
+            File jrubyCoreFile = null;
+            File jrubyStdlibFile = null;
+            for (File file : files) {
+                if (file.getName().startsWith("jruby-core") && file.getName().endsWith(".jar")) {
+                    jrubyCoreFile = file;
+                }
+                if (file.getName().startsWith("jruby-stdlib") && file.getName().endsWith(".jar")) {
+                    jrubyStdlibFile = file;
+                }
+            }
+            debug("jruby core jar file is  : "+ jrubyCoreFile.getAbsolutePath());
+            debug("jruby stdlib jar file is: "+ jrubyStdlibFile.getAbsolutePath());
+
+            // read the property file and get the port number
+            String executable = "Executable definition missing";    // Default if nothing else is specified
+            String executable_params = "";
+
+            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");
+
+            // throw exception if executable is null
+            if (executable == null) {
+                throw new RuntimeException("Property 'executable' definition missing in jarbler.properties");
+            }
+
+            System.setProperty("GEM_PATH", newFolder.getAbsolutePath()+File.separator+"gems");      // not really necessray for Rails
+            System.setProperty("GEM_HOME", newFolder.getAbsolutePath()+File.separator+"gems");      // not really necessray for Rails
+            System.setProperty("BUNDLE_PATH", newFolder.getAbsolutePath()+File.separator+"gems");   // this drives bundler for rails app
+            System.setProperty("BUNDLE_WITHOUT", "test:development");  // exclude test and development dependencies from Gemfile check
+
+            // Load the Jar file
+            URLClassLoader classLoader = new URLClassLoader(new URL[]{
+                new URL("file://" + jrubyCoreFile.getAbsolutePath()),
+                new URL("file://" + jrubyStdlibFile.getAbsolutePath())
+            });
+
+            // Load the class
+            Class<?> clazz = classLoader.loadClass("org.jruby.Main");
+
+            // Get the method
+            Method mainMethod = clazz.getMethod("main", String[].class);
+
+            // Create an instance of the class
+            Constructor<?> constructor = clazz.getConstructor();
+            Object instance = (Object) constructor.newInstance();
+            //Object instance = clazz.newInstance();
+
+            // Prepare the argument list
+            ArrayList<String> mainArgs = new ArrayList<String>();
+            mainArgs.add(executable);
+            if (executable_params != null) {
+                for (String param : executable_params.split(" ")) {
+                    mainArgs.add(param);
+                }
+            }
+            // add possible command line arguments
+            if (args.length > 0) {
+                for (String arg : args) {
+                    mainArgs.add(arg);
+                }
+            }
+
+            debug("jRuby program starts with the following arguments: ");
+            for (String arg : mainArgs) {
+                debug(" - " + arg);
+            }
+
+            System.setProperty("user.dir", newFolder.getAbsolutePath()+File.separator+"app_root");
+            // call the method org.jruby.Main.main
+            mainMethod.invoke(null, (Object)mainArgs.toArray(new String[mainArgs.size()]));
+        } catch (Exception e) {
+            e.getCause().printStackTrace();
+        } finally {
+            // remove the temp directory newFolder
+            debug("jRuby program terminated, removing temporary folder "+ newFolder.getAbsolutePath());
+            deleteFolder(newFolder);
+        }
+    }
+
+    private static void unzip(String fileZip, String destination) throws IOException {
+        File destDir = new File(destination);
+
+        byte[] buffer = new byte[1024];
+        ZipInputStream zis = new ZipInputStream(new FileInputStream(fileZip));
+        ZipEntry zipEntry = zis.getNextEntry();
+        while (zipEntry != null) {
+            while (zipEntry != null) {
+                File newFile = newFile(destDir, zipEntry);
+                if (zipEntry.isDirectory()) {
+                    if (!newFile.isDirectory() && !newFile.mkdirs()) {
+                        throw new IOException("Failed to create directory " + newFile);
+                    }
+                } else {
+                    // fix for Windows-created archives
+                    File parent = newFile.getParentFile();
+                    if (!parent.isDirectory() && !parent.mkdirs()) {
+                        throw new IOException("Failed to create directory " + parent);
+                    }
+
+                    // write file content
+                    FileOutputStream fos = new FileOutputStream(newFile);
+                    int len;
+                    while ((len = zis.read(buffer)) > 0) {
+                        fos.write(buffer, 0, len);
+                    }
+                    fos.close();
+                }
+                zipEntry = zis.getNextEntry();
+            }
+        }
+
+        zis.closeEntry();
+        zis.close();
+    }
+
+    private static File newFile(File destinationDir, ZipEntry zipEntry) throws IOException {
+        File destFile = new File(destinationDir, zipEntry.getName());
+
+        String destDirPath = destinationDir.getCanonicalPath();
+        String destFilePath = destFile.getCanonicalPath();
+
+        if (!destFilePath.startsWith(destDirPath + File.separator)) {
+            throw new IOException("Entry is outside of the target dir: " + zipEntry.getName());
+        }
+
+        return destFile;
+    }
+
+    private static void debug(String msg) {
+        if (System.getenv("DEBUG") != null) {
+            System.out.println(msg);
+        }
+    }
+
+   private static void deleteFolder(File file){
+      for (File subFile : file.listFiles()) {
+         if(subFile.isDirectory()) {
+            deleteFolder(subFile);
+         } else {
+            subFile.delete();
+         }
+      }
+      file.delete();
+    }
+
+}

data/lib/jarbler/builder.rb

@@ -0,0 +1,256 @@
+require 'bundler'
+require 'find'
+require 'fileutils'
+
+module Jarbler
+  class Builder
+    # Execute all functions needed to build the jar file
+    # Should be executed in application directory of Rails/Ruby application
+    # @return [void]
+    def build_jar
+      # create a temporary directory for staging
+      staging_dir = Dir.mktmpdir
+
+      jarbler_lib_dir = __dir__
+      app_root = Dir.pwd
+      debug "Project dir: #{app_root}"
+
+      # TODO: transform to internal bundler API call (check if jruby is installed + install if not)
+      exec_command  "gem install --no-doc jruby-jars -v #{config.jruby_version}" # Ensure that jruby-jars are installed in the requested version
+      gem_search_locations = collect_gem_search_locations(app_root)
+      ruby_version = copy_jruby_jars_to_staging(staging_dir, gem_search_locations) # Copy the jruby jars to the staging directory
+      exec_command "javac -nowarn -Xlint:deprecation -source 8 -target 8 -d #{staging_dir} #{jarbler_lib_dir}/JarMain.java" # Compile the Java files
+
+      # Copy the application project to the staging directory
+      FileUtils.mkdir_p("#{staging_dir}/app_root")
+      config.includes.each do |dir|
+        file_utils_copy("#{app_root}/#{dir}", "#{staging_dir}/app_root") if File.exist?("#{app_root}/#{dir}")
+      end
+
+      # Get the needed Gems
+      raise "Gemfile.lock not found in #{app_root}" unless File.exist?("#{app_root}/Gemfile.lock")
+
+      gem_target_location = "#{staging_dir}/gems/jruby/#{ruby_version}"
+      FileUtils.mkdir_p("#{gem_target_location}/gems")
+      FileUtils.mkdir_p("#{gem_target_location}/specifications")
+
+      needed_gems = gem_dependencies  # get the full names of the dependencies
+      needed_gems.each do |gem_full_name|
+        copy_gem_to_staging(gem_full_name, gem_target_location, gem_search_locations)
+      end
+
+      Dir.chdir(staging_dir) do
+        # create the manifest file
+        File.open('Manifest.txt', 'w') do |file|
+          file.write("Comment: created by Jarbler (https://github.com/rammpeter/jarbler)\n")
+          file.write("Main-Class: JarMain\n")
+        end
+
+        # Write java properties file for use in JarMain.java
+        File.open('jarbler.properties', 'w') do |file|
+          file.write("jarbler.executable=#{config.executable}\n")
+          # write a list of strings into property file delimited by space
+          java_executable_params = ''
+          config.executable_params.each do |param|
+            java_executable_params += "#{param} "
+          end
+          file.write("jarbler.executable_params=#{java_executable_params.strip}\n")
+        end
+
+        # remove files and directories from excludes, if they exist (after copying the rails project and the gems)
+        config.excludes.each do |exclude|
+          to_remove = "app_root/#{exclude}"
+          if File.exist?(to_remove)
+            debug "Removing #{to_remove} from staging directory"
+            FileUtils.rm_rf(to_remove)
+          else
+            debug "Not removing #{to_remove} from staging directory, because it does not exist"
+          end
+        end
+
+        exec_command "jar cfm #{config.jar_name} Manifest.txt *" # create the jar file
+
+        # place the jar in project directory
+        file_utils_copy(config.jar_name, app_root)
+        puts "Created jar file #{app_root}/#{config.jar_name}"
+      end
+
+      # remove temporary directory staging_dir
+      FileUtils.remove_entry staging_dir
+
+    end
+
+    private
+
+    # Find the locations where Gems are installed
+    # @param [String] app_root Application root directory
+    # @return [Array] Array of Gem locations
+    def collect_gem_search_locations(app_root)
+      # Search locations of gems in Gemfile.lock
+      possible_gem_search_locations = []
+      # Add possible local config first in search list
+      possible_gem_search_locations << bundle_config_bundle_path(app_root) if bundle_config_bundle_path(app_root)
+      ENV['GEM_PATH'].split(':').each do |gem_path|
+        possible_gem_search_locations << gem_path
+      end
+      debug "Possible Gem locations: #{possible_gem_search_locations}"
+      gem_search_locations = []
+      # Check where inside this location the gems may be installed
+      possible_gem_search_locations.each do |gem_search_location|
+        valid_gem_search_location = nil # No valid path found yet
+        Find.find(gem_search_location) do |path|
+          if File.directory?(path) && File.exist?("#{path}/specifications") && File.exist?("#{path}/gems")
+            valid_gem_search_location = path # Found a valid path
+            Find.prune # Do not search deeper
+          end
+        end
+        if valid_gem_search_location
+          gem_search_locations << valid_gem_search_location
+        else
+          debug "No valid gem location found in #{gem_search_location}"
+        end
+      end
+      debug "Valid Gem locations: #{gem_search_locations}"
+      gem_search_locations
+    end
+
+    # Copy the Gem elements to the staging directory
+    # @param [String] gem_full_name Full name of the Gem including version and platform
+    # @param [String] staging_dir Path to the staging directory
+    # @param [Array] gem_search_locations Array of Gem locations
+    # @return [void]
+    def copy_gem_to_staging(gem_full_name, gem_target_location, gem_search_locations)
+      gem_search_locations.each do |gem_search_location|
+        gem_dir = "#{gem_search_location}/gems/#{gem_full_name}"
+        if File.exist?(gem_dir)
+          file_utils_copy(gem_dir, "#{gem_target_location}/gems")
+          file_utils_copy("#{gem_search_location}/specifications/#{gem_full_name}.gemspec", "#{gem_target_location}/specifications")
+          return
+        end
+      end
+      raise "Gem #{gem_name} (#{gem_version}) not found in any of the following locations:\n#{gem_search_locations.join("\n")}"
+    end
+
+    # Read the default/production dependencies from Gemfile.lock and Gemfile
+    # @return [Array] Array with full names of dependencies
+    def gem_dependencies
+      needed_gems = []
+      lockfile_specs = Bundler::LockfileParser.new(Bundler.read_file(Bundler.default_lockfile)).specs
+
+      Bundler.setup # Load Gems specified in Gemfile
+      # filter Gems needed for production
+      gemfile_specs = Bundler.definition.dependencies.select do |d|
+        d.groups.include?(:default) || d.groups.include?(:production)
+      end
+
+      debug "Gems from Gemfile needed for production:"
+      gemfile_specs.each do |gemfile_spec|
+        # find lockfile record for Gemfile spec
+        lockfile_spec = lockfile_specs.find { |lockfile_spec| lockfile_spec.name == gemfile_spec.name }
+        if lockfile_spec
+          needed_gems << lockfile_spec.full_name unless needed_gems.include?(lockfile_spec.full_name)
+          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"
+        end
+      end
+      needed_gems.uniq.sort
+    end
+
+    # recurively find all indirect dependencies
+    # @param [Array] lockfile_specs Array of Bundler::LockfileParser::Spec objects
+    # @param [Bundler::LockfileParser::Spec] lockfile_spec current lockfile spec to check for their dependencies
+    # @param [Array] needed_gems Array with full names of already found dependencies, add findings here
+    # @return [void]
+    def add_indirect_dependencies(lockfile_specs, lockfile_spec, needed_gems)
+      lockfile_spec.dependencies.each do |lockfile_spec_dep|
+        lockfile_spec_found = lockfile_specs.find { |lockfile_spec| lockfile_spec.name == lockfile_spec_dep.name }
+        if lockfile_spec_found
+          debug "Indirect Gem dependency from #{lockfile_spec.full_name}: #{lockfile_spec_found.full_name}"
+          unless needed_gems.include?(lockfile_spec_found.full_name)
+            needed_gems << lockfile_spec_found.full_name
+            add_indirect_dependencies(lockfile_specs, lockfile_spec_found, needed_gems)
+          end
+        else
+          debug "Gem #{lockfile_spec_dep.name} not found in Gemfile.lock"
+        end
+      end
+    end
+    def debug(msg)
+      puts msg if ENV['DEBUG']
+    end
+
+    def config
+      unless defined? @config
+       @config = Config.create
+       debug("Config attributes:")
+       @config.instance_variables.each do |var|
+         debug("#{var}: #{@config.instance_variable_get(var)}")
+       end
+       debug ""
+      end
+      @config
+    end
+
+    # Check if there is an additional local bundle path in .bundle/config
+    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 jruby-jars to the staging directory
+    # @param [String] staging_dir Path to the staging directory
+    # @param [Array] gem_search_locations Array of Gem locations to look for jRuby jars
+    # @return [String] the ruby version of the jRuby jars
+    def copy_jruby_jars_to_staging(staging_dir, gem_search_locations)
+      jruby_jars_location = nil
+      gem_search_locations.each do |gem_search_location|
+        gem_dir = "#{gem_search_location}/gems/jruby-jars-#{config.jruby_version}"
+        if File.exist?(gem_dir)
+          jruby_jars_location = gem_dir
+          break
+        end
+      end
+      raise "Could not determine location of jRuby jars for release '#{config.jruby_version}' in the following output:\n#{lines}" unless jruby_jars_location
+      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
+      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
+      ruby_version = match_result[0].tr('()', '')
+      debug "Corresponding Ruby version for jRuby (#{config.jruby_version}): #{ruby_version}"
+      ruby_version
+    end
+
+    # Execute the command and return the output
+    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
+    end
+
+    # Copy file or directory with error handling
+    def file_utils_copy(source, destination)
+      if File.exist?(source) && File.directory?(source)
+        FileUtils.cp_r(source, destination)
+      else
+        FileUtils.cp(source, destination)
+      end
+    rescue Exception
+      puts "Error copying #{source} to #{destination}"
+      raise
+    end
+  end
+
+end

data/lib/jarbler/config.rb

@@ -0,0 +1,108 @@
+module Jarbler
+  class Config
+    attr_accessor :jar_name, :includes, :excludes, :jruby_version, :executable, :executable_params
+
+    CONFIG_FILE = 'config/jarble.rb'
+    # create instence of Config class with defaults or from config file
+    # Should be called from rails/ruby root directory
+    def self.create
+      if File.exist?(CONFIG_FILE)
+        config = eval(File.read(CONFIG_FILE), binding, CONFIG_FILE, 0)
+      else
+        config = Jarbler::Config.new
+      end
+      unless config.class == Jarbler::Config
+        Jarbler.debug "No valid config provided in #{CONFIG_FILE}! Using defaults."
+        config = Config.new
+      end
+      config.define_jruby_version
+      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)
+      @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)
+      # execute additional block if given
+      yield self if block_given?
+    end
+
+    # Generate the template config file based on default values
+    def create_config_file
+      write_config_file("\
+# Name of the generated jar file
+# config.jar_name = '#{jar_name}'
+
+# Application directories or files to include in the jar file
+# config.includes = #{includes}
+# config.includes << 'additional'
+
+# Application directories or files to exclude from the jar file
+# config.excludes = #{excludes}
+# config.excludes << 'additional'
+
+# Use certail 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
+# config.jruby_version = '9.2.3.0'
+# config.jruby_version = nil
+
+# The Ruby executable file to run, e.g. 'bin/rails' or 'bin/rake'
+# config.executable = '#{executable}'
+
+# Additional command line parameters for the Ruby executable
+# config.executable_params = #{executable_params}
+      ".split("\n"))
+    end
+
+    # write a config file with the given lines
+    # if the file exists, it is overwritten
+    # if the file does not exist, it is created
+    # @param [Array] lines is an array of strings
+    def write_config_file(lines)
+      lines = [lines] unless lines.is_a?(Array)
+      FileUtils.mkdir_p('config')
+      raise "config file #{CONFIG_FILE} already exists in current directory! Please move file temporary and try again." if File.exist?(CONFIG_FILE)
+      File.open(CONFIG_FILE, 'w') do |file|
+        file.write("# Jarbler configuration, see https://github.com/rammpeter/jarbler\n")
+        file.write("# values in comments are the default values\n")
+        file.write("# uncomment and adjust if needed\n")
+        file.write(" \n")
+        file.write("Jarbler::Config.new do |config|\n")
+        lines.each do |line|
+          file.write("  #{line}\n")
+        end
+        file.write("end\n")
+      end
+      puts "Jarbler: Created config file #{Dir.pwd}/#{CONFIG_FILE}"
+    end
+
+    # 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}"
+        else
+          # no .ruby-version file, use jRuby version of the latest Gem
+          # Fetch the gem specification from Rubygems.org
+          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 "jRuby version from latest jruby-jars gem: #{jruby_version}"
+        end
+      end
+    end
+
+    def debug(msg)
+      puts msg if ENV['DEBUG']
+    end
+  end
+end

data/lib/jarbler/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Jarbler
+  VERSION = "0.1.0"
+  VERSION_DATE = "2023-04-20"
+end

data/lib/jarbler.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tmpdir'
+require 'yaml'
+require 'bundler'
+require 'bundler/lockfile_parser'
+
+require_relative "jarbler/version"
+require_relative "jarbler/builder"
+require_relative "jarbler/config"
+
+
+module Jarbler
+  def self.run
+    puts "Jarbler release #{VERSION}, #{VERSION_DATE} ( https://github.com/rammpeter/jarbler )"
+    Builder.new.build_jar
+  end
+
+  def self.config
+    Jarbler::Config.new.create_config_file
+  end
+end

data/sig/jarbler.rbs

@@ -0,0 +1,4 @@
+module Jarbler
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: jarbler
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Peter Ramm
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-04-23 00:00:00.000000000 Z
+dependencies: []
+description: Pack a Rails application into an executable jar file
+email:
+- Peter@ramm-oberhermsdorf.de
+executables:
+- jarble
+extensions: []
+extra_rdoc_files: []
+files:
+- ".ruby-version"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/jarble
+- build_gem.sh
+- jarbler.gemspec
+- lib/jarbler.rb
+- lib/jarbler/JarMain.java
+- lib/jarbler/builder.rb
+- lib/jarbler/config.rb
+- lib/jarbler/version.rb
+- sig/jarbler.rbs
+homepage: https://github.com/rammpeter/jarbler
+licenses:
+- MIT
+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:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.12
+signing_key:
+specification_version: 4
+summary: Create jar file from Rails app
+test_files: []