jarbler 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6c86b6661dda0e9669619c5bac4a954a400dbeed028cb1944b9f0b781b4771d
-  data.tar.gz: 987e8bd4e2bd388f1b1642a8b9e911e9774e4c9870eb56c3bb85d053de1e1e1b
+  metadata.gz: fa38516809660fd2add2d7f1cb4a47bf48f219afb69adc2242f582c96b3b7a6f
+  data.tar.gz: 8f6cca1c0fbf6e892f7db511ba012de9fb9f3c96bfa49079e373172f0c9ee64a
 SHA512:
-  metadata.gz: 4810b94071beeda3eea5fc513646b63033129e38b258b0d274e4b3384705f3b1034ff7a706cf90317c6c0dd5086fea572652c7b89ddeba62bb3faebc68d1f69d
-  data.tar.gz: b6054b374c79cc5f1d4976d1b486fcc4730e088e54285edb3156f6cd592ca2bf8c665c8fcfbec383fc4e9e2132268744dec11fdc1e81b5fbf0dbdf0d9c5cd40d
+  metadata.gz: 3b01cbb87353587184e147d9082e5c8a4807afec0308a940c6c53c4b65a9df13aaa1eac32e1a0615fd0f4716c9e5d49b0a7138895dc5857f40f9c31f3de2fe6d
+  data.tar.gz: 1ab3a61b970c11b13e2ad118507dee7463460baf11c4d2dc617babf85f4e253206952245d5dbbcc1cb42356143b17d90fe3594c35564aa91b6462c49da862020

data/CHANGELOG.md

@@ -7,3 +7,11 @@
 ## [0.1.1] - 2023-04-24
 
 - Fixed the bug 'java.lang.ClassNotFoundException: org.jruby.Main' with Windows
+
+## [0.1.2] - 2023-04-24
+
+- 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

data/Gemfile

@@ -5,11 +5,13 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in jarbler.gemspec
 gemspec
 
-gem "rake", "~> 13.0"
+# gem "rake", "~> 13.0"
+gem "rake"
 
 group(:test)  do
   gem 'minitest'
   gem 'minitest-reporters'
   # needed for minitests
-  gem 'jruby-jars'
+  # test should install the jruby-jars in right version itself
+  # gem 'jruby-jars'
 end

data/README.md

@@ -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/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,16 @@ module Jarbler
     # Should be executed in application directory of Rails/Ruby application
     # @return [void]
     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
 
-      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
+      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")
@@ -34,10 +35,8 @@ module Jarbler
       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(gem_target_location, app_root)
 
       Dir.chdir(staging_dir) do
         # create the manifest file
@@ -82,53 +81,36 @@ module Jarbler
 
     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}"
+
+    # 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
-      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 [String] gem_target_location Path to the staging directory
     # @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
+    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}"
+          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
@@ -137,7 +119,7 @@ module Jarbler
       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
       # filter Gems needed for production
       gemfile_specs = Bundler.definition.dependencies.select do |d|
         d.groups.include?(:default) || d.groups.include?(:production)
@@ -148,14 +130,16 @@ 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
@@ -168,8 +152,8 @@ module Jarbler
         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
@@ -193,33 +177,24 @@ module Jarbler
       @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
+    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)
 

data/lib/jarbler/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jarbler
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Peter Ramm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-24 00:00:00.000000000 Z
+date: 2023-04-26 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'
@@ -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