jarbler 0.2.3 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bba70c5fbf20494c82fc683d2e4ad8c39952000e8a525c7070f142219f7c38bd
-  data.tar.gz: '085db112eb0163afbad08545074af2a3994ec6cc498f56b6da16910833c2fe62'
+  metadata.gz: ae7132c21c27b0d51a870c3e79470d83a4d4b6b088c474c8cdaf4cf4ed34a79c
+  data.tar.gz: 8e149011da1e3957f425f659a7ac35b47e1696b3896f1a617c6027d027a783bb
 SHA512:
-  metadata.gz: 3a18adb5dfd17593a8c9fa8fb0c997b1e65544705a1074f39984923c6bfd9d82eb938c30b32b09339d349a17cb2e591ed817812060228bb94ecdb6e8cc890e2f
-  data.tar.gz: 36b98d4f3293ffcc11bbec6ef8e53f57a934d7885d30be43c6ed4c0dbcf3c54802d606d6a5d11292c37a4e1681077a92ecc7f9d23a49008ada7b95c1b0634d17
+  metadata.gz: d0712390a6916ee50d063c3f9dcc92fc6389c3ca566bc0b089d5df0275e3044b0aee30d3dedbcaf8171642e8555958137ef8a1ab8d14123417af8bc4475fee44
+  data.tar.gz: b85408f04e6c496827c8fc78d34a78790e173721c6c10e9899e07a29c818d4986296bdfadf5cc79e1ff1de49ff5679d1982cfdc370c3bacca15786c62b7b9e85

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
+## [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
+
+
+## [0.3.0] - 2024-06-18
+
+- excludes_from_compile specifies paths as the location in the jar file
+- Desupport of configuration attribute include_gems_to_compile
+
 ## [0.2.3] - 2024-06-13
 
 - Show used configuration values in log output

data/README.md

@@ -53,21 +53,20 @@ 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   | ["config"]                                                                     | The files and dirs of the project to exclude from the compilation of .rb files                                                                          |
-| 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                                                                                    |
-| include_gems_to_compile | false                                                                          | Should .rb files of the project gems also be compiled if compile_ruby_files = true                                                                      |
-| 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           | The current most recent JRuby version                                          | The version of the JRuby runtime to use                                                                                                                 |
+| 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                                                                                                                   |
 
 
 ## Troubleshooting
-* Set DEBUG=true in environment to get additional runtime information
+* Set DEBUG=true in OS 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

data/lib/jarbler/builder.rb

@@ -271,13 +271,9 @@ module Jarbler
 
       ruby_files = Find.find('.').select { |f| f =~ /\.rb$/ }                   # find all Ruby files in the current directory
 
