lock_jar 0.10.5 → 0.12.0

data/lib/lock_jar/domain/lockfile.rb

@@ -19,17 +19,15 @@ require 'lock_jar/version'
 module LockJar
   module Domain
     class Lockfile
-      
-      attr_accessor :local_repository, :maps, :excludes, :remote_repositories, 
+
+      attr_accessor :local_repository, :maps, :excludes, :remote_repositories,
                     :version, :groups, :gems, :merged
-      attr_reader :force_utf8
-      
-      
+
       def self.read( path )
         lockfile = Lockfile.new
-        
+
         lock_data = YAML.load_file( path )
-        
+
         lockfile.version = lock_data['version'] || LockJar::VERSION
         lockfile.merged = lock_data['merged']
         lockfile.local_repository = lock_data['local_repository']
@@ -41,69 +39,55 @@ module LockJar
         lockfile.gems = lock_data['gems'] || []
         lockfile
       end
-      
+
       def initialize
-        @force_utf8 ||= RUBY_VERSION =~ /^1.9/
         @groups = { 'default' => {} }
         @maps = []
         @excludes = []
         @remote_repositories = []
         @gems = []
         @merged = []
-        
+
         @version = LockJar::VERSION # default version
       end
-      
+
       def to_hash
         lock_data = { 'version' => @version }
-  
+
         unless local_repository.nil?
           lock_data['local_repository'] = local_repository
-          
-          if @force_utf8
-            lock_data['local_repository'] = lock_data['local_repository'].force_encoding("UTF-8")
-          end
         end
-            
+
         unless merged.empty?
           lock_data['merged'] = merged
         end
-        
+
         if maps.size > 0
           lock_data['maps'] = maps
         end
-        
-        if excludes.size > 0 
+
+        if excludes.size > 0
           lock_data['excludes'] = excludes
-            
-          if @force_utf8
-            lock_data['excludes'].map! { |exclude| exclude.force_encoding("UTF-8") }
-          end
         end
-        
+
         unless gems.empty?
           lock_data['gems'] = gems
         end
-        
+
         lock_data['groups'] = groups
-        
-        #if @force_utf8
-        #  lock_data['groups'].each do |group, group_notations|
-        #    group_notations.map! { |notation| notation.force_encoding("UTF-8") }
-        #  end
-        #end
-        
+
         if remote_repositories.size > 0
           lock_data['remote_repositories'] = remote_repositories
         end
-        
+
         lock_data
       end
-      
+      alias_method :to_h, :to_hash
+
       def to_yaml
         to_hash.to_yaml
       end
-      
+
       def write( path )
         File.open( path, "w") do |f|
           f.write( to_yaml )
@@ -111,4 +95,4 @@ module LockJar
       end
     end
   end
-end
+end

data/lib/lock_jar/resolver.rb

@@ -20,50 +20,54 @@ require 'fileutils'
 
 module LockJar
   class Resolver
-    
+
     attr_reader :opts
     attr_reader :naether
-        
+
     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 )
-      
-      # Bootstrapping naether will create an instance from downloaded jars. 
+
+      # Bootstrapping naether will create an instance from downloaded jars.
       # If jars exist locally already, create manually
       @naether = Naether.create
       @naether.local_repo_path = local_repo if local_repo
       @naether.clear_remote_repositories if opts[:offline]
     end
-    
+
     def remote_repositories
       @naether.remote_repository_urls
     end
-    
+
+    def clear_remote_repositories
+      @naether.clear_remote_repositories
+    end
+
     def add_remote_repository( repo )
       @naether.add_remote_repository( repo )
     end
-    
-    
+
+
     def resolve( dependencies, download_artifacts = true )
       @naether.dependencies = dependencies
       @naether.resolve_dependencies( download_artifacts )
       @naether.dependencies_notation
     end
-    
+
     def dependencies_graph
       @naether.dependencies_graph
     end
-    
+
     def download( dependencies )
       @naether.download_artifacts( dependencies )
     end
-    
+
     def to_local_paths( notations )
-      paths = []   
+      paths = []
       notations.each do |notation|
         if File.exists?(notation)
           paths << notation
