jar-dependencies 0.3.9 → 0.4.1

data/lib/jars/lock.rb

@@ -2,59 +2,57 @@ require 'jars/maven_exec'
 
 module Jars
   class JarDetails < Array
-
     def scope
-      self[ -2 ].to_sym
+      self[-2].to_sym
     end
 
     def file
-      file = self[ -1 ].strip
+      file = self[-1].strip
       file.empty? ? path : file
     end
 
     def group_id
-      self[ 0 ]
+      self[0]
     end
 
     def artifact_id
-      self[ 1 ]
+      self[1]
     end
 
     def version
-      self[ -3 ]
+      self[-3]
     end
 
     def classifier
-      size == 5 ? nil : self[ 2 ]
+      size == 5 ? nil : self[2]
     end
 
     def gacv
-      classifier ? self[ 0..3 ] : self[ 0..2 ]
+      classifier ? self[0..3] : self[0..2]
     end
 
     def path
       if scope == :system
         # replace maven like system properties embedded into the string
-        self[ -1 ].gsub( /\$\{[a-zA-Z.]+\}/ ) do |a|
-          ENV_JAVA[ a[2..-2] ] || a
+        self[-1].gsub(/\$\{[a-zA-Z.]+\}/) do |a|
+          ENV_JAVA[a[2..-2]] || a
         end
       else
-        File.join( Jars.home, group_id.gsub(/[.]/, '/'), artifact_id, version, gacv[ 1..-1 ].join( '-' ) + '.jar' )
+        File.join(Jars.home, group_id.gsub(/[.]/, '/'), artifact_id, version, gacv[1..-1].join('-') + '.jar')
       end
     end
   end
 
   class Lock
-
-    def initialize( file )
+    def initialize(file)
       @file = file
     end
 
-    def process( scope )
+    def process(scope)
       scope ||= :runtime
-      File.read( @file ).each_line do |line|
-        next if not line =~ /:.+:/
-        jar = JarDetails.new( line.strip.sub( /:jar:/, ':' ).sub( /:$/, ': ' ).split( /:/ ) )
+      File.read(@file).each_line do |line|
+        next if line !~ /:.+:/
+        jar = JarDetails.new(line.strip.sub(/:jar:/, ':').sub(/:$/, ': ').split(/:/))
         case scope
         when :all
           yield jar
@@ -66,7 +64,7 @@ module Jars
           yield jar if jar.scope == :provided
         when :runtime
           # jar.scope is maven scope
-          yield jar if jar.scope != :test and jar.scope != :provided
+          yield jar if (jar.scope != :test) && (jar.scope != :provided)
         when :test
           yield jar
         end

data/lib/jars/lock_down.rb

@@ -6,24 +6,23 @@ require 'jars/gemspec_artifacts'
 
 module Jars
   class LockDown
-
     attr_reader :debug, :verbose
 
-    def initialize( debug, verbose )
+    def initialize(debug, verbose)
       @debug = debug
       @verbose = verbose
     end
 
     def maven_new
-      factory = MavenFactory.new( {}, @debug, @verbose )
-      pom = File.expand_path( '../lock_down_pom.rb', __FILE__ )
-      m = factory.maven_new( pom )
-      m[ 'jruby.plugins.version' ] = Jars::JRUBY_PLUGINS_VERSION
-      m[ 'dependency.plugin.version' ] = Jars::DEPENDENCY_PLUGIN_VERSION
-      m[ 'jars.basedir' ] = File.expand_path( basedir )
-      jarfile = File.expand_path( Jars.jarfile )
-      m[ 'jars.jarfile' ] = jarfile if File.exists?( jarfile )
-      attach_jar_coordinates_from_bundler_dependencies( m )
+      factory = MavenFactory.new({}, @debug, @verbose)
+      pom = File.expand_path('../lock_down_pom.rb', __FILE__)
+      m = factory.maven_new(pom)
+      m['jruby.plugins.version'] = Jars::JRUBY_PLUGINS_VERSION
+      m['dependency.plugin.version'] = Jars::DEPENDENCY_PLUGIN_VERSION
+      m['jars.basedir'] = File.expand_path(basedir)
+      jarfile = File.expand_path(Jars.jarfile)
+      m['jars.jarfile'] = jarfile if File.exist?(jarfile)
+      attach_jar_coordinates_from_bundler_dependencies(m)
       m
     end
     private :maven_new
