lock_jar 0.13.0 → 0.14.0

data/lib/lock_jar/bundler.rb

@@ -4,60 +4,102 @@ require 'lock_jar/domain/lockfile'
 require 'lock_jar/domain/dsl'
 require 'lock_jar/domain/gem_dsl'
 require 'lock_jar/domain/jarfile_dsl'
-require 'lock_jar/domain/dsl_helper'
+require 'lock_jar/domain/dsl_merger'
 
 module LockJar
-  
+  #
   class Bundler
-      
     class << self
-      
       attr_accessor :skip_lock
-    
+
       def load(*groups)
-        if groups && !groups.empty?  && File.exists?( 'Jarfile.lock')
-          
-          lockfile = LockJar::Domain::Lockfile.read( 'Jarfile.lock' )
-          
-          # expand merged paths to include gem base path
-          unless lockfile.merged.empty?
-            lockfile.merged = LockJar::Bundler.expand_gem_paths( lockfile.merged )
-          end
-          
-          LockJar.load( lockfile, groups )
-          
-          if ENV["DEBUG"]
-            puts "[LockJar] Loaded Jars for #{groups.inspect}: #{LockJar::Registry.instance.loaded_jars.inspect}"
-          end
+        return if groups.empty? || !File.exist?('Jarfile.lock')
+
+        lockfile = LockJar::Domain::Lockfile.read('Jarfile.lock')
+
+        # expand merged paths to include gem base path
+        unless lockfile.merged.empty?
+          lockfile.merged = LockJar::Bundler.expand_gem_paths(lockfile.merged)
         end
+
+        LockJar.load(lockfile, groups)
+
+        puts(
+          '[LockJar] Loaded Jars for #{groups.inspect}: '\
+          "#{LockJar::Registry.instance.loaded_jars.inspect}"
+        ) if ENV['DEBUG']
       end
-      
+
       def expand_gem_paths(merged)
-        
         merged_gem_paths = []
         Gem.path.each do |gem_root|
           merged.each do |merge|
+            next unless merge.start_with? 'gem:'
+
             # merged gems follow the notation: gem:gemname:path
-            if merge.start_with? 'gem:'
-              gem_path = merge.gsub(/^gem:.+:/, '')
-              gem_path = File.join( gem_root, gem_path )
-              if File.exists? gem_path
-                merged_gem_paths << gem_path
-              end
-            end
+            gem_path = merge.gsub(/^gem:.+:/, '')
+            gem_path = File.join(gem_root, gem_path)
+
+            merged_gem_paths << gem_path if File.exist? gem_path
           end
         end
-        
+
         merged_gem_paths
       end
+
+      # Create a lock file from bundled gems
+      def lock!(*opts)
+        definition = ::Bundler.definition
+
+        dsl = nil
+        gems_with_jars = []
+
+        jarfile_opt = opts.find { |option| option.is_a? String }
+
+        jarfile = File.expand_path(jarfile_opt || 'Jarfile')
+
+        # load local Jarfile
+        if File.exist?(jarfile)
+          dsl = LockJar::Domain::JarfileDsl.create(jarfile)
+
+        # Create new Dsl
+        else
+          dsl = LockJar::Domain::Dsl.new
+        end
+
+        definition.groups.each do |group|
+          puts '[LockJar] Group #{group}:' if ENV['DEBUG']
+
+          definition.specs_for([group]).each do |spec|
+            merged_dsl = merge_gem_dsl(dsl, spec, group)
+            dsl = merged_dsl if merged_dsl
+            gems_with_jars << "gem:#{spec.name}" if File.exist? File.join(spec.gem_dir, 'Jarfile')
+          end
+        end
+
+        puts "[LockJar] Locking Jars for: #{gems_with_jars.inspect}"
+        LockJar.lock(*([dsl] + opts))
+      end
+
+      private
+
+      def merge_gem_dsl(dsl, spec, group)
+        jarfile = File.join(spec.gem_dir, 'Jarfile')
+
+        return unless File.exist?(jarfile)
+
+        puts "[LockJar]   #{spec.name} has Jarfile" if ENV['DEBUG']
+        spec_dsl = LockJar::Domain::GemDsl.create(spec, jarfile)
+        LockJar::Domain::DslMerger.new(dsl, spec_dsl, [group.to_s]).merge
+      end
     end
   end
