jarbler 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa38516809660fd2add2d7f1cb4a47bf48f219afb69adc2242f582c96b3b7a6f
-  data.tar.gz: 8f6cca1c0fbf6e892f7db511ba012de9fb9f3c96bfa49079e373172f0c9ee64a
+  metadata.gz: 69c4dfd51fa32af943ab9ada29536253dc516150cdff7e82e1944216098a92c8
+  data.tar.gz: 63e6752eba98d7cc27642fcbb13a199fc41867a6d044edf28051f025d292ef09
 SHA512:
-  metadata.gz: 3b01cbb87353587184e147d9082e5c8a4807afec0308a940c6c53c4b65a9df13aaa1eac32e1a0615fd0f4716c9e5d49b0a7138895dc5857f40f9c31f3de2fe6d
-  data.tar.gz: 1ab3a61b970c11b13e2ad118507dee7463460baf11c4d2dc617babf85f4e253206952245d5dbbcc1cb42356143b17d90fe3594c35564aa91b6462c49da862020
+  metadata.gz: 882f6b8e791b8f7fc9cc4eff3d86867c2667f8d817fd4c46a1f10103bcf98e50aee1e98c10b49fe14ae5e4f5a63a992ff9bf9121d4a9459d87e20ca05560c42a
+  data.tar.gz: e8b9a10dbfacc4180710a62fe84cfa9595049d62cd6ff6625cf520d39d380357f13502f0e0f228057d85d226d4ef29fe255e5cc63cf011f5d00f92bc8c5d2c52

data/CHANGELOG.md

@@ -15,3 +15,7 @@
 ## [0.1.3] - 2023-04-25
 
 - Removed .jruby-version so that the jruby version is not fixed anymore
+
+## [0.1.4] - 2023-04-28
+
+- Jarbler also supports Gemfile references to Gems with git dependencies now

data/Gemfile

@@ -8,10 +8,11 @@ gemspec
 # gem "rake", "~> 13.0"
 gem "rake"
 
+group(:development) do
+  gem 'rdoc'
+end
+
 group(:test)  do
   gem 'minitest'
   gem 'minitest-reporters'
-  # needed for minitests
-  # test should install the jruby-jars in right version itself
-  # gem 'jruby-jars'
 end

data/README.md

@@ -1,11 +1,10 @@
 # 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.
+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. 
-In contrast to Warbler no Java servlet container is needed for execution.
-Instead the configured executable is executed using the jRuby runtime jars.
+The configured Ruby program is directly executed inside the JVM using the jRuby runtime jars.
 
 ## Installation
 
@@ -28,6 +27,7 @@ To adjust Jarbler's configuration, modify the settings in config file ´config/j
     $ jarble config
 
 ### Preconditions
+* Dependency handling should be based on Bundler (existence of Gemfile is required)
 * 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.
