jar-dependencies 0.3.11 → 0.3.12

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

data/lib/jars/classpath.rb

@@ -3,42 +3,40 @@ require 'jars/lock'
 require 'fileutils'
 
 module Jars
-
   class Classpath
-
     # convenient method
-    def self.require( scope = nil )
-      new.require( scope )
+    def self.require(scope = nil)
+      new.require(scope)
     end
 
     # convenient method
-    def self.classpath( scope = nil )
-      new.classpath( scope )
+    def self.classpath(scope = nil)
+      new.classpath(scope)
     end
 
     # convenient method
-    def self.classpath_string( scope = nil )
-      new.classpath_string( scope )
+    def self.classpath_string(scope = nil)
+      new.classpath_string(scope)
     end
 
-    def initialize( spec = nil, deps = nil )
+    def initialize(spec = nil, deps = nil)
       @spec = spec
       @deps = deps
     end
 
     def mvn
-      @mvn ||= MavenExec.new( @spec )
+      @mvn ||= MavenExec.new(@spec)
     end
 
-    def workdir( dirname )
-      dir = File.join( mvn.basedir, dirname )
-      dir if File.directory?( dir )
+    def workdir(dirname)
+      dir = File.join(mvn.basedir, dirname)
+      dir if File.directory?(dir)
     end
 
     def dependencies_list
       if @deps.nil?
-        deps = Jars.lock_path( mvn.basedir )
-        @deps = deps if deps && File.exist?( deps )
+        deps = Jars.lock_path(mvn.basedir)
+        @deps = deps if deps && File.exist?(deps)
       end
       if @deps
         @deps
@@ -47,50 +45,50 @@ module Jars
       end
     end
     private :dependencies_list
-    
-    DEPENDENCY_LIST = 'dependencies.list'
+
+    DEPENDENCY_LIST = 'dependencies.list'.freeze
     def resolve_dependencies
-      basedir = workdir( 'pkg' ) || workdir( 'target' ) || workdir( '' )
-      deps = File.join( basedir, DEPENDENCY_LIST )
-      mvn.resolve_dependencies_list( deps )
+      basedir = workdir('pkg') || workdir('target') || workdir('')
+      deps = File.join(basedir, DEPENDENCY_LIST)
+      mvn.resolve_dependencies_list(deps)
       deps
     end
     private :resolve_dependencies
 
-    def require( scope = nil )
-      process( scope ) do |jar|
+    def require(scope = nil)
+      process(scope) do |jar|
         if jar.scope == :system
           Kernel.require jar.path
         else
-          require_jar( *jar.gacv )
+          require_jar(*jar.gacv)
         end
       end
-      if scope == nil || scope == :runtime
-        process( :provided ) do |jar|
-          Jars.mark_as_required( *jar.gacv )
+      if scope.nil? || scope == :runtime
+        process(:provided) do |jar|
+          Jars.mark_as_required(*jar.gacv)
         end
       end
     end
 
-    def classpath( scope = nil )
+    def classpath(scope = nil)
       classpath = []
-      process( scope ) do |jar|
+      process(scope) do |jar|
         classpath << jar.file
       end
       classpath
     end
 
-    def process( scope, &block )
+    def process(scope, &block)
       deps = dependencies_list
-      Lock.new( deps ).process( scope, &block )
+      Lock.new(deps).process(scope, &block)
     ensure
       # just delete the temporary file if it exists
-      FileUtils.rm_f( DEPENDENCY_LIST )
+      FileUtils.rm_f(DEPENDENCY_LIST)
     end
     private :process
 
-    def classpath_string( scope = nil )
-      classpath( scope ).join( File::PATH_SEPARATOR )
+    def classpath_string(scope = nil)
+      classpath(scope).join(File::PATH_SEPARATOR)
     end
   end
 end

data/lib/jars/gemspec_artifacts.rb

@@ -1,8 +1,7 @@
 module Jars
-
   class MavenVersion < String
     def self.new(*args)
-      if args.size == 0 || (args.size == 1 && args[0].nil?)
+      if args.empty? || (args.size == 1 && args[0].nil?)
         nil
       else
         low, high = convert(args[0])
@@ -20,7 +19,7 @@ module Jars
     def self.convert(arg, low = nil, high = nil)
       if arg =~ /~>/
         val = arg.sub(/~>\s*/, '')
-        last = val=~/\./ ? val.sub(/\.[0-9]*[a-z]+.*$/, '').sub(/\.[^.]+$/, '.99999') : '99999'
+        last = val =~ /\./ ? val.sub(/\.[0-9]*[a-z]+.*$/, '').sub(/\.[^.]+$/, '.99999') : '99999'
         ["[#{snapshot_version(val)}", "#{snapshot_version(last)}]"]
       elsif arg =~ />=/
         val = arg.sub(/>=\s*/, '')