@@ -33,28 +32,28 @@ module Jars
     end
 
     def basedir
-      File.expand_path( '.' )
+      File.expand_path('.')
     end
 
-    def attach_jar_coordinates_from_bundler_dependencies( maven )
+    def attach_jar_coordinates_from_bundler_dependencies(maven)
       load_path = $LOAD_PATH.dup
       require 'bundler'
-      #TODO make this group a commandline option
-      Bundler.setup( 'default' )
-      maven.property( "jars.bundler", true )
+      # TODO: make this group a commandline option
+      Bundler.setup('default')
+      maven.property('jars.bundler', true)
       done = []
       index = 0
-      cwd = File.expand_path( "." )
-      Gem.loaded_specs.each do |name, spec|
+      cwd = File.expand_path('.')
+      Gem.loaded_specs.each do |_name, spec|
         # if gemspec is local then include all dependencies
-        maven.attach_jars( spec, cwd == spec.full_gem_path )
+        maven.attach_jars(spec, cwd == spec.full_gem_path)
       end
     rescue Exception => e
       case e.class.to_s
       when 'LoadError'
         if Jars.verbose?
           warn e.message
-          warn "no bundler found - ignore Gemfile if exists"
+          warn 'no bundler found - ignore Gemfile if exists'
         end
       when 'Bundler::GemfileNotFound'
         # do nothing then as we have bundler but no Gemfile
@@ -66,41 +65,41 @@ module Jars
         raise e
       end
     ensure
-      $LOAD_PATH.replace( load_path )
+      $LOAD_PATH.replace(load_path)
     end
 
-    def lock_down( options = {} )
-      vendor_dir = File.expand_path( options[ :vendor_dir ] ) if options[ :vendor_dir ]
-      out = File.expand_path( '.jars.output' )
-      tree = File.expand_path( '.jars.tree' )
-      maven.property( 'jars.outputFile', out )
-      maven.property( 'maven.repo.local', Jars.local_maven_repo )
-      maven.property( 'jars.home', vendor_dir ) if vendor_dir
-      maven.property( 'jars.lock', File.expand_path( Jars.lock ) )
-      maven.property( 'jars.force', options[ :force ] == true )
-      maven.property( 'jars.update', options[ :update ] ) if options[ :update ]
+    def lock_down(options = {})
+      vendor_dir = File.expand_path(options[:vendor_dir]) if options[:vendor_dir]
+      out = File.expand_path('.jars.output')
+      tree = File.expand_path('.jars.tree')
+      maven.property('jars.outputFile', out)
+      maven.property('maven.repo.local', Jars.local_maven_repo)
+      maven.property('jars.home', vendor_dir) if vendor_dir
+      maven.property('jars.lock', File.expand_path(Jars.lock))
+      maven.property('jars.force', options[:force] == true)
+      maven.property('jars.update', options[:update]) if options[:update]
       # tell not to use Jars.lock as part of POM when running mvn
-      maven.property( 'jars.skip.lock', true )
+      maven.property('jars.skip.lock', true)
 
-      args = [ 'gem:jars-lock' ]
-      if options[ :tree ]
-        args += [ 'dependency:tree', '-P -gemfile.lock', '-DoutputFile=' + tree ]
+      args = ['gem:jars-lock']
+      if options[:tree]
+        args += ['dependency:tree', '-P -gemfile.lock', '-DoutputFile=' + tree]
       end
 
       puts
       puts '-- jar root dependencies --'
       puts
-      status = maven.exec( *args )
+      status = maven.exec(*args)
       exit 1 unless status
-      if File.exists?( tree )
+      if File.exist?(tree)
         puts
         puts '-- jar dependency tree --'
         puts
-        puts File.read( tree )
+        puts File.read(tree)
         puts
       end
       puts