@@ -71,12 +75,12 @@ module LockJar
           paths = paths + @naether.to_local_paths( [notation] )
         end
       end
-      
+
       paths
     end
-    
+
     def load_to_classpath( artifacts )
-      paths = [] 
+      paths = []
       notations = []
 
       artifacts.each do |art|
@@ -86,11 +90,11 @@ module LockJar
           notations << art
         end
       end
-      
+
       paths += @naether.to_local_paths( notations )
       Naether::Java.load_paths( paths )
-      
+
       paths
     end
   end
-end
+end

data/lib/lock_jar/runtime.rb

@@ -23,21 +23,21 @@ require 'lock_jar/domain/jarfile_dsl'
 require 'lock_jar/domain/lockfile'
 
 module LockJar
-  
+
   class Runtime
     include Singleton
-    
+
     attr_reader :current_resolver
-    
+
     def initialize
       @current_resolver = nil
     end
-    
+
     def resolver( opts = {} )
-      
+
       # XXX: Caches the resolver by the options. Passing in nil opts will replay
       #      from the cache. This need to change.
-      
+
       unless opts.nil?
         if opts[:local_repo]
           opts[:local_repo] = File.expand_path(opts[:local_repo])
@@ -49,35 +49,45 @@ module LockJar
           opts = {}
         end
       end
-      
+
       if @current_resolver.nil? || opts != @current_resolver.opts
         @current_resolver = LockJar::Resolver.new( opts )
       end
-      
+
       @current_resolver
     end
-    
+
+    def reset!
+      @current_resolver = nil
+    end
+
     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
+      if lockfile.version.to_f >= 0.11
+        resolver(opts).clear_remote_repositories
+      end
+
       lockfile.remote_repositories.each do |repo|
           resolver(opts).add_remote_repository( repo )
       end
-      
+
       files = resolver(opts).download( deps )
-      
+
       files
     end
-    
+
     def lock( jarfile_or_dsl, opts = {}, &blk )
-      
+
       opts = {:download => true }.merge( opts )
-    
+
       jarfile = nil
 
       if jarfile_or_dsl
@@ -87,7 +97,7 @@ module LockJar
           jarfile = LockJar::Domain::JarfileDsl.create( jarfile_or_dsl )
         end
       end
-      
+
       unless blk.nil?
         dsl = LockJar::Domain::Dsl.create(&blk)
         if jarfile.nil?
@@ -105,14 +115,20 @@ module LockJar
         end
       end
 
-      
+
       # If not set in opts, and is set in  dsl
       if opts[:local_repo].nil? && jarfile.local_repository
-        opts[:local_repo] = jarfile.local_repository 
+        opts[:local_repo] = jarfile.local_repository
       end
-              
+
       lockfile = LockJar::Domain::Lockfile.new
-      
+
+      if jarfile.clear_repositories
+        resolver(opts).clear_remote_repositories
+      else
+        lockfile.remote_repositories += resolver(opts).remote_repositories.to_a
+      end
+
       jarfile.remote_repositories.each do |repo|
         resolver(opts).add_remote_repository( repo )
       end
@@ -120,57 +136,55 @@ module LockJar
       unless jarfile.local_repository.nil?
         lockfile.local_repository = jarfile.local_repository
       end
-              
+
       if jarfile.maps.size > 0
         lockfile.maps = jarfile.maps
       end
-      
-      if jarfile.excludes.size > 0 
+
+      if jarfile.excludes.size > 0
         lockfile.excludes = jarfile.excludes
       end
-      
+
       artifacts = []
       jarfile.artifacts.each do |group, group_artifacts|
         group_artifacts.each do |artifact|
           artifacts += group_artifacts
         end
       end
-      
+
       if !jarfile.merged.empty?
         lockfile.merged = jarfile.merged
       end
-      
-      if !artifacts.empty?   
+
+      if !artifacts.empty?
         resolved_notations = resolver(opts).resolve( artifacts.select{ |artifact| artifact.resolvable? }.map(&:to_dep), opts[:download] == true )