@@ -29,7 +28,7 @@ module Jars
         val = arg.sub(/<=\s*/, '')
         [(nil || low), "#{snapshot_version(val)}]"]
       # treat '!' the same way as '>' since maven can not describe such range
-      elsif arg =~ /[!>]/  
+      elsif arg =~ /[!>]/
         val = arg.sub(/[!>]\s*/, '')
         ["(#{snapshot_version(val)}", (nil || high)]
       elsif arg =~ /</
@@ -38,8 +37,8 @@ module Jars
       elsif arg =~ /\=/
         val = arg.sub(/=\s*/, '')
         # for prereleased version pick the maven version (no version range)
-        if val.match( /[a-z]|[A-Z]/ )
-          [ val, val ]
+        if val =~ /[a-z]|[A-Z]/
+          [val, val]
         else
           ["[#{val}", "#{val}.0.0.0.0.1)"]
         end
@@ -49,7 +48,7 @@ module Jars
       end
     end
 
-    def self.snapshot_version( val )
+    def self.snapshot_version(val)
       if val.match(/[a-z]|[A-Z]/) && !val.match(/-SNAPSHOT|[${}]/)
         val + '-SNAPSHOT'
       else
@@ -59,12 +58,11 @@ module Jars
   end
 
   class GemspecArtifacts
-
     class Exclusion
       attr_reader :group_id, :artifact_id
 
       def initialize(line)
