lock_jar 0.13.0 → 0.14.0

data/lib/lock_jar/registry.rb

@@ -15,79 +15,71 @@
 
 require 'singleton'
 
-#
-# Registry of resources loaded by LockJar
-#
-# @author Michael Guymon
-#
-class LockJar::Registry
+module LockJar
+  #
+  # Registry of resources loaded by LockJar
+  #
+  # @author Michael Guymon
+  #
+  class Registry
     include Singleton
-    
-    attr_accessor :loaded_gems
-    attr_accessor :loaded_jars
-    attr_accessor :loaded_lockfiles
-    
+
+    attr_accessor :loaded_gems, :loaded_jars, :loaded_lockfiles
+
     def initialize
       @loaded_gems = {}
       @loaded_jars = []
       @loaded_lockfiles = []
     end
-    
-    def lockfile_registered?( lockfile )
-      if lockfile
-        @loaded_lockfiles.include? File.expand_path( lockfile )
-      end
+
+    def lockfile_registered?(lockfile)
+      @loaded_lockfiles.include? File.expand_path(lockfile) if lockfile
     end
-    
-    def register_lockfile( lockfile )
-      if lockfile && !lockfile_registered?( lockfile )
-        @loaded_lockfiles << File.expand_path( lockfile )
-      end
+
+    def register_lockfile(lockfile)
+      return if lockfile.nil? || lockfile_registered?(lockfile)
+
+      @loaded_lockfiles << File.expand_path(lockfile)
     end
-    
-    def register_jars( jars )
-      if jars
-        jars_to_load = jars - @loaded_jars
-        
-        @loaded_jars += jars_to_load
-        
-        jars_to_load
-      end
+
+    def register_jars(jars)
+      return if jars.nil?
+
+      jars_to_load = jars - @loaded_jars
+
+      @loaded_jars += jars_to_load
+
+      jars_to_load
     end
-    
-    def register_gem( spec )
+
+    def register_gem(spec)
       @loaded_gems[spec.name] = spec
     end
-    
-    def gem_registered?( spec )
+
+    def gem_registered?(spec)
       !@loaded_gems[spec.name].nil?
     end
-    
-    def load_gem( spec )
-      unless gem_registered?( spec )
-        register_gem(spec)
-        gem_dir = spec.gem_dir
-  		
-        lockfile = File.join( gem_dir, "Jarfile.lock" )
-       	
-        if File.exists?( lockfile )
-       	  puts "#{spec.name} has Jarfile.lock, loading jars"
-          LockJar.load( lockfile )
-        end 
-      end
+
+    def load_gem(spec)
+      return if gem_registered?(spec)
+
+      register_gem(spec)
+      gem_dir = spec.gem_dir
+
+      lockfile = File.join(gem_dir, 'Jarfile.lock')
+
+      return unless File.exist?(lockfile)
+
+      puts "#{spec.name} has Jarfile.lock, loading jars"
+      LockJar.load(lockfile)
     end
-    
-    def load_jars_for_gems      
+
+    def load_jars_for_gems
       specs = Gem.loaded_specs
-      if specs 
-        gems = specs.keys - @loaded_gems.keys
-        if gems.size > 0
-          gems.each do |key|
-            spec = specs[key]
-            load_gem( spec )
-          end 
-        end
-      end
-    end
+      return if specs.nil?
 
-end
+      gems = specs.keys - @loaded_gems.keys
+      gems.each { |key| load_gem(specs[key]) }
+    end
+  end
+end

data/lib/lock_jar/resolver.rb

@@ -19,18 +19,16 @@ require 'naether/bootstrap'
 require 'fileutils'
 
 module LockJar
+  #
   class Resolver
+    attr_reader :opts, :naether
 
-    attr_reader :opts
-    attr_reader :naether
-
-    def initialize( opts = {} )
-
+    def initialize(opts = {})
       @opts = opts
       local_repo = opts[:local_repo] || Naether::Bootstrap.default_local_repo
 
       # Bootstrap Naether
-      Naether::Bootstrap.bootstrap_local_repo( local_repo, opts )
+      Naether::Bootstrap.bootstrap_local_repo(local_repo, opts)
 
       # Bootstrapping naether will create an instance from downloaded jars.
       # If jars exist locally already, create manually
@@ -47,14 +45,13 @@ module LockJar
       @naether.clear_remote_repositories
     end
 
-    def add_remote_repository( repo )
-      @naether.add_remote_repository( repo )
+    def add_remote_repository(repo)
+      @naether.add_remote_repository(repo)
     end
 
-
-    def resolve( dependencies, download_artifacts = true )
+    def resolve(dependencies, download_artifacts = true)
       @naether.dependencies = dependencies
-      @naether.resolve_dependencies( download_artifacts )
+      @naether.resolve_dependencies(download_artifacts)
       @naether.dependencies_notation
     end
 
@@ -62,37 +59,37 @@ module LockJar
       @naether.dependencies_graph
     end
 
-    def download( dependencies )
-      @naether.download_artifacts( dependencies )
+    def download(dependencies)
+      @naether.download_artifacts(dependencies)
     end
 