-  
 end
 
+# Patch Bundler module to allow LockJar to lock and load when Bundler is run
 module Bundler
   class << self
-    alias :_lockjar_extended_require :require
+    alias_method :_lockjar_extended_require, :require
     def require(*groups)
       LockJar::Bundler.load(*groups)
 
@@ -66,7 +108,7 @@ module Bundler
       _lockjar_extended_require
     end
 
-    alias :_lockjar_extended_setup :setup
+    alias_method :_lockjar_extended_setup, :setup
     def setup(*groups)
       LockJar::Bundler.load(*groups)
 
@@ -76,9 +118,10 @@ module Bundler
     end
   end
 
+  # Patch Bundler::Runtime.require and Bundler::Runtime.setup to execute
+  # Lockjar::Bundler.load
   class Runtime
-
-    alias :_lockjar_extended_require :require
+    alias_method :_lockjar_extended_require, :require
     def require(*groups)
       LockJar::Bundler.load(*groups)
 
@@ -87,7 +130,7 @@ module Bundler
       _lockjar_extended_require
     end
 
-    alias :_lockjar_extended_setup :setup
+    alias_method :_lockjar_extended_setup, :setup
     def setup(*groups)
       LockJar::Bundler.load(*groups)
 
@@ -97,59 +140,17 @@ module Bundler
     end
   end
 
+  # Patch Bundler::Definition.to_lock to run LockJar::Bundler.lock!
   class Definition
-    alias :_lockjar_extended_to_lock :to_lock
+    alias_method :_lockjar_extended_to_lock, :to_lock
     def to_lock
-      to_lock = _lockjar_extended_to_lock
-
-      if LockJar::Bundler.skip_lock != true
-        definition = Bundler.definition
-        #if !definition.send( :nothing_changed? )
-          gems_with_jars = []
-
-          # load local Jarfile
-          if File.exists?( 'Jarfile' )
-            dsl = LockJar::Domain::JarfileDsl.create( File.expand_path( 'Jarfile' ) )
-            gems_with_jars << 'jarfile:Jarfile'
-          # Create new Dsl
-          else
-            dsl = LockJar::Domain::Dsl.new
-          end
-
-          definition.groups.each do |group|
-            if ENV["DEBUG"]
-              puts "[LockJar] Group #{group}:"
-            end
+      result = _lockjar_extended_to_lock
 
-            definition.specs_for( [group] ).each do |spec|
-              gem_dir = spec.gem_dir
+      return result if LockJar::Bundler.skip_lock
 
-              jarfile = File.join( gem_dir, "Jarfile" )
+      LockJar::Bundler.lock!
 
-              if File.exists?( jarfile )
-                gems_with_jars << "gem:#{spec.name}"
-
-                if ENV["DEBUG"]
-                  puts "[LockJar]   #{spec.name} has Jarfile"
-                end
-
-                spec_dsl = LockJar::Domain::GemDsl.create( spec, "Jarfile" )
-
-                dsl = LockJar::Domain::DslHelper.merge( dsl, spec_dsl, group.to_s )
-              end
-            end
-
-          end
-
-          puts "[LockJar] Locking Jars for: #{gems_with_jars.inspect}"
-          LockJar.lock( dsl )
-        #elsif ENV["DEBUG"]
-        #  puts "[LockJar] Locking skiped, Gemfile has not changed"
-        #end
-      end
-
-      to_lock
+      result
     end
-
   end
-end
+end

data/lib/lock_jar/class_loader.rb

@@ -17,53 +17,51 @@ require 'lock_jar'
 require 'naether'
 
 module LockJar
-  
   #
   # Create a ClassLoader populated by a lockfile
   #
   # @author Michael Guymon
   #
   class ClassLoader