-        
-        lockfile.remote_repositories = resolver(opts).remote_repositories - ['http://repo1.maven.org/maven2/']
-        
+
         jarfile.artifacts.each do |group_name, group_artifacts|
           group = {'locals' => [], 'dependencies' => [], 'artifacts' => []}
-          
+
           group_artifacts.each do |artifact|
-          
+
             artifact_data = {}
-            
+
             if artifact.is_a? LockJar::Domain::Jar
               group['dependencies'] << artifact.notation
               artifact_data["transitive"] = resolver(opts).dependencies_graph[artifact.notation].to_hash
 
             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|               
+              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
               # XXX: handle unsupported artifact
-              
+
             end
 
             # flatten the graph of nested hashes
@@ -181,64 +195,64 @@ module LockJar
               end
               deps
             end
-            
+
             if artifact_data["transitive"]
               group['dependencies'] += dep_merge.call( artifact_data["transitive"] )
-              
+
               # xxX: set required_by ?
-              
+
               group['artifacts'] << { artifact.to_urn => artifact_data }
             end
           end
-  
+
           if lockfile.excludes
             lockfile.excludes.each do |exclude|
                group['dependencies'].delete_if { |dep| dep =~ /#{exclude}/ }
             end
           end
-          
+
           group['dependencies'].sort!
           if group['locals'].empty?
             group.delete 'locals'
           end
-          
-          lockfile.groups[group_name] = group         
-        end                        
+
+          lockfile.groups[group_name] = group
+        end
       end
-      
+
       lockfile.write( opts[:lockfile] || "Jarfile.lock" )
-      
+
       lockfile
     end
-  
+
     def list( lockfile_or_path, groups = ['default'], opts = {}, &blk )
-          
+
       lockfile = nil
       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 
+
+      if maps && maps.size > 0
         mapped_dependencies = []
-        
+
         maps.each do |notation, replacements|
           dependencies.each do |dep|
             if dep =~ /#{notation}/
@@ -250,84 +264,84 @@ module LockJar
             end
           end
         end
-                        
+
         dependencies = mapped_dependencies
       end
-      
+
       if opts[:resolve]
         dependencies = resolver(opts).resolve( dependencies )
       end
-      
+
       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
-    
+
     # 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
     def load( lockfile_or_path, groups = ['default'], opts = {}, &blk )
-      
+
       lockfile = nil
-      
+
       # lockfile is only loaded once
-      unless lockfile_or_path.nil? 
+      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  
-          
+          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
         if opts[:local_repo].nil? && dsl.local_repository
           opts[:local_repo] = dsl.local_repository
         end
       end
-      
+
       # registered merged lockfiles for lockfile
       if lockfile && !lockfile.merged.empty?
         lockfile.merged.each do |path|
           LockJar::Registry.instance.register_lockfile( path )
         end
       end
-      
+
       dependencies = LockJar::Registry.instance.register_jars( list( lockfile, groups, opts, &blk ) )
-              
+
       resolver(opts).load_to_classpath( dependencies )
     end
-    
+
     private
-    
+
     def lockfile_dependencies( lockfile, groups, with_locals = true)
       dependencies = []
-       
+
       groups.each do |group|
         if lockfile.groups[group.to_s]
-          dependencies += lockfile.groups[group.to_s]['dependencies'] 
+          dependencies += lockfile.groups[group.to_s]['dependencies']
 
           if with_locals
             locals = lockfile.groups[group.to_s]['locals']
@@ -335,14 +349,14 @@ module LockJar
           end
         end
       end
-      
+
       dependencies
     end
-    
+
     def dsl_dependencies( dsl, groups, with_locals = true)
-      
+
       dependencies = []
-       
+
       groups.each do |group|
         if dsl.artifacts[group.to_s]
           dependencies += dsl.artifacts[group.to_s]
@@ -352,7 +366,7 @@ module LockJar
       unless with_locals
         dependencies.select! { |dep| !dep.is_a? LockJar::Domain::Local }
       end
-      
+
       dependencies
     end
   end

data/lib/lock_jar/version.rb

@@ -1,3 +1,3 @@
 module LockJar
-  VERSION = '0.10.5'
+  VERSION = '0.12.0'
 end