-    def to_local_paths( notations )
+    def to_local_paths(notations)
       paths = []
       notations.each do |notation|
-        if File.exists?(notation)
+        if File.exist?(notation)
           paths << notation
         else
-          paths = paths + @naether.to_local_paths( [notation] )
+          paths += @naether.to_local_paths([notation])
         end
       end
 
       paths
     end
 
-    def load_to_classpath( artifacts )
+    def load_to_classpath(artifacts)
       paths = []
       notations = []
 
       artifacts.each do |art|
-        if File.exists?(art)
+        if File.exist?(art)
           paths << art
         else
           notations << art
         end
       end
 
-      paths += @naether.to_local_paths( notations )
-      Naether::Java.load_paths( paths )
+      paths += @naether.to_local_paths(notations)
+      Naether::Java.load_paths(paths)
 
       paths
     end

data/lib/lock_jar/runtime/install.rb

@@ -0,0 +1,28 @@
+module LockJar
+  #
+  class Runtime
+    #
+    module Install
+      def install(jarfile_lock, groups = ['default'], opts = {}, &blk)
+        deps = list(jarfile_lock, groups, { with_locals: false }.merge(opts), &blk)
+
+        lockfile = LockJar::Domain::Lockfile.read(jarfile_lock)
+        if opts[:local_repo].nil? && lockfile.local_repository
+          opts[:local_repo] = lockfile.local_repository
+        end
+
+        # Older Jarfile expected the defaul maven repo, but did not write
+        # it to the lockfile
+        resolver(opts).clear_remote_repositories if lockfile.version.to_f >= 0.11
+
+        lockfile.remote_repositories.each do |repo|
+          resolver(opts).add_remote_repository(repo)
+        end
+
+        files = resolver(opts).download(deps)
+
+        files
+      end
+    end
+  end
+end

data/lib/lock_jar/runtime/list.rb

@@ -0,0 +1,55 @@
+module LockJar
+  #
+  class Runtime
+    #
+    module List
+      # rubocop:disable Metrics/PerceivedComplexity, MethodLength
+      def list(lockfile_or_path, groups = ['default'], opts = {}, &blk)
+        dependencies = []
+        maps = []
+        with_locals = { with_locals: true }.merge(opts).delete(:with_locals)
+
+        if lockfile_or_path
+          if lockfile_or_path.is_a? LockJar::Domain::Lockfile
+            lockfile = lockfile_or_path
+          elsif lockfile_or_path
+            lockfile = LockJar::Domain::Lockfile.read(lockfile_or_path)
+          end
+
+          dependencies = lockfile_dependencies(lockfile, groups, with_locals)
+          maps = lockfile.maps
+        end
+
+        # Support limited DSL from block
+        unless blk.nil?
+          dsl = LockJar::Domain::Dsl.create(&blk)
+          dependencies += dsl_dependencies(dsl, groups, with_locals).map(&:to_dep)
+          maps = dsl.maps
+        end
+
+        if maps && maps.size > 0
+          maps.each do |notation, replacements|
+            dependencies = dependencies.flat_map do |dep|
+              if dep =~ /#{notation}/
+                replacements
+              else
+                dep
+              end
+            end
+          end
+        end
+
+        dependencies = resolver(opts).resolve(dependencies) if opts[:resolve]
+
+        if opts[:local_paths]
+          opts.delete(:local_paths) # remove list opts so resolver is not reset
+          resolver(opts).to_local_paths(dependencies)
+
+        else
+          dependencies
+        end
+      end
+      # rubocop:enable Metrics/PerceivedComplexity, MethodLength
+    end
+  end
+end

data/lib/lock_jar/runtime/load.rb

@@ -0,0 +1,54 @@
+module LockJar
+  #
+  class Runtime
+    #
+    module Load
+      # Load paths from a lockfile or block. Paths are loaded once per lockfile.
+      #
+      # @param [String] lockfile_path the lockfile
+      # @param [Array] groups to load into classpath
+      # @param [Hash] opts
+      # @param [Block] blk
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def load(lockfile_or_path, groups = ['default'], opts = {}, &blk)
+        # lockfile is only loaded once
+        unless lockfile_or_path.nil?
+          # loaded a Lockfile instance
+          if lockfile_or_path.is_a? LockJar::Domain::Lockfile
+            lockfile = lockfile_or_path
+
+          # check if lockfile path is already loaded
+          elsif LockJar::Registry.instance.lockfile_registered?(lockfile_or_path)
+            return
+
+          # convert lockfile path to a Lockfile instance
+          else
+            lockfile = LockJar::Domain::Lockfile.read(lockfile_or_path)
+          end
+
+          if opts[:local_repo].nil? && lockfile.local_repository
+            opts[:local_repo] = lockfile.local_repository
+          end
+        end
+
+        # set local_repo if passed in the block
+        unless blk.nil?
+          dsl = LockJar::Domain::Dsl.create(&blk)
+
+          # set local_repo from block
+          opts[:local_repo] = dsl.local_repository if opts[:local_repo].nil? && dsl.local_repository
+        end
+
+        # registered merged lockfiles for lockfile
+        if lockfile && !lockfile.merged.empty?
+          lockfile.merged.each { |path| LockJar::Registry.instance.register_lockfile(path) }
+        end
+
+        dependencies = LockJar::Registry.instance.register_jars(list(lockfile, groups, opts, &blk))
+
+        resolver(opts).load_to_classpath(dependencies)
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    end
+  end
+end

