lock_jar 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fdc8665446b2c03fe7af8986a64e2f26e2c60b2b
-  data.tar.gz: 46e658bf1bd14e571797ed13e22af81390cdb86b
+  metadata.gz: 127144912becde98e2e9f80f09c4cc8539ac9444
+  data.tar.gz: 5cc472a575538541f16e46ad98f8cc788aa9670a
 SHA512:
-  metadata.gz: c7168fac6c7af56f0875c87e27c68353ebb3f36acf3efc8fa3edeaf40f29cc3dd32863770bd6f071e48d42019b96721611804086624813866cec2e71991dabcd
-  data.tar.gz: 772b77a7c9b2c1262c2bd8c9521797f31fcba17f294650e8b2bd379f29ee3aef75ea43aaafb8d1c1f5fd9496cbd7b87c8230c51ac46b661b89ff5224f11cae83
+  metadata.gz: 03900e1901e2442d270e32d33dd817880beb11b2d8593ec29266c92065593184f636e8cbc95815e5856966ec37095f899eac1e28feedb01cbecd99d1c6c7d920
+  data.tar.gz: 7c1e04d429617d7b95b139195312f8f2106c8c94e6f1b6fb52ccfc6995359d89bdc8135d4fae8025b3bceb04f4a15440a7cb9f462eb2cb2b89b2b5e9c61f9e51

data/.codeclimate.yml

@@ -0,0 +1,16 @@
+languages:
+   Ruby: true
+engines:
+  rubocop:
+    enabled: true
+    checks:
+      Rubocop/Rails/Output:
+        enabled: false
+ratings:
+   paths:
+   - lib/**
+exclude_paths:
+- spec/**/*
+- vendor/**/*
+- tmp/**/*
+- target/**/*

data/.rubocop.yml

@@ -0,0 +1,28 @@
+# This is the configuration used to check the rubocop source code.
+
+AllCops:
+  Exclude:
+    - 'tmp/**/*'
+    - 'target/**/*'
+    - 'vendor/**/*'
+    - 'spec/fixtures/**/*'
+
+Metrics/LineLength:
+  Max: 100
+  Exclude:
+    - 'spec/**/*'
+
+Metrics/MethodLength:
+  Max: 25
+
+Metrics/AbcSize:
+  Max: 30
+
+Metrics/CyclomaticComplexity:
+  Max: 10
+
+Style/PredicateName:
+  Enabled: false
+
+Style/Lambda:
+  Enabled: false

data/.travis.yml

@@ -1,3 +1,5 @@
+before_install:
+  - export JRUBY_OPTS="-Xcli.debug=true --debug"
 language: ruby
 rvm:
   - 1.9.3
@@ -7,4 +9,13 @@ rvm:
   - jruby-20mode
   - jruby-21mode
 
-script: bundle exec rspec spec
+script: bundle exec rake
+sudo: false
+
+addons:
+  code_climate:
+    repo_token: 3377046eefe5079936ac6dd66241c7fac6e56c632a34b653ef7896e31fa048c1
+
+cache:
+  directories:
+    - .spec-tmp

data/Gemfile

@@ -3,11 +3,14 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in lock_jar.gemspec
 gemspec
 
+group :test do
+  gem 'codeclimate-test-reporter', require: nil
+  gem 'jarfile_gem', path: 'spec/fixtures/jarfile_gem'
+end
 
 group :development do
-  gem 'guard-rspec', :require => false
+  gem 'guard-rspec', require: false
   gem 'pry'
   gem 'yard'
-  gem 'jruby-openssl',   :platforms => :jruby
-  gem 'rspec', '~> 2.14.1'
+  gem 'rubocop'
 end

data/Guardfile

@@ -3,7 +3,6 @@
 
 guard :rspec do
   watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb')  { "spec" }
+  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb') { 'spec' }
 end
-

data/README.md