-    
     # Create new instance, populating ClassLoader with lockfile
-    # 
+    #
     # @param [String] lockfile path
-    def initialize( lockfile )
+    def initialize(lockfile)
       # XXX: ensure Naether has been loaded, this should be handled less
       #     clumsily
       LockJar::Runtime.instance.resolver(nil)
-      @class_loader = com.tobedevoured.naether.PathClassLoader.new(JRuby.runtime.jruby_class_loader)
-      
-      jars = LockJar.list( lockfile, :local_paths => true )
+      @class_loader = com.tobedevoured.naether.PathClassLoader.new(
+        JRuby.runtime.jruby_class_loader)
+
+      jars = LockJar.list(lockfile, local_paths: true)
       jars.each do |jar|
-        add_path( jar )
-      end      
+        add_path(jar)
+      end
     end
-    
+
     # Execute block
     #
     # @param [Block] blk
-    def isolate(&blk)    
-      instance_eval(&blk)      
+    def isolate(&blk)
+      instance_eval(&blk)
     end
-    
+
     # Add path to the ClassLoader
     #
     # @param [String] path of Jar or directory to add to ClassLoader
     # @return [Boolean] if added
-    def add_path( path )
-      @class_loader.addPath( path )
+    def add_path(path)
+      @class_loader.addPath(path)
     end
-    
+
     #
     # Create new instance of a Java class using the populated ClassLoader
-    # 
+    #
     # @param [String] clazz fully qualified Java class
     # @param [Array] args arguments for constructing the Java class
     # @return [Object]
-    def new_instance( clazz, *args )
-      @class_loader.newInstance( clazz, *args )      
+    def new_instance(clazz, *args)
+      @class_loader.newInstance(clazz, *args)
     end
-    
   end
-end
+end

data/lib/lock_jar/cli.rb

@@ -4,64 +4,72 @@ require 'lock_jar'
 require 'lock_jar/logging'
 
 module LockJar
-
+  #
   class CLI < Thor
-
+    #
     module ClassMethods
       def generate_lockfile_option
-        method_option :lockfile,
-          aliases: "-l",
+        method_option(
+          :lockfile,
+          aliases: '-l',
           default: 'Jarfile.lock',
-          desc: "Path to Jarfile.lock"
+          desc: 'Path to Jarfile.lock'
+        )
       end
 
       def generate_scopes_option
-        method_option :scopes,
-          aliases: "-s",
+        method_option(
+          :scopes,
+          aliases: '-s',
           default: ['default'],
-          desc: "Scopes to install from Jarfile.lock",
-          :type => :array
+          desc: 'Scopes to install from Jarfile.lock',
+          type: :array
+        )
       end
 
       def generate_jarfile_option
-        method_option :jarfile,
-          aliases: "-j",
+        method_option(
+          :jarfile,
+          aliases: '-j',
           default: 'Jarfile',
-          desc: "Path to Jarfile"
+          desc: 'Path to Jarfile'
+        )
       end
 
       def verbose_option
-        method_option :verbose,
-          aliases: "-v",
+        method_option(
+          :verbose,
+          aliases: '-v',
           type: :boolean,
-          desc: "Verbose output"
+          desc: 'Verbose output'
+        )
       end
     end
     extend(ClassMethods)
 
-    desc "version", "LockJar version"
+    desc 'version', 'LockJar version'
     def version
       puts LockJar::VERSION
     end
 
-    desc "install", "Install Jars from a Jarfile.lock"
+    desc 'install', 'Install Jars from a Jarfile.lock'
     generate_lockfile_option
     generate_scopes_option
     verbose_option
     def install
       handle_verbose(options[:verbose])
       puts "Installing Jars from #{options[:lockfile]} for #{options[:scopes].inspect}"
-      LockJar.install( options[:lockfile], options[:scopes] )
+      LockJar.install(options[:lockfile], options[:scopes])
     end
 
