jar-dependencies 0.3.9 → 0.4.1

data/jar-dependencies.gemspec

@@ -4,41 +4,39 @@ Gem::Specification.new do |s|
   s.name = 'jar-dependencies'
 
   path = File.expand_path('lib/jars/version.rb', File.dirname(__FILE__))
-  s.version = File.read(path).match( /\s*VERSION\s*=\s*['"](.*)['"]/ )[1]
-  
+  s.version = File.read(path).match(/\s*VERSION\s*=\s*['"](.*)['"]/)[1]
+
   s.author = 'christian meier'
-  s.email = [ 'mkristian@web.de' ]
+  s.email = ['mkristian@web.de']
   s.summary = 'manage jar dependencies for gems'
   s.homepage = 'https://github.com/mkristian/jar-dependencies'
 
-  s.bindir = "bin"
-  LOCK_JARS = 'lock_jars'
-  s.executables = [LOCK_JARS]
+  s.bindir = 'bin'
+  s.executables = [lock_jars = 'lock_jars'.freeze]
 
   s.license = 'MIT'
 
-  s.files = `git ls-files`.split($/).select do |file|
+  s.files = `git ls-files`.split($INPUT_RECORD_SEPARATOR).select do |file|
     file =~ /^lib\// ||
-    [ 'Mavenfile', 'Rakefile' ].include?(file) ||
-    [ 'Readme.md', 'jar-dependencies.gemspec', 'MIT-LICENSE' ].include?(file)
+      %w[Mavenfile Rakefile].include?(file) ||
+      ['Readme.md', 'jar-dependencies.gemspec', 'MIT-LICENSE'].include?(file)
   end
 
   s.description = 'manage jar dependencies for gems and keep track which jar was already loaded using maven artifact coordinates. it warns on version conflicts and loads only ONE jar assuming the first one is compatible to the second one otherwise your project needs to lock down the right version by providing a Jars.lock file.'
 
-  s.add_development_dependency 'minitest', '~> 5.3'
+  s.add_development_dependency 'minitest', '~> 5.10.0'
   s.add_development_dependency 'rake', '~> 10.2'
-  RUBY_MAVEN_VERSION = '~> 3.3.11'
-  s.add_development_dependency 'ruby-maven', RUBY_MAVEN_VERSION
+  s.add_development_dependency 'ruby-maven', ruby_maven_version = '~> 3.3.11'.freeze
 
   s.post_install_message = <<EOF
 
-if you want to use the executable #{LOCK_JARS} then install ruby-maven gem before using #{LOCK_JARS} 
+if you want to use the executable #{lock_jars} then install ruby-maven gem before using #{lock_jars}
 
-   $ gem install ruby-maven -v '#{RUBY_MAVEN_VERSION}'
+  $ gem install ruby-maven -v '#{ruby_maven_version}'
 
 or add it as a development dependency to your Gemfile
 
-   gem 'ruby-maven', '#{RUBY_MAVEN_VERSION}'
+   gem 'ruby-maven', '#{ruby_maven_version}'
 
 EOF
 end

data/lib/jar_dependencies.rb

@@ -18,7 +18,7 @@
 # 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.
 #
-require 'jars/maven_settings'
+
 module Jars
   unless defined? Jars::SKIP_LOCK
     MAVEN_SETTINGS = 'JARS_MAVEN_SETTINGS'.freeze
@@ -45,45 +45,48 @@ module Jars
     DEBUG = 'JARS_DEBUG'.freeze
     # vendor jars inside gem when installing gem
     VENDOR = 'JARS_VENDOR'.freeze
+    # string used when the version is unknown
+    UNKNOWN = 'unknown'
   end
 
-  class << self
+  autoload :MavenSettings, 'jars/maven_settings'
 
-    def lock_down( debug = false, verbose = false, options = {} )
-      ENV[ SKIP_LOCK ] = 'true'
+  class << self
+    def lock_down(debug = false, verbose = false, options = {})
+      ENV[SKIP_LOCK] = 'true'
       require 'jars/lock_down' # do this lazy to keep things clean
-      Jars::LockDown.new( debug, verbose ).lock_down( options )
+      Jars::LockDown.new(debug, verbose).lock_down(options)
     ensure
-      ENV[ SKIP_LOCK ] = nil
+      ENV[SKIP_LOCK] = nil
     end
 
     if defined? JRUBY_VERSION
-      def to_prop( key )
-        key = key.gsub( '_', '.' )
-        ENV_JAVA[ ( key.downcase!; key ) ] ||
-          ENV[ ( key.gsub!( '.', '_' ); key.upcase!; key ) ]
+      def to_prop(key)
+        key = key.tr('_', '.')
+        ENV_JAVA[(key.downcase!; key)] ||
+          ENV[(key.tr!('.', '_'); key.upcase!; key)]
       end
     else
-      def to_prop( key )
-        ENV[ key.gsub( '.', '_' ).upcase ]
+      def to_prop(key)
+        ENV[key.tr('.', '_').upcase]
       end
     end
 
-    def to_boolean( key )
-      return nil if ( prop = to_prop( key ) ).nil?
+    def to_boolean(key)
+      return nil if (prop = to_prop(key)).nil?
       prop.empty? || prop.eql?('true')
     end
 
     def skip?
-      to_boolean( SKIP )
+      to_boolean(SKIP)
     end
 
     def require?
       @require = nil unless instance_variable_defined?(:@require)
       if @require.nil?
-        if ( require = to_boolean( REQUIRE ) ).nil?
-          no_require = to_boolean( NO_REQUIRE )
-          @require = no_require.nil? ? true : ! no_require
+        if (require = to_boolean(REQUIRE)).nil?
+          no_require = to_boolean(NO_REQUIRE)
+          @require = no_require.nil? ? true : !no_require
         else
           @require = require
         end
@@ -93,26 +96,28 @@ module Jars
     attr_writer :require
 
     def quiet?
-      ( @silent ||= false ) || to_boolean( QUIET )
+      (@silent ||= false) || to_boolean(QUIET)
     end
 
     def jarfile
-      ENV[ 'JARFILE' ] || ENV_JAVA[ 'jarfile' ] || ENV[ 'JBUNDLER_JARFILE' ] || ENV_JAVA[ 'jbundler.jarfile' ] || 'Jarfile'
+      ENV['JARFILE'] || ENV_JAVA['jarfile'] || ENV['JBUNDLER_JARFILE'] || ENV_JAVA['jbundler.jarfile'] || 'Jarfile'
     end
 
     # @deprecated
-    def no_require?; ! require? end
+    def no_require?
+      !require?
+    end
 
     def verbose?
-      to_boolean( VERBOSE )
+      to_boolean(VERBOSE)
     end
 
     def debug?
-      to_boolean( DEBUG )
+      to_boolean(DEBUG)
     end
 
     def vendor?
-      to_boolean( VENDOR )
+      to_boolean(VENDOR)
     end
 
     def no_more_warnings
@@ -124,28 +129,30 @@ module Jars
     end
 
     def skip_lock?
-      to_prop( SKIP_LOCK ) || false
+      to_prop(SKIP_LOCK) || false
     end
 
     def lock
-      to_prop( LOCK ) || 'Jars.lock'
+      to_prop(LOCK) || 'Jars.lock'
     end
 
     def jars_lock_from_class_loader
-      if to_prop( LOCK ).nil? && defined?(JRUBY_VERSION)
-        JRuby.runtime.jruby_class_loader.get_resources( 'Jars.lock' ).collect do |url|
-          url.to_s
+      if to_prop(LOCK).nil? && defined?(JRUBY_VERSION)
+        if JRuby::Util.respond_to?(:class_loader_resources)
+          JRuby::Util.class_loader_resources('Jars.lock')
+        else; require 'jruby'
+          JRuby.runtime.jruby_class_loader.get_resources('Jars.lock').collect(&:to_s)
         end
       end
     end
 
-    def lock_path( basedir = nil )
-      deps = self.lock
-      return deps if File.exists?( deps )
+    def lock_path(basedir = nil)
+      deps = lock
+      return deps if File.exist?(deps)
       basedir ||= '.'
-      [ '.', 'jars', 'vendor/jars' ].each do |dir|
-        file = File.join( basedir, dir, self.lock )
-        return file if File.exists?( file )
+      ['.', 'jars', 'vendor/jars'].each do |dir|
+        file = File.join(basedir, dir, lock)
+        return file if File.exist?(file)
       end
       nil
     end
@@ -153,7 +160,7 @@ module Jars
     def reset
       instance_variables.each { |var| instance_variable_set(var, nil) }
       Jars::MavenSettings.reset
-      ( @@jars ||= {} ).clear
+      (@@jars ||= {}).clear
     end
 
     def maven_local_settings
@@ -177,29 +184,28 @@ module Jars
                              detect_local_repository(maven_local_settings) ||
                              detect_local_repository(maven_user_settings) ||
                              detect_local_repository(maven_global_settings) ||
-                             File.join( user_home, '.m2', 'repository' )
+                             File.join(user_home, '.m2', 'repository')
     end
 
     def home
-      @_jars_home_ ||= absolute(to_prop(HOME)) || local_maven_repo
+      absolute(to_prop(HOME)) || local_maven_repo
     end
 
-    def require_jars_lock!( scope = :runtime )
+    def require_jars_lock!(scope = :runtime)
       urls = jars_lock_from_class_loader
-      if urls and urls.size > 0
+      if urls && !urls.empty?
         @@jars_lock = true
         # funny error during spec where it tries to load it again
         # and finds it as gem instead of the LOAD_PATH
         require 'jars/classpath' unless defined? Jars::Classpath
         done = []
-        while done != urls do
+        while done != urls
           urls.each do |url|
-            unless done.member?( url )
-              Jars.debug { "--- load jars from uri #{url}" }
-              classpath = Jars::Classpath.new( nil, "uri:#{url}" )
-              classpath.require( scope )
-              done << url
-            end
+            next if done.member?(url)
+            Jars.debug { "--- load jars from uri #{url}" }
+            classpath = Jars::Classpath.new(nil, "uri:#{url}")
+            classpath.require(scope)
+            done << url
           end
           urls = jars_lock_from_class_loader
         end
@@ -210,25 +216,25 @@ module Jars
         # funny error during spec where it tries to load it again
         # and finds it as gem instead of the LOAD_PATH
         require 'jars/classpath' unless defined? Jars::Classpath
-        classpath = Jars::Classpath.new( nil, jars_lock )
-        classpath.require( scope )
+        classpath = Jars::Classpath.new(nil, jars_lock)
+        classpath.require(scope)
         no_more_warnings
       end
-      Jars.debug {
+      Jars.debug do
         @@jars ||= {}
-        loaded = @@jars.collect{ |k,v| "#{k}:#{v}" }
+        loaded = @@jars.collect { |k, v| "#{k}:#{v}" }
         "--- loaded jars ---\n\t#{loaded.join("\n\t")}"
-      }
+      end
     end
 
-    def setup( options = nil )
+    def setup(options = nil)
       case options
       when Symbol
-        require_jars_lock!( options )
+        require_jars_lock!(options)
       when Hash
         @_jars_home = options[:jars_home]
         @_jars_lock = options[:jars_lock]
-        require_jars_lock!( options[:scope] || :runtime )
+        require_jars_lock!(options[:scope] || :runtime)
       else
         require_jars_lock!
       end
@@ -242,35 +248,41 @@ module Jars
       end
     end
 
-    def mark_as_required( group_id, artifact_id, *classifier_version )
-      require_jar_with_block( group_id, artifact_id, *classifier_version ) do
+    def mark_as_required(group_id, artifact_id, *classifier_version)
+      require_jar_with_block(group_id, artifact_id, *classifier_version) do
       end
     end
 
-    def require_jar( group_id, artifact_id, *classifier_version )
+    def require_jar(group_id, artifact_id, *classifier_version, &block)
       require_jars_lock unless skip_lock?
-      require_jar_with_block( group_id, artifact_id, *classifier_version ) do |gid, aid, version, classifier|
-        do_require( gid, aid, version, classifier )
+      if classifier_version.empty? && block_given?
+        classifier_version = [block.call].compact
+        if classifier_version.empty?
+          return mark_as_required(group_id, artifact_id, UNKNOWN) || false
+        end
+      end
+      require_jar_with_block(group_id, artifact_id, *classifier_version) do |gid, aid, version, classifier|
+        do_require(gid, aid, version, classifier)
       end
     end
 
-    def warn(msg = nil, &block)
-      Kernel.warn(msg || block.call) unless quiet? and not verbose?
+    def warn(msg = nil)
+      Kernel.warn(msg || yield) unless quiet? && !verbose?
     end
 
-    def debug(msg = nil, &block)
-      Kernel.warn(msg || block.call) if verbose?
+    def debug(msg = nil)
+      Kernel.warn(msg || yield) if verbose?
     end
 
-    def absolute( file )
-      File.expand_path( file ) if file
+    def absolute(file)
+      File.expand_path(file) if file
     end
 
     def user_home
-      ENV[ 'HOME' ] || begin
+      ENV['HOME'] || begin
         user_home = Dir.home if Dir.respond_to?(:home)
         unless user_home
-          user_home = ENV_JAVA[ 'user.home' ] if Object.const_defined?(:ENV_JAVA)
+          user_home = ENV_JAVA['user.home'] if Object.const_defined?(:ENV_JAVA)
         end
         user_home
       end
@@ -278,22 +290,22 @@ module Jars
 
     private
 
-    def require_jar_with_block( group_id, artifact_id, *classifier_version )
-      version = classifier_version[ -1 ]
-      classifier = classifier_version[ -2 ]
+    def require_jar_with_block(group_id, artifact_id, *classifier_version)
+      version = classifier_version[-1]
+      classifier = classifier_version[-2]
 
       @@jars ||= {}
       coordinate = "#{group_id}:#{artifact_id}"
       coordinate << ":#{classifier}" if classifier
       if @@jars.key? coordinate
-        if @@jars[ coordinate ] == version
+        if @@jars[coordinate] == version
           false
         else
-          @@jars[ coordinate ] # version of already registered jar
+          @@jars[coordinate] # version of already registered jar
         end
       else
         yield group_id, artifact_id, version, classifier
-        @@jars[ coordinate ] = version
+        @@jars[coordinate] = version
         return true
       end
     end
@@ -301,60 +313,57 @@ module Jars
     def detect_local_repository(settings)
       return nil unless settings
 
-      doc = File.read( settings )
-      # TODO filter out xml comments
-      local_repo = doc.sub( /<\/localRepository>.*/m, '' ).sub( /.*<localRepository>/m, '' )
+      doc = File.read(settings)
+      # TODO: filter out xml comments
+      local_repo = doc.sub(/<\/localRepository>.*/m, '').sub(/.*<localRepository>/m, '')
       # replace maven like system properties embedded into the string
-      local_repo.gsub!( /\$\{[a-zA-Z.]+\}/ ) do |a|
-        ENV_JAVA[ a[2..-2] ] || a
-      end
-      if local_repo.empty? or not File.exists?( local_repo )
-        local_repo = nil
+      local_repo.gsub!(/\$\{[a-zA-Z.]+\}/) do |a|
+        ENV_JAVA[a[2..-2]] || a
       end
+      local_repo = nil if local_repo.empty? || !File.exist?(local_repo)
       local_repo
     rescue
       Jars.warn { "error reading or parsing #{settings}" }
       nil
     end
 
-    def to_jar( group_id, artifact_id, version, classifier = nil )
-      file = String.new("#{group_id.gsub( '.', '/' )}/#{artifact_id}/#{version}/#{artifact_id}-#{version}")
+    def to_jar(group_id, artifact_id, version, classifier = nil)
+      file = String.new("#{group_id.tr('.', '/')}/#{artifact_id}/#{version}/#{artifact_id}-#{version}")
       file << "-#{classifier}" if classifier
       file << '.jar'
       file
     end
 
-    def do_require( *args )
-      jar = to_jar( *args )
-      local = File.join( Dir.pwd, 'jars', jar )
-      vendor = File.join( Dir.pwd, 'vendor', 'jars', jar )
-      file = File.join( home, jar )
+    def do_require(*args)
+      jar = to_jar(*args)
+      local = File.join(Dir.pwd, 'jars', jar)
+      vendor = File.join(Dir.pwd, 'vendor', 'jars', jar)
+      file = File.join(home, jar)
       # use jar from local repository if exists
-      if File.exists?( file )
+      if File.exist?(file)
         require file
       # use jar from PWD/jars if exists
-      elsif File.exists?( local )
+      elsif File.exist?(local)
         require local
       # use jar from PWD/vendor/jars if exists
-      elsif File.exists?( vendor )
+      elsif File.exist?(vendor)
         require vendor
       else
         # otherwise try to find it on the load path
         require jar
       end
     rescue LoadError => e
-      raise "\n\n\tyou might need to reinstall the gem which depends on the missing jar or in case there is Jars.lock then resolve the jars with `lock_jars` command\n\n" + e.message + " (LoadError)"
+      raise "\n\n\tyou might need to reinstall the gem which depends on the missing jar or in case there is Jars.lock then resolve the jars with `lock_jars` command\n\n" + e.message + ' (LoadError)'
     end
-
   end # class << self
-
 end
 
-def require_jar( *args )
+def require_jar(*args, &block)
   return nil unless Jars.require?
-  result = Jars.require_jar( *args )
+  result = Jars.require_jar(*args, &block)
   if result.is_a? String
-    Jars.warn { "--- jar coordinate #{args[0..-2].join( ':' )} already loaded with version #{result} - omit version #{args[-1]}" }
+    args << (block.call || Jars::UNKNOWN) if args.size == 2 && block_given?
+    Jars.warn { "--- jar coordinate #{args[0..-2].join(':')} already loaded with version #{result} - omit version #{args[-1]}" }
     Jars.debug { "    try to load from #{caller.join("\n\t")}" }
     return false
   end

data/lib/jars/attach_jars_pom.rb

@@ -1,22 +1,22 @@
 # this file is maven DSL
 
-( 0..10000 ).each do |i|
-  coord = ENV_JAVA[ "jars.#{i}" ]
+(0..10_000).each do |i|
+  coord = ENV_JAVA["jars.#{i}"]
   break unless coord
-  artifact = Maven::Tools::Artifact.from_coordinate( coord )
+  artifact = Maven::Tools::Artifact.from_coordinate(coord)
   exclusions = []
-  ( 0..10000 ).each do |j|
-    exclusion = ENV_JAVA[ "jars.#{i}.exclusions.#{j}" ]
+  (0..10_000).each do |j|
+    exclusion = ENV_JAVA["jars.#{i}.exclusions.#{j}"]
     break unless exclusion
     exclusions << exclusion
   end
-  scope = ENV_JAVA[ "jars.#{i}.scope" ]
+  scope = ENV_JAVA["jars.#{i}.scope"]
   artifact.scope = scope if scope
-  classifier = ENV_JAVA[ "jars.#{i}.classifier" ]
+  classifier = ENV_JAVA["jars.#{i}.classifier"]
   artifact.classifier = classifier if classifier
 
   # declare the artifact inside the POM
-  dependency_artifact( artifact ) do
+  dependency_artifact(artifact) do
     exclusions.each do |ex|
       exclusion ex
     end