-        @group_id, @artifact_id = line.gsub(/['"]/, '').strip.split( ':' )
+        @group_id, @artifact_id = line.gsub(/['"]/, '').strip.split(':')
         @artifact_id.strip!
       end
 
@@ -72,68 +70,62 @@ module Jars
         "#{@group_id}:#{@artifact_id}"
       end
     end
-    
-    class Exclusions < Array
 
+    class Exclusions < Array
       def to_s
         "[#{join(', ')}]"
       end
 
-      def initialize( line )
+      def initialize(line)
         super()
-        line.gsub(/'"|^\s*\[|\]\s*$/, '').split( /,\s*/ ).each do |exclusion|
-          self.<< Exclusion.new( exclusion )
+        line.gsub(/'"|^\s*\[|\]\s*$/, '').split(/,\s*/).each do |exclusion|
+          self.<< Exclusion.new(exclusion)
         end
         freeze
       end
     end
 
     class Artifact
- 
       attr_reader :type, :group_id, :artifact_id, :classifier, :version, :scope, :exclusions
 
-      ALLOWED_TYPES = ['jar', 'pom']
-      
-      def initialize( options, *args )
+      ALLOWED_TYPES = %w[jar pom].freeze
+
+      def initialize(options, *args)
         @type, @group_id, @artifact_id, @classifier, @version, @exclusions = *args
-        options.each do |k,v|
-          instance_variable_set( "@#{k}", v )
+        options.each do |k, v|
+          instance_variable_set("@#{k}", v)
         end
       end
 
-      def self.new( line )
+      def self.new(line)
         line = line.strip
-        index = line.index( /\s/ )
-        if index.nil?
-          return nil
-        end
+        index = line.index(/\s/)
+        return nil if index.nil?
         type = line[0..index].strip
-        unless ALLOWED_TYPES.member?( type )
-          return nil
-        end
+        return nil unless ALLOWED_TYPES.member?(type)
         line = line[index..-1]
         line.gsub!(/['"]/, '')
         line.strip!
 
         options = {}
         line.sub!(/,\s*:exclusions\s*(:|=>)\s*(\[[^\]]+\])/) do
-          options[ :exclusions ] = Exclusions.new( $2.strip )
+          options[:exclusions] = Exclusions.new(Regexp.last_match(2).strip)
           ''
         end
         line.sub!(/,\s*:([a-z]+)\s*(:|=>)\s*(:?[a-zA-Z0-9_]+)/) do
-          options[ $1.to_sym ] = $3.sub(/^:/, '')
+          options[Regexp.last_match(1).to_sym] = Regexp.last_match(3).sub(/^:/, '')
           ''
         end
         exclusions = nil
         line.sub!(/[,:]\s*\[(.+:.+,?\s*)+\]$/) do |a|
-          exclusions = Exclusions.new( a[1..-1].strip )
+          exclusions = Exclusions.new(a[1..-1].strip)
           ''
         end
 
         line.strip!
         line.gsub!(/,\s*/, ':')
 
-        if line.match(/[\[\(\)\]]/)
+        if line =~ /[\[\(\)\]]/
           index = line.index(/[\[\(].+$/)
           version = line[index..-1].sub(/:/, ', ')
           line = line[0..index - 1].strip.sub(/:$/, '')
@@ -153,7 +145,7 @@ module Jars
           warn line
           return nil
         end
-        super( options, type, group_id, artifact_id, classifier, version, exclusions )
+        super(options, type, group_id, artifact_id, classifier, version, exclusions)
       end
 
       def to_s
@@ -174,7 +166,7 @@ module Jars
       def to_coord_no_classifier
         args = [@group_id, @artifact_id]
         args << @type
-        args << MavenVersion.new( @version )
+        args << MavenVersion.new(@version)
         args.join(':')
       end
 
@@ -182,7 +174,7 @@ module Jars
         args = [@group_id, @artifact_id]
         args << @classifier if @classifier
         args << @type
-        args << MavenVersion.new( @version )
+        args << MavenVersion.new(@version)
         args.join(':')
       end
 
@@ -195,11 +187,11 @@ module Jars
 
     attr_reader :artifacts
 
-    def initialize( spec )
+    def initialize(spec)
       @artifacts = []
       spec.requirements.each do |req|
-        req.split( /\n/ ).each do |line|
-          if ( a = Artifact.new( line ) )
+        req.split(/\n/).each do |line|
+          if (a = Artifact.new(line))
             @artifacts << a
           end
         end

data/lib/jars/gemspec_pom.rb

@@ -1,5 +1,5 @@
 # this file is maven DSL and used by maven via jars/maven_exec.rb
 
-eval( File.read( File.join( File.dirname(__FILE__), 'attach_jars_pom.rb' ) ) )
+eval(File.read(File.join(File.dirname(__FILE__), 'attach_jars_pom.rb')))
 
-eval( File.read( File.join( File.dirname(__FILE__), 'output_jars_pom.rb' ) ) )
+eval(File.read(File.join(File.dirname(__FILE__), 'output_jars_pom.rb')))

data/lib/jars/installer.rb

@@ -3,18 +3,14 @@ require 'jars/maven_exec'
 
 module Jars
   class Installer
-
     class Dependency
-
       attr_reader :path, :file, :gav, :scope, :type, :coord
 
-      def self.new( line )
-        if line.match( /:jar:|:pom:/ )
-          super
-        end
+      def self.new(line)
+        super if line =~ /:jar:|:pom:/
       end
 
-      def setup_type( line )
+      def setup_type(line)
         if line.index(':pom:')
           @type = :pom
         elsif line.index(':jar:')
@@ -23,7 +19,7 @@ module Jars
       end
       private :setup_type
 
-      def setup_scope( line )
+      def setup_scope(line)
         @scope =
           case line
           when /:provided:/
@@ -37,25 +33,25 @@ module Jars
       private :setup_scope
 
       REG = /:jar:|:pom:|:test:|:compile:|:runtime:|:provided:|:system:/
-      EMPTY = ''
-      def initialize( line )
-        setup_type( line )
+      EMPTY = ''.freeze
+      def initialize(line)
+        setup_type(line)
 
         line.strip!
-        @coord = line.sub( /:[^:]+:([A-Z]:\\)?[^:]+$/, EMPTY )
-        first, second = @coord.split( /:#{type}:/ )
-        group_id, artifact_id = first.split( /:/ )
-        parts = group_id.split( '.' )
+        @coord = line.sub(/:[^:]+:([A-Z]:\\)?[^:]+$/, EMPTY)
+        first, second = @coord.split(/:#{type}:/)
+        group_id, artifact_id = first.split(/:/)
+        parts = group_id.split('.')
         parts << artifact_id
-        parts << second.split( ':' )[ -1 ]
+        parts << second.split(':')[-1]
         @file = line.slice(@coord.length, line.length).sub(REG, EMPTY).strip
         last = @file.reverse.index /\\|\//
         parts << line[-last..-1]
-        @path = File.join( parts ).strip
+        @path = File.join(parts).strip
 
-        setup_scope( line )
+        setup_scope(line)
 
-        @system = line.index(':system:') != nil
+        @system = !line.index(':system:').nil?
         @gav = @coord.sub(REG, ':')
       end
 
@@ -64,24 +60,24 @@ module Jars
       end
     end
 
-    def self.install_jars( write_require_file = false )
-      new.install_jars( write_require_file )
+    def self.install_jars(write_require_file = false)
+      new.install_jars(write_require_file)
     end
-    
-    def self.load_from_maven( file )
+
+    def self.load_from_maven(file)
       result = []
-      File.read( file ).each_line do |line|
-        dep = Dependency.new( line )
+      File.read(file).each_line do |line|
+        dep = Dependency.new(line)
         result << dep if dep && dep.scope == :runtime
       end
       result
     end
 
-    def self.write_require_file( require_filename )
-      warn "deprecated"
+    def self.write_require_file(require_filename)
+      warn 'deprecated'
       if needs_to_write?(require_filename)
-        FileUtils.mkdir_p( File.dirname( require_filename ) )
-        f = File.open( require_filename, 'w' )
+        FileUtils.mkdir_p(File.dirname(require_filename))
+        f = File.open(require_filename, 'w')
         f.puts COMMENT
         f.puts "require 'jar_dependencies'"
         f.puts
@@ -89,113 +85,115 @@ module Jars
       end
     end
 
-    def self.vendor_file( dir, dep )
+    def self.vendor_file(dir, dep)
       if !dep.system? && dep.type == :jar && dep.scope == :runtime
-        vendored = File.join( dir, dep.path )
-        FileUtils.mkdir_p( File.dirname( vendored ) )
-        FileUtils.cp( dep.file, vendored )
+        vendored = File.join(dir, dep.path)
+        FileUtils.mkdir_p(File.dirname(vendored))
+        FileUtils.cp(dep.file, vendored)
       end
     end
 
-    def self.write_dep( file, dir, dep, vendor )
-      warn "deprecated"
-      print_require_jar( file, dep )
+    def self.write_dep(file, _dir, dep, _vendor)
+      warn 'deprecated'
+      print_require_jar(file, dep)
     end
 
-    def self.print_require_jar( file, dep, fallback = false )
+    def self.print_require_jar(file, dep, fallback = false)
       return if dep.type != :jar || dep.scope != :runtime
       if dep.system?
-        file.puts( "require( '#{dep.file}' )" ) if file
+        file.puts("require '#{dep.file}'") if file
       elsif dep.scope == :runtime
         if fallback
-          file.puts( "  require '#{dep.path}'" ) if file
+          file.puts("  require '#{dep.path}'") if file
         else
-          file.puts( "  require_jar( '#{dep.gav.gsub( ':', "', '" )}' )" ) if file
+          file.puts("  require_jar '#{dep.gav.gsub(':', "', '")}'") if file
         end
       end
     end
 
-    COMMENT = '# this is a generated file, to avoid over-writing it just delete this comment'
+    COMMENT = '# this is a generated file, to avoid over-writing it just delete this comment'.freeze
     def self.needs_to_write?(require_filename)
-      require_filename and (not File.exists?( require_filename ) or File.read( require_filename ).match( COMMENT))
+      require_filename && (!File.exist?(require_filename) || File.read(require_filename).match(COMMENT))
     end
 
-    def self.install_deps( deps, dir, require_filename, vendor )
-      warn "deprecated"
-      write_require_jars( deps, require_filename )
-      vendor_jars( deps, dir ) if dir && vendor
+    def self.install_deps(deps, dir, require_filename, vendor)
+      warn 'deprecated'
+      write_require_jars(deps, require_filename)
+      vendor_jars(deps, dir) if dir && vendor
     end
 
-    def self.write_require_jars( deps, require_filename )
+    def self.write_require_jars(deps, require_filename)
       if needs_to_write?(require_filename)
-        FileUtils.mkdir_p( File.dirname( require_filename ) )
-        File.open( require_filename, 'w' ) do |f|
+        FileUtils.mkdir_p(File.dirname(require_filename))
+        File.open(require_filename, 'w') do |f|
           f.puts COMMENT
-          f.puts "begin"
+          f.puts 'begin'
           f.puts "  require 'jar_dependencies'"
-          f.puts "rescue LoadError"
+          f.puts 'rescue LoadError'
           deps.each do |dep|
-             # do not use require_jar method
-            print_require_jar( f, dep, true )
+            # do not use require_jar method
+            print_require_jar(f, dep, true)
           end
-          f.puts "end"
+          f.puts 'end'
           f.puts
-          f.puts "if defined? Jars"
+          f.puts 'if defined? Jars'
           deps.each do |dep|
-            print_require_jar( f, dep )
+            print_require_jar(f, dep)
           end
-          f.puts "end"
+          f.puts 'end'
           yield f if block_given?
         end
       end
     end
 
-    def self.vendor_jars( deps, dir )
+    def self.vendor_jars(deps, dir)
       deps.each do |dep|
-        vendor_file( dir, dep )
+        vendor_file(dir, dep)
       end
     end
 
-    def initialize( spec = nil )
-      @mvn = MavenExec.new( spec )
+    def initialize(spec = nil)
+      @mvn = MavenExec.new(spec)
     end
 
-    def spec; @mvn.spec end
+    def spec
+      @mvn.spec
+    end
 
-    def vendor_jars( write_require_file = true, vendor_dir = nil )
+    def vendor_jars(write_require_file = true, vendor_dir = nil)
       return unless has_jars?
-      if Jars.to_prop( Jars::VENDOR ) == 'false'
+      if Jars.to_prop(Jars::VENDOR) == 'false'
         vendor_dir = nil
       else
         vendor_dir ||= spec.require_path
       end
-      do_install( vendor_dir, write_require_file )
+      do_install(vendor_dir, write_require_file)
     end
 
     def self.vendor_jars!(vendor_dir = nil)
       new.vendor_jars!(true, vendor_dir)
     end
 
-    def vendor_jars!( write_require_file = true, vendor_dir = nil )
+    def vendor_jars!(write_require_file = true, vendor_dir = nil)
       vendor_dir ||= spec.require_path
-      do_install( vendor_dir, write_require_file )
+      do_install(vendor_dir, write_require_file)
     end
 
-    def install_jars( write_require_file = true )
+    def install_jars(write_require_file = true)
       return unless has_jars?
-      do_install( nil, write_require_file )
+      do_install(nil, write_require_file)
     end
 
-    def ruby_maven_install_options=( options )
-      @mvn.ruby_maven_install_options=( options )
+    def ruby_maven_install_options=(options)
+      @mvn.ruby_maven_install_options = options
     end
 
     def has_jars?
       # first look if there are any requirements in the spec
       # and then if gem depends on jar-dependencies for runtime.
       # only then install the jars declared in the requirements
-      result = ( spec = self.spec ) && ! spec.requirements.empty? &&
-        spec.dependencies.detect { |d| d.name == 'jar-dependencies' && d.type == :runtime } != nil
+      result = (spec = self.spec) && !spec.requirements.empty? &&
+               spec.dependencies.detect { |d| d.name == 'jar-dependencies' && d.type == :runtime } != nil
       if result && spec.platform.to_s != 'java'
         Jars.warn "\njar dependencies found on non-java platform gem - do not install jars\n"
         false
@@ -203,42 +201,40 @@ module Jars
         result
       end
     end
-    alias_method :jars?, :has_jars?
+    alias jars? has_jars?
 
     private
 
-    def do_install( vendor_dir, write_require_file )
+    def do_install(vendor_dir, write_require_file)
       if !spec.require_paths.include?(vendor_dir) && vendor_dir
         raise "vendor dir #{vendor_dir} not in require_paths of gemspec #{spec.require_paths}"
       end
-      target_dir = File.join( @mvn.basedir, vendor_dir || spec.require_path )
-      jars_file = File.join( target_dir, "#{spec.name}_jars.rb" )
+      target_dir = File.join(@mvn.basedir, vendor_dir || spec.require_path)
+      jars_file = File.join(target_dir, "#{spec.name}_jars.rb")
 
       # write out new jars_file it write_require_file is true or
       # check timestamps:
       # do not generate file if specfile is older then the generated file
-      if ! write_require_file &&
-          File.exists?( jars_file ) &&
-          File.mtime( @mvn.specfile ) < File.mtime( jars_file )
+      if !write_require_file &&
+         File.exist?(jars_file) &&
+         File.mtime(@mvn.specfile) < File.mtime(jars_file)
         # leave jars_file as is
         jars_file = nil
       end
-      deps = install_dependencies()
-      self.class.write_require_jars( deps, jars_file )
-      if vendor_dir
-        self.class.vendor_jars( deps, target_dir )
-      end
+      deps = install_dependencies
+      self.class.write_require_jars(deps, jars_file)
+      self.class.vendor_jars(deps, target_dir) if vendor_dir
     end
 
     def install_dependencies
-      deps = File.join( @mvn.basedir, 'deps.lst' )
+      deps = File.join(@mvn.basedir, 'deps.lst')
 
       puts "  jar dependencies for #{spec.spec_name} . . ." unless Jars.quiet?
-      @mvn.resolve_dependencies_list( deps )
+      @mvn.resolve_dependencies_list(deps)
 
-      self.class.load_from_maven( deps )
+      self.class.load_from_maven(deps)
     ensure
-      FileUtils.rm_f( deps ) if deps
+      FileUtils.rm_f(deps) if deps
     end
   end
   # to stay backward compatible