-    desc "list", "List Jars from a Jarfile.lock"
+    desc 'list', 'List Jars from a Jarfile.lock'
     generate_lockfile_option
     generate_scopes_option
     verbose_option
     def list
       handle_verbose(options[:verbose])
       puts "Listing Jars from #{options[:lockfile]} for #{options[:scopes].inspect}"
-      puts LockJar.list( options[:lockfile], options[:scopes] ).inspect
+      puts LockJar.list(options[:lockfile], options[:scopes]).inspect
     end
 
     desc 'lock', 'Lock Jars in a Jarfile.lock'
@@ -71,15 +79,14 @@ module LockJar
     def lock
       handle_verbose(options[:verbose])
       puts "Locking #{options[:jarfile]} to #{options[:lockfile]}"
-      LockJar.lock( options[:jarfile], { :lockfile => options[:lockfile] } )
+      LockJar.lock(options[:jarfile], lockfile: options[:lockfile])
     end
 
     private
+
     def handle_verbose(verbose)
-      if verbose
-        LockJar::Logging.verbose!
-      end
+      LockJar::Logging.verbose! if verbose
+      nil
     end
-
   end
 end

data/lib/lock_jar/domain/artifact.rb

@@ -19,53 +19,54 @@ require 'naether/notation'
 
 module LockJar
   module Domain
-    
-    
+    #
     class Artifact
       include Comparable
       attr_reader :type
-      
-      def <=>(another_artifact)
-        if another_artifact.is_a? Artifact
-          to_urn <=> another_artifact.to_urn
+
+      def <=>(other)
+        if other.is_a? Artifact
+          to_urn <=> other.to_urn
         else
-          to_urn <=> another_artifact.to_s
+          to_urn <=> other.to_s
         end
       end
-      
+
       def resolvable?
         true
       end
     end
-    
+
+    #
     class Jar < Artifact
       attr_reader :notation
-      
-      def initialize( notation )
+
+      def initialize(notation)
         @type = 'jar'
-        @notation = Naether::Notation.new( notation ).to_notation
+        @notation = Naether::Notation.new(notation).to_notation
       end
-      
+
       def to_urn
         "jar:#{notation}"
       end
-      
+
       def to_dep
         notation
       end
     end
-    
+
+    #
     class Local < Artifact
       attr_reader :path
-      def initialize( path )
+      def initialize(path)
         @type = 'local'
         @path = path
       end
-      
+
       def to_urn
         "local:#{path}"
       end
-      
+
       def to_dep
         path
       end
@@ -74,51 +75,44 @@ module LockJar
         false
       end
     end
-    
+
+    #
     class Pom < Artifact
       attr_reader :path, :scopes
-      
-      def initialize( _path, _scopes = ['compile','runtime'] )
+
+      def initialize(pom_path, pom_scopes = %w(compile runtime))
         @type = 'pom'
-        @path = _path
-        @scopes = _scopes
+        @path = pom_path
+        @scopes = pom_scopes
       end
-      
+
       def to_urn
         "pom:#{path}"
       end
-      
+
       def to_dep
         { path => scopes }
       end
-      
+
       def notations
-        LockJar::Maven.dependencies( path, scopes )  
+        LockJar::Maven.dependencies(path, scopes)
       end
-      
-      def ==(another_artifact)
-        self.<=>(another_artifact) == 0
+
+      def ==(other)
+        self.<=>(other) == 0
       end
-      
-      def <=>(another_artifact)
-        if another_artifact.is_a? Pom
-          if to_urn == another_artifact.to_urn
-            return 0 if Set.new(scopes) == Set.new(another_artifact.scopes)
-            
-            # XXX: this is not a reliable way to compare. 
-            if scopes.size > another_artifact.scopes.size
-              return 1
-            else
-              return -1
-            end
+
+      def <=>(other)
+        if other.is_a? Pom
+          if to_urn == other.to_urn
+            return Set.new(scopes) <=> Set.new(other.scopes)
           else
-            to_urn <=> another_artifact.to_urn
+            to_urn <=> other.to_urn
           end
         else
           super
         end
       end
     end
-    
   end
-end
+end