-      puts File.read( out ).gsub( /#{File.dirname(out)}\//, '' )
+      puts File.read(out).gsub(/#{File.dirname(out)}\//, '')
       puts
     ensure
       FileUtils.rm_f out

data/lib/jars/lock_down_pom.rb

@@ -1,27 +1,30 @@
 # this file is maven DSL and used by maven via jars/lock_down.rb
 
-basedir( ENV_JAVA[ "jars.basedir" ] )
+basedir(ENV_JAVA['jars.basedir'])
 
-eval( File.read( File.join( File.dirname(__FILE__), 'attach_jars_pom.rb' ) ) )
+eval(File.read(File.join(File.dirname(__FILE__), 'attach_jars_pom.rb')))
 
-jfile = ENV_JAVA[ "jars.jarfile" ]
-jarfile( jfile ) if jfile
+jfile = ENV_JAVA['jars.jarfile']
+jarfile(jfile) if jfile
 
 # need to fix the version of this plugin for gem:jars_lock goal
-jruby_plugin :gem, ENV_JAVA[ "jruby.plugins.version" ]
-
+jruby_plugin :gem, ENV_JAVA['jruby.plugins.version']
 
 # if you use bundler we collect all root jar dependencies
 # from each gemspec file. otherwise we need to resolve
 # the gemspec artifact in the maven way
-unless ENV_JAVA[ "jars.bundler" ]
+unless ENV_JAVA['jars.bundler']
 
-  gemspec rescue nil
+  begin
+    gemspec
+  rescue
+    nil
+  end
 
 end
 
-properties( 'project.build.sourceEncoding' => 'utf-8' )
+properties('project.build.sourceEncoding' => 'utf-8')
 
-plugin :dependency, ENV_JAVA[ "dependency.plugin.version" ]
+plugin :dependency, ENV_JAVA['dependency.plugin.version']
 
-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/maven_exec.rb

@@ -3,9 +3,8 @@ require 'jars/maven_factory'
 
 module Jars
   class MavenExec
-
-    def find_spec( allow_no_file )
-      specs = Dir[ '*.gemspec' ]
+    def find_spec(allow_no_file)
+      specs = Dir['*.gemspec']
       case specs.size
       when 0
         raise 'no gemspec found' unless allow_no_file
@@ -19,64 +18,65 @@ module Jars
 
     attr_reader :basedir, :spec, :specfile
 
-    def initialize( spec = nil )
+    def initialize(spec = nil)
       @options = {}
-      setup( spec )
+      setup(spec)
     rescue StandardError, LoadError => e
       # If spec load fails, skip looking for jar-dependencies
-      warn "jar-dependencies: " + e.to_s
-      warn e.backtrace.join( "\n" ) if Jars.verbose?
+      warn 'jar-dependencies: ' + e.to_s
+      warn e.backtrace.join("\n") if Jars.verbose?
     end
 
-    def setup( spec = nil, allow_no_file = false )
-      spec ||= find_spec( allow_no_file )
+    def setup(spec = nil, allow_no_file = false)
+      spec ||= find_spec(allow_no_file)
 
       case spec
       when String
-        @specfile = File.expand_path( spec )
-        @basedir = File.dirname( @specfile )
-        Dir.chdir( @basedir ) do
-          spec = eval( File.read( @specfile ), TOPLEVEL_BINDING, @specfile )
+        @specfile = File.expand_path(spec)
+        @basedir = File.dirname(@specfile)
+        Dir.chdir(@basedir) do
+          spec = eval(File.read(@specfile), TOPLEVEL_BINDING, @specfile)
         end
       when Gem::Specification
-        if File.exists?( spec.spec_file )
+        if File.exist?(spec.loaded_from)
           @basedir = spec.gem_dir
-          @specfile = spec.spec_file
+          @specfile = spec.loaded_from
         else
           # this happens with bundle and local gems
           # there the spec_file is "not installed" but inside
           # the gem_dir directory
-          Dir.chdir( spec.gem_dir ) do
-            setup( nil, true )
+          Dir.chdir(spec.gem_dir) do
+            setup(nil, true)
           end
         end
       when NilClass
       else
-        raise 'spec must be either String or Gem::Specification'
+        Jars.debug('spec must be either String or Gem::Specification. ' +
+                   'File an issue on github if you need it.')
       end
       @spec = spec
     end
 
-    def ruby_maven_install_options=( options )
+    def ruby_maven_install_options=(options)
       @options = options
     end
 
-    def resolve_dependencies_list( file )
-      factory = MavenFactory.new( @options )
-      maven = factory.maven_new( File.expand_path( '../gemspec_pom.rb', __FILE__ ) )
+    def resolve_dependencies_list(file)
+      factory = MavenFactory.new(@options)
+      maven = factory.maven_new(File.expand_path('../gemspec_pom.rb', __FILE__))
 
-      is_local_file = File.expand_path( File.dirname( @specfile ) ) == File.expand_path( Dir.pwd )
-      maven.attach_jars( @spec, is_local_file )
+      is_local_file = File.expand_path(File.dirname(@specfile)) == File.expand_path(Dir.pwd)
+      maven.attach_jars(@spec, is_local_file)
 
-      maven[ 'jars.specfile' ] = "#{@specfile}"
-      maven[ 'outputAbsoluteArtifactFilename' ] = 'true'
-      maven[ 'includeTypes' ] = 'jar'
-      maven[ 'outputScope' ] = 'true'
-      maven[ 'useRepositoryLayout' ] = 'true'
-      maven[ 'outputDirectory' ] = "#{Jars.home}"
-      maven[ 'outputFile' ] = "#{file}"
+      maven['jars.specfile'] = @specfile.to_s
+      maven['outputAbsoluteArtifactFilename'] = 'true'
+      maven['includeTypes'] = 'jar'
+      maven['outputScope'] = 'true'
+      maven['useRepositoryLayout'] = 'true'
+      maven['outputDirectory'] = Jars.home.to_s
+      maven['outputFile'] = file.to_s
 
-      maven.exec( 'dependency:copy-dependencies', 'dependency:list' )
+      maven.exec('dependency:copy-dependencies', 'dependency:list')
     end
   end
 end

data/lib/jars/maven_factory.rb

@@ -3,78 +3,71 @@ require 'jars/gemspec_artifacts'
 
 module Jars
   class MavenFactory
-
     module AttachJars
-
-      def attach_jars( spec, all_dependencies = false )
+      def attach_jars(spec, all_dependencies = false)
         @index ||= 0
         @done ||= []
 
-        deps = GemspecArtifacts.new( spec )
+        deps = GemspecArtifacts.new(spec)
         deps.artifacts.each do |a|
           # for this gemspec we want to include all artifacts but
           # for all others we want to exclude provided and test artifacts
-          if !@done.include?( a.key ) and (all_dependencies or (a.scope != 'provided' and a.scope != 'test'))
-
-            # ruby dsl is not working reliably for classifier
-            self[ "jars.#{@index}" ] = a.to_coord_no_classifier
-            if a.exclusions
-              jndex = 0
-              a.exclusions.each do |ex|
-                self[ "jars.#{@index}.exclusions.#{jndex}" ] = ex.to_s
-                jndex += 1
-              end
+          next unless !@done.include?(a.key) && (all_dependencies || ((a.scope != 'provided') && (a.scope != 'test')))
+
+          # ruby dsl is not working reliably for classifier
+          self["jars.#{@index}"] = a.to_coord_no_classifier
+          if a.exclusions
+            jndex = 0
+            a.exclusions.each do |ex|
+              self["jars.#{@index}.exclusions.#{jndex}"] = ex.to_s
+              jndex += 1
             end
-            self[ "jars.#{@index}.scope" ] = a.scope if a.scope
-            if a.classifier
-              self[ "jars.#{@index}.classifier" ] = a.classifier
-            end
-            @index += 1
-            @done << a.key
           end
+          self["jars.#{@index}.scope"] = a.scope if a.scope
+          self["jars.#{@index}.classifier"] = a.classifier if a.classifier
+          @index += 1
+          @done << a.key
         end
       end
     end
 
     attr_reader :debug, :verbose
 
-    def initialize( options = nil,  debug = Jars.debug?, verbose = Jars.verbose? )
+    def initialize(options = nil, debug = Jars.debug?, verbose = Jars.verbose?)
       @options = (options || {}).dup
-      @options.delete( :ignore_dependencies )
+      @options.delete(:ignore_dependencies)
       @debug = debug
       @verbose = verbose
       @installed_maven = false
     end
 
-    def maven_new( pom )
+    def maven_new(pom)
       lazy_load_maven
-      maven = setup( Maven::Ruby::Maven.new )
+      maven = setup(Maven::Ruby::Maven.new)
 
       maven.extend AttachJars
-      # TODO copy pom to tmp dir in case it is not a real file
-      maven.options[ '-f' ] = pom
+      # TODO: copy pom to tmp dir in case it is not a real file
+      maven.options['-f'] = pom
       maven
     end
 
     private
 
-    def setup( maven )
+    def setup(maven)
       maven.verbose = @verbose
-      if @debug
-        maven.options[ '-X' ] = nil
-      end
+      maven.options['-X'] = nil if @debug
       if @verbose
-        maven.options[ '-e' ] = nil
-      elsif not @debug
-        maven.options[ '--quiet' ] = nil
+        maven.options['-e'] = nil
+      elsif !@debug
+        maven.options['--quiet'] = nil
       end
-      maven[ 'verbose' ] = (@debug || @verbose) == true
+      maven['verbose'] = (@debug || @verbose) == true
 
       if Jars.maven_settings
-        maven.options[ '-s' ] = Jars::MavenSettings.effective_settings
+        maven.options['-s'] = Jars::MavenSettings.effective_settings
       end
 
-      maven[ 'maven.repo.local' ] = "#{java.io.File.new( Jars.local_maven_repo ).absolute_path}"
+      maven['maven.repo.local'] = java.io.File.new(Jars.local_maven_repo).absolute_path.to_s
 
       maven
     end
@@ -82,8 +75,8 @@ module Jars
     private
 
     def lazy_load_maven
-      add_gem_to_load_path( 'ruby-maven' )
-      add_gem_to_load_path( 'ruby-maven-libs' )
+      add_gem_to_load_path('ruby-maven')
+      add_gem_to_load_path('ruby-maven-libs')
       if @installed_maven
         puts
         puts 'using maven for the first time results in maven'
@@ -95,44 +88,44 @@ module Jars
       require 'maven/ruby/maven'
     end
 
-    def find_spec_via_rubygems( name, req )
+    def find_spec_via_rubygems(name, req)
       require 'rubygems/dependency'
-      dep = Gem::Dependency.new( name, req )
-      dep.matching_specs( true ).last
+      dep = Gem::Dependency.new(name, req)
+      dep.matching_specs(true).last
     end
 
-    def add_gem_to_load_path( name )
+    def add_gem_to_load_path(name)
       # if the gem is already activated => good
-      return if Gem.loaded_specs[ name ]
+      return if Gem.loaded_specs[name]
       # just install gem if needed and add it to the load_path
       # and leave activated gems as they are
-      req = requirement( name )
-      unless spec = find_spec_via_rubygems( name, req )
-        spec = install_gem( name, req )
+      req = requirement(name)
+      unless spec = find_spec_via_rubygems(name, req)
+        spec = install_gem(name, req)
       end
       unless spec
         raise "failed to resolve gem '#{name}' if you're using Bundler add it as a dependency"
       end
-      path = File.join( spec.full_gem_path, spec.require_path )
-      $LOAD_PATH << path unless $LOAD_PATH.include?( path )
+      path = File.join(spec.full_gem_path, spec.require_path)
+      $LOAD_PATH << path unless $LOAD_PATH.include?(path)
     end
 
-    def requirement( name )
-      jars = Gem.loaded_specs[ 'jar-dependencies' ]
+    def requirement(name)
+      jars = Gem.loaded_specs['jar-dependencies']
       dep = jars.nil? ? nil : jars.dependencies.detect { |d| d.name == name }
-      dep.nil? ? Gem::Requirement.create( '>0' ) : dep.requirement
+      dep.nil? ? Gem::Requirement.create('>0') : dep.requirement
     end
 
-    def install_gem( name, req )
+    def install_gem(name, req)
       @installed_maven = true
       puts "Installing gem '#{name}' . . ."
       require 'rubygems/dependency_installer'
-      inst = Gem::DependencyInstaller.new( @options ||= {} )
-      inst.install( name, req ).first
+      inst = Gem::DependencyInstaller.new(@options ||= {})
+      inst.install(name, req).first
     rescue => e
       if Jars.verbose?
-        warn "#{e.inspect}"
-        warn e.backtrace.join( "\n" )
+        warn e.inspect.to_s
+        warn e.backtrace.join("\n")
       end
       raise "there was an error installing '#{name} (#{req})' #{@options[:domain]}. please install it manually: #{e.inspect}"
     end