@@ -1,6 +1,7 @@
 # LockJar
 
 [![Build Status](https://secure.travis-ci.org/mguymon/lock_jar.png?branch=master)](http://travis-ci.org/mguymon/lock_jar)
+[![Code Climate](https://codeclimate.com/github/mguymon/lock_jar/badges/gpa.svg)](https://codeclimate.com/github/mguymon/lock_jar)
 
 LockJar manages Java Jars for Ruby. Powered by [Naether](https://github.com/mguymon/naether) to
  create a frankenstein of Bundler and Maven. A Jarfile ([example](https://github.com/mguymon/lock_jar/blob/master/spec/support/Jarfile)) is used to generate a Jarfile.lock that contains all the resolved jar dependencies. The Jarfile.lock can be used to populate the classpath.
@@ -10,7 +11,7 @@ LockJar can:
 * From the [command line](https://github.com/mguymon/lock_jar/blob/master/README.md#command-line)
 * [Triggered from a Gem install](https://github.com/mguymon/lock_jar/blob/master/README.md#gem-integration)
 * [Integrated into Buildr](https://github.com/mguymon/lock_jar/blob/master/README.md#buildr-integration)
-* Experimental [integration with Bundler](https://github.com/mguymon/lock_jar/blob/master/README.md#bundler-integration)
+* [Integrated into Bundler](https://github.com/mguymon/lock_jar/blob/master/README.md#bundler-integration)
 
 https://github.com/mguymon/lock_jar
 
@@ -29,12 +30,12 @@ JRuby is natively supported. Ruby 1.9.3 and 2.1 uses [Rjb](http://rjb.rubyforge.
 A Jarfile is a simple file using a Ruby DSL for defining a project's dependencies using the following
 methods:
 
-* **local_repo( path )**: Set the local Maven repository, this were dependencies are downloaded to.
-* **remote_repo( url )**: Add additional url of remote Maven repository.
-* **group( groups )**: Set the group for nested jar or pom. A single or Array of groups can be set.
-* **jar( notations, opts = {} )**: Add Jar dependency in artifact notation, artifact:group:version as the bare minimum. A single or Array of notations can be passed. Default group is _default_, can be specified by setting _opts = { :group => ['group_name'] }_
-* **local( path )**: Add a local path to a Jar
-* **pom( pom_path, opts = {} )**: Add a local Maven pom, default is to load dependencies for `runtime` and `compile` scopes. To select the scopes to be loaded from the pom, set the _opts = { :scopes => ['test'] }_
+* **local_repo(path)**: Set the local Maven repository, this were dependencies are downloaded to.
+* **remote_repo(url)**: Add additional url of remote Maven repository.
+* **group(groups)**: Set the group for nested jar or pom. A single or Array of groups can be set.
+* **jar(notations, opts = {})**: Add Jar dependency in artifact notation, artifact:group:version as the bare minimum. A single or Array of notations can be passed. Default group is _default_, can be specified by setting _opts = { :group => ['group_name'] }_
+* **local(path)**: Add a local path to a Jar
+* **pom(pom_path, opts = {})**: Add a local Maven pom, default is to load dependencies for `runtime` and `compile` scopes. To select the scopes to be loaded from the pom, set the _opts = { :scopes => ['test'] }_
 * **without_default_maven_repo**: Do not use the default maven repo.
 
 #### Example Jarfile
@@ -55,7 +56,7 @@ methods:
 
 ### Resolving dependencies
 
-**LockJar.lock( *args )**: Using a Jarfile, creates a lock file. Depending on the type of arg, a different configuration is set.
+**LockJar.lock(*args)**: Using a Jarfile, creates a lock file. Depending on the type of arg, a different configuration is set.
 * _[String]_ will set the Jarfile path, e.g. `'/somewhere/Jarfile.different'`. Default jarfile is `'Jarfile'`
 * _[Hash]_ will set the options, e.g. `{ :local_repo => 'path' }`
   * **:download** _[Boolean]_ if true, will download jars to local repo. Defaults to true.
@@ -192,7 +193,7 @@ You can skip the _Jarfile_ and _Jarfile.lock_ to directly play with dependencies
 
 Since you skipped the locking part, mostly likely you will need to resolve the dependences in the block, just pass the _:resolve => true_ option to enable dependency resolution (also works for _LockJar.list_).
 
-    LockJar.load( :resolve => true ) do
+    LockJar.load(:resolve => true) do
       jar 'org.eclipse.jetty:example-jetty-embedded:jar:8.1.2.v20120308'
     end
 
@@ -233,9 +234,9 @@ Rakefile with default to install Jars using LockJar:
       require 'lock_jar'
 
       # get jarfile relative the gem dir
-      lockfile = File.expand_path( "../Jarfile.lock", __FILE__ )
+      lockfile = File.expand_path("../Jarfile.lock", __FILE__)
 
-      LockJar.install( lockfile )
+      LockJar.install(lockfile)
     end
 
 #### Work around for Rakefile default
@@ -252,10 +253,10 @@ Instead of rely in a Rakefile to install Jars when the Gem is installed, Jars ca
 Ruby needs to be called before calling `LockJar.load`. Only Jars that are missing are downloaded.
 
       #get jarfile relative the gem dir
-      lockfile = File.expand_path( "../Jarfile.lock", __FILE__ )
+      lockfile = File.expand_path("../Jarfile.lock", __FILE__)
 
       # Download any missing Jars
-      LockJar.install( lockfile )
+      LockJar.install(lockfile)
 
 ### Loading
 
@@ -263,10 +264,10 @@ With the Jars installed, loading the classpath for the Gem is simple.
 As part of the load process for the Gem (an entry file that is required, etc) use the following:
 
       #get jarfile relative the gem dir
-      lockfile = File.expand_path( "../Jarfile.lock", __FILE__ )
+      lockfile = File.expand_path("../Jarfile.lock", __FILE__)
 
       # Loads the ClassPath with Jars from the lockfile
-      LockJar.load( lockfile )
+      LockJar.load(lockfile)
 
 See also [loading Jars into a custom ClassLoader](https://github.com/mguymon/lock_jar/wiki/ClassLoader).
 
@@ -327,7 +328,7 @@ Generated the following lock files using **lock_jar:lock**
 
 ## Bundler Integration
 
-Bundler integration is **experimental** right now. [LockJar patches Bundler](https://github.com/mguymon/lock_jar/blob/master/lib/lock_jar/bundler.rb)
+[LockJar patches Bundler](https://github.com/mguymon/lock_jar/blob/master/lib/lock_jar/bundler.rb)
 to allow creation of a _Jarfile.lock_ when Bundler calls `install` and `update`. The dependencies from the _Jarfile.lock_ are automatically loaded when
 Bundler  calls `setup` and `require`. To enable this support, add this require to your _Gemfile_
 

data/Rakefile

@@ -1,24 +1,28 @@
 # encoding: utf-8
 
-require 'rubygems'
 require 'bundler'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+require 'bundler/gem_tasks'
+require 'rdoc/task'
+
 begin
   Bundler.setup(:default, :development)
 rescue Bundler::BundlerError => e
   $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
+  $stderr.puts 'Run `bundle install` to install missing gems'
   exit e.status_code
 end
-require 'rake'
-require "bundler/gem_tasks"
 
+RSpec::Core::RakeTask.new
+RuboCop::RakeTask.new
 
-require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
+  version = File.exist?('VERSION') ? File.read('VERSION') : ''
   rdoc.rdoc_dir = 'rdoc'
   rdoc.title = "lockjar #{version}"
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+task default: [:spec, :rubocop]

data/lib/lock_jar/buildr.rb

@@ -16,130 +16,136 @@
 require 'lock_jar'
 require 'lock_jar/domain/dsl'
 
+#
 module Buildr
-  
-  @@global_lockjar_dsl = nil
-  
+  attr_reader :global_lockjar_dsl
+
   class << self
-    def project_to_lockfile( project )
-      "#{project.name.gsub(/:/,'-')}.lock"
-    end
-    
-    def global_lockjar_dsl
-      @@global_lockjar_dsl 
+    def project_to_lockfile(project)
+      "#{project.name.gsub(/:/, '-')}.lock"
     end
   end
-  
-  def lock_jar( &blk )
-    @@global_lockjar_dsl = ::LockJar::Domain::Dsl.create(&blk) 
+
+  def lock_jar(&blk)
+    @global_lockjar_dsl = ::LockJar::Domain::Dsl.create(&blk)
   end
-  
-  namespace "lock_jar" do
-    desc "Lock dependencies for each project"    
-    task("lock") do 
-      projects.each do |project|   
-        if project.lockjar_dsl
-          # add buildr repos
-          repositories.remote.each do |repo|
-            project.lockjar_dsl.repository repo
-          end
-          ::LockJar.lock( project.lockjar_dsl, :lockfile => Buildr.project_to_lockfile(project) )       
+
+  namespace 'lock_jar' do
+    desc 'Lock dependencies for each project'
+    task('lock') do
+      projects.each do |project|
+        next if project.lockjar_dsl.nil?
+
+        # add buildr repos
+        repositories.remote.each do |repo|
+          project.lockjar_dsl.repository repo
         end
+        ::LockJar.lock(project.lockjar_dsl, lockfile: Buildr.project_to_lockfile(project))
       end
     end
   end
-  
+
   module LockJar
+    #
     module ProjectExtension
       include Extension
-    
-      def lock_jar( &blk )
-          @lockjar_dsl = ::LockJar::Domain::Dsl.create(&blk)    
-                   
-          unless Buildr.global_lockjar_dsl.nil?
-            @lockjar_dsl.merge( Buildr.global_lockjar_dsl )
-          end        
+
+      def lock_jar(&blk)
+        @lockjar_dsl = ::LockJar::Domain::Dsl.create(&blk)
+        @lockjar_dsl.merge(Buildr.global_lockjar_dsl) unless Buildr.global_lockjar_dsl.nil?
       end
-      
-      def lock_jars( *args )
+
+      def lock_jars(*args)
         lockfile = Buildr.project_to_lockfile(project)
         opts = {}
         groups = ['default']
-          
+
         args.each do |arg|
           if arg.is_a?(Hash)
-            opts.merge!( arg )
-          elsif arg.is_a?( String )
+            opts.merge!(arg)
+          elsif arg.is_a?(String)
             lockfile = arg
-          elsif arg.is_a?( Array )
+          elsif arg.is_a?(Array)
             groups = arg
           end
         end
-          
-        ::LockJar.list( lockfile, groups, opts )
+
+        ::LockJar.list(lockfile, groups, opts)
       end
-      
+
       def lockjar_dsl
         @lockjar_dsl || Buildr.global_lockjar_dsl
       end
-      
-      after_define do |project|      
-        task :compile => 'lock_jar:compile'
+
+      after_define do |project|
+        task compile: 'lock_jar:compile'
         task 'test:compile' => 'lock_jar:test:compile'
-        
+
         task 'eclipse' => 'lock_jar:eclipse'
-        
-        namespace "lock_jar" do
-            desc "Lock dependencies to JarFile"
-            task("lock") do 
-              dsl = project.lockjar_dsl
-              if dsl
-                # add buildr repos
-                repositories.remote do |repo|
-                  puts repo
-                  dsl.repository repo
-                end
-                ::LockJar.lock( dsl, :lockfile => "#{project.name}.lock" )
-              else
-                # XXX: output that there were no dependencies to lock
-                puts "No lock_jar dependencies to lock for #{project.name}" 
-              end              
-            end      
-            
-            task("compile") do
-              if project.lockjar_dsl && !File.exists?( Buildr.project_to_lockfile(project) )
-                raise "#{project.name}.lock does not exist, run #{project.name}:lockjar:lock first"
+
+        namespace 'lock_jar' do
+          desc 'Lock dependencies to JarFile'
+          task('lock') do
+            dsl = project.lockjar_dsl
+            if dsl
+              # add buildr repos
+              repositories.remote do |repo|
+                puts repo
+                dsl.repository repo
               end
-              jars = ::LockJar.list( Buildr.project_to_lockfile(project), ['default'] )
-              project.compile.with( jars )
+              ::LockJar.lock(dsl, lockfile: "#{project.name}.lock")
+            else
+              # XXX: output that there were no dependencies to lock
+              puts "No lock_jar dependencies to lock for #{project.name}"
             end
-            
-            task("test:compile") do
-              if project.lockjar_dsl && !File.exists?( Buildr.project_to_lockfile(project) )
-                raise "#{Buildr.project_to_lockfile(project)} does not exist, run #{project.name}:lockjar:lock first"
-              end
-              jars = ::LockJar.list( Buildr.project_to_lockfile(project), ['test'] )
-              
-              project.test.compile.with( jars )
-              project.test.with( jars )
+          end
+
+          task('compile') do
+            if project.lockjar_dsl && !File.exist?(Buildr.project_to_lockfile(project))
+              fail(
+                "#{project.name}.lock does not exist, run "\
+                "#{project.name}:lockjar:lock first"
+              )
             end
-            
-            task("eclipse") do
-              if project.lockjar_dsl && !File.exists?( Buildr.project_to_lockfile(project) )
-                raise "#{Buildr.project_to_lockfile(project)} does not exist, run #{project.name}:lockjar:lock first"
-              end
-              jars = ::LockJar.list( Buildr.project_to_lockfile(project), ['default'] )
-              project.compile.with( jars )
-              
-              jars = ::LockJar.list( Buildr.project_to_lockfile(project), ['test'] )
-              project.test.compile.with( jars )
+            jars = ::LockJar.list(Buildr.project_to_lockfile(project), ['default'])
+            project.compile.with(jars)
+          end
+
+          task('test:compile') do
+            if project.lockjar_dsl && !File.exist?(Buildr.project_to_lockfile(project))
+              fail(
+                "#{Buildr.project_to_lockfile(project)} does not exist, run"\
+                " #{project.name}:lockjar:lock first"
+              )
             end
+            jars = ::LockJar.list(Buildr.project_to_lockfile(project), ['test'])
+
+            project.test.compile.with(jars)
+            project.test.with(jars)
+          end
+
+          task('eclipse') do
+            if project.lockjar_dsl && !File.exist?(Buildr.project_to_lockfile(project))
+              fail(
+                "#{Buildr.project_to_lockfile(project)} does not exist, run "\
+                "#{project.name}:lockjar:lock first"
+              )
+            end
+            jars = ::LockJar.list(Buildr.project_to_lockfile(project), ['default'])
+            project.compile.with(jars)
+
+            jars = ::LockJar.list(Buildr.project_to_lockfile(project), ['test'])
+            project.test.compile.with(jars)
+          end
         end
       end
     end
   end
 end
 
-class Buildr::Project
-  include Buildr::LockJar::ProjectExtension
-end
+module Buildr
+  # Patch Builder::Project to include Buildr::LockJar::ProjectExtension
+  class Project
+    include Buildr::LockJar::ProjectExtension
+  end
+end