data/lib/lock_jar/runtime/lock.rb

@@ -0,0 +1,152 @@
+require 'delegate'
+
+module LockJar
+  #
+  class Runtime
+    #
+    class Lock < SimpleDelegator
+      attr_accessor :jarfile, :lockfile, :opts
+
+      def initialize(runtime)
+        super(runtime)
+
+        @lockfile = LockJar::Domain::Lockfile.new
+      end
+
+      def lock(jarfile_or_dsl, opts = {}, &blk)
+        @opts = { download: true }.merge(opts)
+
+        create_dsl!(jarfile_or_dsl, &blk)
+
+        apply_repositories!
+
+        apply_maps!
+
+        apply_excludes!
+
+        apply_merged!
+
+        artifacts = jarfile.artifacts.values.flatten
+        apply_artifacts!(artifacts) unless artifacts.empty?
+
+        lockfile.write(@opts[:lockfile] || 'Jarfile.lock')
+
+        lockfile
+      end
+
+      private
+
+      def create_dsl!(jarfile_or_dsl, &blk)
+        if jarfile_or_dsl
+          if jarfile_or_dsl.is_a? LockJar::Domain::Dsl
+            @jarfile = jarfile_or_dsl
+          else
+            @jarfile = LockJar::Domain::JarfileDsl.create(jarfile_or_dsl)
+          end
+        end
+
+        return @jarfile if blk.nil?
+
+        if @jarfile
+          @jarfile = LockJar::Domain::DslMerger.new(
+            jarfile, LockJar::Domain::Dsl.create(&blk)).merge
+        else
+          @jarfile = LockJar::Domain::Dsl.create(&blk)
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def apply_artifacts!(artifacts)
+        # Build the dependencies_graph hash in the resolver
+        resolver(opts).resolve(
+          artifacts.select(&:resolvable?).map(&:to_dep), opts[:download] == true
+        )
+
+        jarfile.artifacts.each do |group_name, group_artifacts|
+          group = { 'locals' => [], 'dependencies' => [], 'artifacts' => [] }
+
+          group_artifacts.each do |artifact|
+            artifact_data = {}
+
+            add_artifact!(group, artifact_data, artifact)
+
+            next unless artifact_data['transitive']
+
+            # flatten the graph of nested hashes
+            group['dependencies'] += dependency_merge(artifact_data['transitive'])
+            # xxX: set required_by ?
+            group['artifacts'] << { artifact.to_urn => artifact_data }
+          end
+
+          lockfile.excludes.each do |exclude|
+            group['dependencies'].delete_if { |dep| dep =~ /#{exclude}/ }
+          end if lockfile.excludes
+
+          group['dependencies'] = group['dependencies'].sort.uniq
+
+          group.delete 'locals' if group['locals'].empty?
+
+          lockfile.groups[group_name] = group
+        end
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def apply_excludes!
+        lockfile.excludes = jarfile.excludes if jarfile.excludes.size > 0
+      end
+
+      def apply_maps!
+        lockfile.maps = jarfile.maps if jarfile.maps.size > 0
+      end
+
+      def apply_merged!
+        lockfile.merged = jarfile.merged unless jarfile.merged.empty?
+      end
+
+      def apply_repositories!
+        if jarfile.clear_repositories
+          resolver(opts).clear_remote_repositories
+        else
+          repos = resolver(opts).remote_repositories
+          lockfile.remote_repositories += repos.to_a if repos
+        end
+
+        # Add remote repos to the resolver and the lockfile
+        jarfile.remote_repositories.each do |repo|
+          resolver(opts).add_remote_repository(repo)
+          lockfile.remote_repositories << repo
+        end
+
+        lockfile.local_repository = opts[:local_repo] || jarfile.local_repository
+      end
+
+      def add_artifact!(group, artifact_data, artifact)
+        if artifact.is_a? LockJar::Domain::Jar
+          group['dependencies'] << artifact.notation
+          g = resolver(opts).dependencies_graph[artifact.notation]
+          artifact_data['transitive'] = g.to_hash if g
+
+        elsif artifact.is_a? LockJar::Domain::Pom
+          artifact_data['scopes'] = artifact.scopes
+
+          # iterate each dependency in Pom to map transitive dependencies
+          transitive = {}
+          artifact.notations.each do |notation|
+            transitive.merge!(notation => resolver(opts).dependencies_graph[notation])
+          end
+          artifact_data['transitive'] = transitive
+
+        elsif artifact.is_a? LockJar::Domain::Local
+          group['locals'] << artifact.path
+        else
+          fail("Unsupported artifact: #{artifact.inspect}")
+        end
+      end
+
+      def dependency_merge(graph)
+        deps = graph.keys
+        graph.values.flat_map { |next_step| deps += dependency_merge(next_step) }
+      end
+    end
+  end
+end