-      if !config.include_gems_to_compile
-        ruby_files = ruby_files.select { |f| !(f =~ /\.#{File::SEPARATOR}gems#{File::SEPARATOR}/) } # Exclude ./gems/* directories from compiling
-      end
-
       # Exclude named files or directories from compiling
       config.excludes_from_compile.each do |exclude|
-        ruby_files = ruby_files.select { |f| !(f =~ /\.#{File::SEPARATOR}app_root#{File::SEPARATOR}#{exclude}/) }
+        ruby_files = ruby_files.select { |f| !(f =~ /\.#{File::SEPARATOR}#{exclude}/) }
       end
 
       ruby_files.each do |ruby_file|

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, :include_gems_to_compile, :excludes_from_compile
+    attr_accessor :jar_name, :includes, :excludes, :jruby_version, :executable, :executable_params, :compile_ruby_files, :excludes_from_compile
 
     CONFIG_FILE = 'config/jarble.rb'
     # create instance of Config class with defaults or from config file
@@ -31,13 +31,12 @@ 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_ruby_files:       #{config.compile_ruby_files}" if config.compile_ruby_files
-      puts "  excludes:                 #{config.excludes}" unless config.excludes.empty?
-      puts "  excludes_from_compile:    #{config.excludes_from_compile}" unless config.excludes_from_compile.empty?
+      puts "  compile_ruby_files:       #{config.compile_ruby_files}"
+      puts "  excludes:                 #{config.excludes}"
+      puts "  excludes_from_compile:    #{config.excludes_from_compile}"
       puts "  executable:               #{config.executable}"
-      puts "  executable_params:        #{config.executable_params}" unless config.executable_params.empty?
-      puts "  include_gems_to_compile:  #{config.include_gems_to_compile}" if config.include_gems_to_compile
-      puts "  includes:                 #{config.includes}" unless config.includes.empty?
+      puts "  executable_params:        #{config.executable_params}"
+      puts "  includes:                 #{config.includes}"
       puts "  jar_name:                 #{config.jar_name}"
       puts "  jruby_version:            #{config.jruby_version}"
       puts ""
@@ -47,10 +46,9 @@ module Jarbler
     def initialize
       @compile_ruby_files = false
       @excludes = %w(tmp/cache tmp/pids tmp/sockets vendor/bundle vendor/cache vendor/ruby)
-      @excludes_from_compile = %w(config)
+      @excludes_from_compile = []
       @executable = 'bin/rails'
       @executable_params = %w(server -e production -p 8080)
-      @include_gems_to_compile = false
       @includes = %w(app bin config config.ru db Gemfile Gemfile.lock lib log public Rakefile script vendor tmp)
       @jar_name = File.basename(Dir.pwd) + '.jar'
       @jruby_version = nil  # determined automatically at runtime
@@ -88,10 +86,8 @@ 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}
 
-# Compile also the .rb files of the gems of the project to Java .class files?
-# config.include_gems_to_compile = #{include_gems_to_compile}
-
 # 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}
 
       ".split("\n"))
@@ -121,35 +117,51 @@ module Jarbler
 
     # 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}"
+      if @jruby_version.nil? && File.exist?('.ruby-version')                    # not yet defined in config file but .ruby-version file exists
+        # read the file RAILS_ROOT/.ruby-version starting from char at position 6 to the end of the line
+        full_jruby_version_string = File.read('.ruby-version')
+        if full_jruby_version_string[0..5] == 'jruby-'
+          @jruby_version = full_jruby_version_string[6..20].strip
+          if @jruby_version =~ /\d+\.\d+\.\d+\.\d+/                        # check if the version is valid with four digits
+            debug "Jarbler::Config.define_jruby_version: JRuby version used from .ruby-version file: #{@jruby_version}"
+          else
+            debug "Jarbler::Config.define_jruby_version: Invalid JRuby version in .ruby-version file (not four digits delimited by dot): #{full_jruby_version_string}"
+            @jruby_version = nil
+          end
         else
-          # no .ruby-version file, use JRuby version of the latest Gem
-          # Fetch the gem specification from Rubygems.org
-          # 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}"
+          debug "Jarbler::Config.define_jruby_version: Version info from .ruby-version file not applicable: #{full_jruby_version_string}"
         end
       end
+
+      if @jruby_version.nil?                                                    # not yet defined in config file and .ruby-version file
+        # no .ruby-version file to be used, use JRuby version of the latest Gem
+        # Fetch the gem specification from Rubygems.org
+        # search for the gem and get the JSON response
+        response = Gem::SpecFetcher.fetcher.search_for_dependency(Gem::Dependency.new('jruby-jars'))
+        debug("Jarbler::Config.define_jruby_version: Response from search_for_dependency = #{response.inspect}")
+        # extract the versions from the response
+        @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
 
     def debug(msg)
       puts msg if ENV['DEBUG']
     end
 
+    # 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."
+    end
+
     def validate_values
       raise "Invalid config value for jar name: #{jar_name}" unless jar_name =~ /\w+/
       raise "Invalid config value for executable: #{executable}" unless executable =~ /\w+/
@@ -158,8 +170,8 @@ module Jarbler
       raise "Invalid config value for excludes: #{excludes}" unless excludes.is_a?(Array)
       raise "Invalid config value for compile_ruby_files: #{compile_ruby_files}" unless [true, false].include?(compile_ruby_files)
       raise "compile_ruby_files = true is supported only with JRuby! Current runtime is '#{RUBY_ENGINE}'" if compile_ruby_files && (defined?(RUBY_ENGINE) && RUBY_ENGINE != 'jruby')
-      raise "include_gems_to_compile = true is supported only if compile_ruby_files = true!" if include_gems_to_compile && !compile_ruby_files
       raise "Invalid config value for excludes_from_compile: #{excludes_from_compile}" unless excludes_from_compile.is_a?(Array)
+      raise "Invalid config value for jruby_version: #{jruby_version}" unless jruby_version.nil? || jruby_version =~ /\d+\.\d+\.\d+\.\d+/
     end
   end
 end

data/lib/jarbler/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Jarbler
-  VERSION = "0.2.3"
-  VERSION_DATE = "2024-06-13"
+  VERSION = "0.3.1"
+  VERSION_DATE = "2024-07-02"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jarbler
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.1
 platform: ruby
 authors:
 - Peter Ramm
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-06-13 00:00:00.000000000 Z
+date: 2024-07-02 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'