@@ -43,7 +43,7 @@ Additional command line parameters are passed through to the executed Ruby app (
 ## 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:
+To create a template config file with information about all the supported configuration options, execute:
 
     $ jarble config
 

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 Ruby combined with jRuby runtime 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

@@ -27,13 +27,16 @@ import java.util.Map;
 import java.util.HashMap;
 import java.lang.reflect.Field;
 import java.io.FileWriter;
+import java.security.CodeSource;
+import java.security.ProtectionDomain;
 
 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");
+        debug("Start java process in jar file "+jar_file_name());
+        debug("JVM: "+System.getProperty("java.vm.vendor")+" "+System.getProperty("java.vm.name")+" "+System.getProperty("java.vm.version")+" "+System.getProperty("java.home"));
         if (args.length > 0) {
             debug("Java command line arguments are: ");
             for (String arg : args) {
@@ -225,4 +228,18 @@ class JarMain {
         fw.write("BUNDLE_WITHOUT: test:development\n");
         fw.close();
     }
+
+    private static String jar_file_name() {
+        String jarFileName = "";
+
+        try {
+            ProtectionDomain protectionDomain = JarMain.class.getProtectionDomain();
+            CodeSource codeSource = protectionDomain.getCodeSource();
+            URL location = codeSource.getLocation();
+            jarFileName = new File(location.toURI()).getName();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return jarFileName;
+    }
 }

data/lib/jarbler/builder.rb

@@ -13,9 +13,8 @@ module Jarbler
     def build_jar
       debug "Running with Ruby version '#{RUBY_VERSION}' on platform '#{RUBY_PLATFORM}'. Engine '#{RUBY_ENGINE}' version '#{RUBY_ENGINE_VERSION}'"
 
-      # create a temporary directory for staging
-      staging_dir = Dir.mktmpdir
-
+      @config = nil # Ensure config is read from file or default. Necessary for testing only because of caching
+      staging_dir = Dir.mktmpdir # create a temporary directory for staging
       app_root = Dir.pwd
       debug "Project dir: #{app_root}"
 
@@ -31,12 +30,8 @@ module Jarbler
       # 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")
-
       # Copy the needed Gems to the staging directory
-      copy_needed_gems_to_staging(gem_target_location, app_root)
+      copy_needed_gems_to_staging(staging_dir, ruby_version)
 
       Dir.chdir(staging_dir) do
         # create the manifest file
@@ -73,16 +68,25 @@ module Jarbler
         file_utils_copy(config.jar_name, app_root)
         puts "Created jar file #{app_root}/#{config.jar_name}"
       end
-
+    rescue Exception => e
+      puts "Error: #{e.message}"
+      puts e.backtrace.join("\n")
+      raise
+    ensure
       # remove temporary directory staging_dir
-      FileUtils.remove_entry staging_dir
-
+      if ENV['DEBUG']
+        puts "Temporary directory #{staging_dir} not removed because of debug mode"
+      else
+        FileUtils.remove_entry staging_dir if staging_dir
+      end
     end
 
     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")
@@ -96,30 +100,41 @@ module Jarbler
     end
 
     # Copy the needed Gems to the staging directory
-    # @param [String] gem_target_location Path to the staging directory
+    # @param staging_dir [String] the staging directory
+    # @param ruby_version [String] the corresponding ruby version of the jruby jars version
     # @return [void]
-    def copy_needed_gems_to_staging(gem_target_location, app_root)
-      #Bundler.with_unbundled_env do # No previous setting inherited like Gemfile location
-      #  Bundler.reset! # Reset settings from previous Bundler.with_unbundled_env
-        needed_gems = gem_dependencies  # get the full names of the dependencies
-        needed_gems.each do |needed_gem|
-          # Get the location of the needed gem
-          spec = Gem::Specification.find_by_name(needed_gem[:name], needed_gem[:version])
-          raise "Gem #{needed_gem[:full_name]} not found for copying" unless spec
-          debug "Found gem #{needed_gem[:full_name]} version #{needed_gem[:version]} in #{spec.gem_dir}"
+    def copy_needed_gems_to_staging(staging_dir, ruby_version)
+      gem_target_location = "#{staging_dir}/gems/jruby/#{ruby_version}"
+      FileUtils.mkdir_p("#{gem_target_location}/gems")
+      FileUtils.mkdir_p("#{gem_target_location}/specifications")
+      FileUtils.mkdir_p("#{gem_target_location}/bundler/gems")
+
+      needed_gems = gem_dependencies  # get the full names of the dependencies
+      needed_gems.each do |needed_gem|
+        # Get the location of the needed gem
+        spec = Gem::Specification.find_by_name(needed_gem[:name], needed_gem[:version])
+        raise "Gem #{needed_gem[:full_name]} not found for copying" unless spec
+        debug "Found gem #{needed_gem[:full_name]} version #{needed_gem[:version]} in #{spec.gem_dir}"
+
+        # differentiate between Gems from git/bundler and Gems from rubygems
+        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")
+        else  # Gem is from rubygems
+          # 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")
-          # end
+        end
       end
     end
 
     # Read the default/production dependencies from Gemfile.lock and Gemfile
-    # @return [Array] Array with full names of dependencies
+    # @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
 
-      # Bundler.setup # Load Gems specified in Gemfile
+      Bundler.setup # Load Gems specified in Gemfile, ensure that Gem path also includes the Gems loaded into bundler dir
       # filter Gems needed for production
       gemfile_specs = Bundler.definition.dependencies.select do |d|
         d.groups.include?(:default) || d.groups.include?(:production)
@@ -145,7 +160,7 @@ module Jarbler
     # 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
+    # @param [Array] needed_gems Array with Hashes containing: name, version, full_name
     # @return [void]
     def add_indirect_dependencies(lockfile_specs, lockfile_spec, needed_gems)
       lockfile_spec.dependencies.each do |lockfile_spec_dep|
@@ -161,12 +176,18 @@ module Jarbler
         end
       end
     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']
     end
 
+    # Get the config object
+    # @return [Config] the config object
     def config
-      unless defined? @config
+      if !defined?(@config) || @config.nil?
        @config = Config.create
        debug("Config attributes:")
        @config.instance_variables.each do |var|
@@ -179,7 +200,6 @@ module Jarbler
 
     # 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)
 
@@ -207,7 +227,9 @@ module Jarbler
       ruby_version
     end
 
-    # Execute the command and return the output
+    # 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?
@@ -216,6 +238,9 @@ module Jarbler
     end
 
     # Copy file or directory with error handling
+    # @param [String] source Path to the source file or directory
+    # @param [String] destination Path to the destination file or directory
+    # @return [void]
     def file_utils_copy(source, destination)
       if File.exist?(source) && File.directory?(source)
         FileUtils.cp_r(source, destination)

data/lib/jarbler/config.rb

@@ -1,9 +1,12 @@
+require 'rubygems'
+require 'json'
+
 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
+    # create instance 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)
@@ -90,12 +93,18 @@ module Jarbler
         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]
+          # search for the gem and get the JSON response
+          response = Gem::SpecFetcher.fetcher.search_for_dependency(Gem::Dependency.new('jruby-jars'))
+          # extract the versions from the response
+          self.jruby_version = response&.first&.first&.first&.version&.to_s
+          raise "Unable to determine the latest available version of jruby-jars gem!\Rsponse = #{response.inspect}" unless self.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 "jRuby version from latest jruby-jars gem: #{jruby_version}"
         end
       end

data/lib/jarbler/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Jarbler
-  VERSION = "0.1.3"
-  VERSION_DATE = "2023-04-25"
+  VERSION = "0.1.4"
+  VERSION_DATE = "2023-04-28"
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: jarbler
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Peter Ramm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-26 00:00:00.000000000 Z
+date: 2023-04-28 00:00:00.000000000 Z
 dependencies: []
-description: Pack Ruby combined with jRuby runtime into a jar file to simply run the
-  app on any Java platform by '> java -jar file.jar'
+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
 executables: