jarbler 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff7c6489ae577a03079ca5976e6f8ea2c311593aa2754590b83e37a446f68bc9
-  data.tar.gz: 840b7720151675d538e08473857d7fae6a4342f478cf84473ffc231f2414fc46
+  metadata.gz: 69c4dfd51fa32af943ab9ada29536253dc516150cdff7e82e1944216098a92c8
+  data.tar.gz: 63e6752eba98d7cc27642fcbb13a199fc41867a6d044edf28051f025d292ef09
 SHA512:
-  metadata.gz: 444d52de14b8316967b5184c9e814e40d52bcb780d84ef74dc148befea457232182bf83b01ec8c64540959af7d2522d2e20417ed9589771e8cd63779ffd60266
-  data.tar.gz: 991f7a004c5383846504ff98c7b0c0cb508e50530d64887e4418dd7b9ec2e788764303fa7358eb43d8d66ec3143118da038ee8cf8b03e5743dbc7b83175ff87b
+  metadata.gz: 882f6b8e791b8f7fc9cc4eff3d86867c2667f8d817fd4c46a1f10103bcf98e50aee1e98c10b49fe14ae5e4f5a63a992ff9bf9121d4a9459d87e20ca05560c42a
+  data.tar.gz: e8b9a10dbfacc4180710a62fe84cfa9595049d62cd6ff6625cf520d39d380357f13502f0e0f228057d85d226d4ef29fe255e5cc63cf011f5d00f92bc8c5d2c52

data/CHANGELOG.md

@@ -12,3 +12,10 @@
 
 - extract valid Gem paths from Bundler instead of using the environment variable GEM_PATH 
 
+## [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

@@ -5,11 +5,14 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in jarbler.gemspec
 gemspec
 
-gem "rake", "~> 13.0"
+# gem "rake", "~> 13.0"
+gem "rake"
+
+group(:development) do
+  gem 'rdoc'
+end
 
 group(:test)  do
   gem 'minitest'
   gem 'minitest-reporters'
-  # needed for minitests
-  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
 
@@ -55,6 +55,12 @@ The default executable parameters are  "server -p 8080 -e production".
 * Set DEBUG=true in environment to get additional runtime information
 * The temporary folder with the extracted app and jRuby runtime files is not deleted after execution if DEBUG is set.
 
+### Possible error messages
+* Gem::LoadError: You have already activated ..., but your Gemfile requires ... . Since ... is a default gem, you can either remove your dependency on it or try updating to a newer version of bundler that supports net-protocol as a default gem.
+  * Reason: Mismatch between the version of the local requested gem and the version of the default gem
+  * Solution: Update the default gems to the requested version
+
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/rammpeter/jarbler. <br>

data/build_gem.sh

@@ -1,4 +1,8 @@
-# Steps for creating gem
+# Steps for creating gem in local environment
+
+# remove existing gem file
+rm -f jarbler-*.gem
+
 rake test
 if [ $? -ne 0 ]; then
   echo "Tests failed."
@@ -11,7 +15,7 @@ if [ $? -ne 0 ]; then
   exit 1
 fi
 
-gem install jarbler-0.1.0.gem
+gem install `ls jarbler-*.gem`
 if [ $? -ne 0 ]; then
   echo "Gem install failed."
   exit 1

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

@@ -1,6 +1,9 @@
+require 'rubygems'
+require 'rubygems/dependency_installer'
 require 'bundler'
 require 'find'
 require 'fileutils'
+require 'yaml'
 
 module Jarbler
   class Builder
@@ -8,18 +11,15 @@ module Jarbler
     # 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
+      debug "Running with Ruby version '#{RUBY_VERSION}' on platform '#{RUBY_PLATFORM}'. Engine '#{RUBY_ENGINE}' version '#{RUBY_ENGINE_VERSION}'"
 
-      jarbler_lib_dir = __dir__
+      @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}"
 
-      # 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
+      ruby_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
 
       # Copy the application project to the staging directory
       FileUtils.mkdir_p("#{staging_dir}/app_root")
@@ -30,14 +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")
-
-      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
+      # Copy the needed Gems to the staging directory
+      copy_needed_gems_to_staging(staging_dir, ruby_version)
 
       Dir.chdir(staging_dir) do
         # create the manifest file
@@ -74,70 +68,73 @@ 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
 
-    # 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)
-      # All active search locations for Gems
-      Bundler.setup
-      possible_gem_search_locations = Gem.paths.path
-      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|
-        if File.exist?(gem_search_location) && File.directory?(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
-        else
-          debug("Gem location #{gem_search_location} does not exist or is not a directory")
+
+    # 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
-      debug "Valid Gem locations: #{gem_search_locations}"
-      gem_search_locations
+      bundle_path
     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
+    # Copy the needed Gems 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_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
+    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
-      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
+    # @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)
@@ -148,28 +145,30 @@ module Jarbler
         # 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)
+          unless needed_gems.map{|n| n[:fullname]}.include?(lockfile_spec.full_name)
+            needed_gems << { full_name: lockfile_spec.full_name, name: lockfile_spec.name, version: lockfile_spec.version }
+          end
           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
+      needed_gems.uniq.sort{|a,b| a[:full_name] <=> b[:full_name]}
     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
+    # @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|
         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
+          unless needed_gems.map{|n| n[:fullname]}.include?(lockfile_spec_found.full_name)
+            needed_gems << { full_name: lockfile_spec_found.full_name, name: lockfile_spec_found.name, version: lockfile_spec_found.version }
             add_indirect_dependencies(lockfile_specs, lockfile_spec_found, needed_gems)
           end
         else
@@ -177,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|
@@ -195,18 +200,21 @@ 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, 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 locations:\n#{gem_search_locations}" unless jruby_jars_location
+    def copy_jruby_jars_to_staging(staging_dir)
+
+      # Ensure that jruby-jars gem is installed, otherwise install it. Accepts also bundler path in .bundle/config
+      installer = Gem::DependencyInstaller.new
+      installed = installer.install('jruby-jars', config.jruby_version)
+      raise "jruby-jars gem not installed in version #{config.jruby_version}" if installed.empty?
+
+      jruby_jars_location = installed[0]&.full_gem_path
+      debug "jRuby jars installed at: #{jruby_jars_location}"
+
+      # Get the location of the jruby-jars gem
+      # spec = Gem::Specification.find_by_name('jruby-jars', config.jruby_version)
+      # jruby_jars_location = spec.gem_dir
+
       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)
 
@@ -219,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?
@@ -228,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.2"
-  VERSION_DATE = "2023-04-24"
+  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.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Peter Ramm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-24 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:
@@ -19,7 +19,6 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".ruby-version"
 - CHANGELOG.md
 - Gemfile
 - LICENSE

data/.ruby-version

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