lock_jar 0.6.2 → 0.7.0

data/lib/lock_jar/runtime.rb

@@ -17,16 +17,22 @@ require 'rubygems'
 require "yaml"
 require 'singleton'
 require 'lock_jar/resolver'
-require 'lock_jar/dsl'
 require 'lock_jar/runtime'
 require 'lock_jar/registry'
+require 'lock_jar/domain/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
@@ -51,11 +57,11 @@ module LockJar
       @current_resolver
     end
     
-    def install( jarfile_lock, scopes = ['compile', 'runtime'], opts = {}, &blk )
-      deps = list( jarfile_lock, scopes, opts, &blk )
+    def install( jarfile_lock, groups = ['default'], opts = {}, &blk )
+      deps = list( jarfile_lock, groups, opts, &blk )
       
-      lock_data = read_lockfile( jarfile_lock )
-      lock_data['repositories'].each do |repo|
+      lockfile = LockJar::Domain::Lockfile.read( jarfile_lock )
+      lockfile.remote_repositories.each do |repo|
           resolver(opts).add_remote_repository( repo )
       end
       
@@ -64,205 +70,264 @@ module LockJar
       files
     end
     
-    def lock( jarfile, opts = {}, &blk )
+    def lock( jarfile_or_dsl, opts = {}, &blk )
       
-        opts = {:download => true }.merge( opts )
+      opts = {:download => true }.merge( opts )
+    
+      jarfile = nil
       
-        lock_jar_file = nil
-        
-        if jarfile
-          if jarfile.is_a? LockJar::Dsl
-            lock_jar_file = jarfile
-          else
-            lock_jar_file = LockJar::Dsl.evaluate( jarfile )
-          end
+      if jarfile_or_dsl
+        if jarfile_or_dsl.is_a? LockJar::Domain::Dsl
+          jarfile = jarfile_or_dsl
+        else
+          jarfile = LockJar::Domain::Dsl.create( jarfile_or_dsl )
         end
-        
-        unless blk.nil?
-          dsl = LockJar::Dsl.evaluate(&blk)
-          if lock_jar_file.nil?
-            lock_jar_file = dsl
-          else
-            lock_jar_file.merge( dsl )
-          end
+      end
+      
+      unless blk.nil?
+        dsl = LockJar::Domain::Dsl.create(&blk)
+        if jarfile.nil?
+          jarfile = dsl
+        else
+          jarfile.merge( dsl )
         end
+      end
 
-        
-        # If not set in opts, and is set in  dsl
-        if opts[:local_repo].nil? && lock_jar_file.local_repository
-          opts[:local_repo] = lock_jar_file.local_repository 
-        end
-        
-        lock_jar_file.repositories.each do |repo|
-          resolver(opts).add_remote_repository( repo )
-        end
-        
-        lock_data = { }
+      
+      # If not set in opts, and is set in  dsl
+      if opts[:local_repo].nil? && jarfile.local_repository
+        opts[:local_repo] = jarfile.local_repository 
+      end
+              
+      lockfile = LockJar::Domain::Lockfile.new
+      
+      jarfile.remote_repositories.each do |repo|
+        resolver(opts).add_remote_repository( repo )
+      end
 
-        unless lock_jar_file.local_repository.nil?
-          lock_data['local_repository'] = lock_jar_file.local_repository
-          
-          if needs_force_encoding
-            lock_data['local_repository'] = lock_data['local_repository'].force_encoding("UTF-8")
-          end
-        end
-                
-        if lock_jar_file.maps.size > 0
-          lock_data['maps'] = lock_jar_file.maps
+      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 
+        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?   
+        resolved_notations = resolver(opts).resolve( artifacts.map(&:to_dep), opts[:download] == true )
         
-        if lock_jar_file.excludes.size > 0 
-          lock_data['excludes'] = lock_jar_file.excludes
-            
-          if needs_force_encoding
-            lock_data['excludes'].map! { |exclude| exclude.force_encoding("UTF-8") }
-          end
-        end
+        lockfile.remote_repositories = resolver(opts).remote_repositories - ['http://repo1.maven.org/maven2/']
         
-        lock_data['scopes'] = {} 
-          
-        lock_jar_file.notations.each do |scope, notations|
+        jarfile.artifacts.each do |group_name, group_artifacts|
+          group = {'dependencies' => [], 'artifacts' => []}
           
-          if needs_force_encoding
-            notations.map! { |notation| notation.force_encoding("UTF-8") }
-          end
+          group_artifacts.each do |artifact|
           
-          dependencies = []
-          notations.each do |notation|
-            dependencies << {notation => scope}
-          end
-          
-          if dependencies.size > 0
-            resolved_notations = resolver(opts).resolve( dependencies, opts[:download] == true )
-            
-            lock_data['repositories'] = resolver(opts).remote_repositories.uniq
-            if needs_force_encoding
-              lock_data['repositories'].map! { |repo| repo.force_encoding("UTF-8") }
-            end 
+            artifact_data = {}
             
-            if lock_data['excludes']
-              lock_data['excludes'].each do |exclude|
-                resolved_notations.delete_if { |dep| dep =~ /#{exclude}/ }
+            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|               
+                transitive.merge!( notation => resolver(opts).dependencies_graph[notation] )
               end
+              artifact_data["transitive"] = transitive
+              
+            elsif artifact.is_a? LockJar::Domain::Local
+              # xXX: support local artifacts
+            else
+              # XXX: handle unsupported artifact
+              
             end
+
+            # flatten the graph of nested hashes
+            dep_merge = lambda do |graph|
+              deps = graph.keys
+              graph.values.each do |next_step|
+                deps += dep_merge.call(next_step)
+              end
+              deps
+            end
+            
+            group['dependencies'] += dep_merge.call( artifact_data["transitive"] )
             
-            lock_data['scopes'][scope] = { 
-              'dependencies' => notations,
-              'resolved_dependencies' => resolved_notations } 
+            # xxX: set required_by ?
+            
+            group['artifacts'] << { artifact.to_urn => artifact_data }
           end
-        end
-    
-        File.open( opts[:lockfile] || "Jarfile.lock", "w") do |f|
-          f.write( lock_data.to_yaml )
-        end
-        
-        lock_data
+  
+          if lockfile.excludes
+            lockfile.excludes.each do |exclude|
+               group['dependencies'].delete_if { |dep| dep =~ /#{exclude}/ }
+            end
+          end
+          
+          group['dependencies'].sort!
+          
+          lockfile.groups[group_name] = group         
+        end                        
       end
-    
-      def list( jarfile_lock, scopes = ['compile', 'runtime'], opts = {}, &blk )
-        dependencies = []
-        maps = []
-            
-        if jarfile_lock
-          lockfile = read_lockfile( jarfile_lock)
-          dependencies += lockfile_dependencies( lockfile, scopes )
-          maps = lockfile['maps']
+      
+      
+      lockfile.write( opts[:lockfile] || "Jarfile.lock" )
+      
+      lockfile
+    end
+  
+    def list( lockfile_or_path, groups = ['default'], opts = {}, &blk )
+          
+      lockfile = nil
+      dependencies = []
+      maps = []
+      
+      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
         
-        unless blk.nil?
-          dsl = LockJar::Dsl.evaluate(&blk)
-          dependencies += dsl_dependencies( dsl, scopes )
-          maps = dsl.maps
-        end
+        dependencies = lockfile_dependencies( lockfile, groups )
+        maps = lockfile.maps
+      end
+      
+      # Support limited DSL from block
+      unless blk.nil?
+        dsl = LockJar::Domain::Dsl.create(&blk)
+        dependencies += dsl_dependencies( dsl, groups ).map(&:to_dep)
+        maps = dsl.maps
+      end
+      
+      if maps && maps.size > 0 
+        mapped_dependencies = []
         
-        if maps && maps.size > 0 
-          mapped_dependencies = []
-          
-          maps.each do |notation, replacements|
-            dependencies.each do |dep|
-              if dep =~ /#{notation}/
-                replacements.each do |replacement|
-                  mapped_dependencies << replacement
-                end
-              else
-                mapped_dependencies << dep
+        maps.each do |notation, replacements|
+          dependencies.each do |dep|
+            if dep =~ /#{notation}/
+              replacements.each do |replacement|
+                mapped_dependencies << replacement
               end
+            else
+              mapped_dependencies << dep
             end
           end
-                          
-          dependencies = mapped_dependencies
-        end
-        
-        if opts[:resolve]
-          dependencies = resolver(opts).resolve( dependencies )
         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 )
         
-        if opts[:local_paths]
-          opts.delete( :local_paths ) # remove list opts so resolver is not reset
-          resolver(opts).to_local_paths( dependencies.uniq )
+      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? 
+        # 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
-          dependencies.uniq
+          lockfile = LockJar::Domain::Lockfile.read( lockfile_or_path )
         end
-      end
       
-      def load( jarfile_lock, scopes = ['compile', 'runtime'], opts = {}, &blk )
-        if jarfile_lock
-          lockfile = read_lockfile( jarfile_lock )
-  
-          if opts[:local_repo].nil? && lockfile['local_repo']
-            opts[:local_repo] = lockfile['local_repo']
-          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)
         
-        unless blk.nil?
-          dsl = LockJar::Dsl.evaluate(&blk)
-          
-          if opts[:local_repo].nil? && dsl.local_repository
-            opts[:local_repo] = dsl.local_repository
-          end
+        # set local_repo from block
+        if opts[:local_repo].nil? && dsl.local_repository
+          opts[:local_repo] = dsl.local_repository
         end
-        
-        dependencies = LockJar::Registry.instance.register_jars( list( jarfile_lock, scopes, opts, &blk ) )
-                
-        resolver(opts).load_to_classpath( dependencies )
       end
       
-      def read_lockfile( jarfile_lock )
-        YAML.load_file( jarfile_lock )
+      # registered merged lockfiles for lockfile
+      if lockfile && !lockfile.merged.empty?
+        lockfile.merged.each do |path|
+          LockJar::Registry.instance.register_lockfile( path )
+        end
       end
       
-      private
-      
-      def lockfile_dependencies( lockfile, scopes)
-        dependencies = []
-         
-        scopes.each do |scope|
-          if lockfile['scopes'][scope]
-            dependencies += lockfile['scopes'][scope]['resolved_dependencies']
-          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)
+      dependencies = []
+       
+      groups.each do |group|
+        if lockfile.groups[group.to_s]
+          dependencies += lockfile.groups[group.to_s]['dependencies']
         end
-        
-        dependencies
       end
       
-      def dsl_dependencies( dsl, scopes )
-        
-        dependencies = []
-         
-        dsl.notations.each do |scope,notations|
-          if notations && notations.size > 0
-            dependencies += notations
-          end
+      dependencies
+    end
+    
+    def dsl_dependencies( dsl, groups )
+      
+      dependencies = []
+       
+      groups.each do |group|
+        if dsl.artifacts[group.to_s]
+          dependencies += dsl.artifacts[group.to_s]
         end
-        
-        dependencies
-      end
-
-      private
-      def needs_force_encoding
-        @needs_force_encoding || @needs_force_encoding = RUBY_VERSION =~ /^1.9/
       end
+      
+      dependencies
+    end
   end
-  
-end
+end

data/lib/lock_jar.rb

@@ -16,10 +16,10 @@
 require "yaml"
 require 'rubygems'
 require 'lock_jar/resolver'
-require 'lock_jar/dsl'
 require 'lock_jar/runtime'
 require 'lock_jar/version'
-require 'lock_jar/rubygems'
+require 'lock_jar/domain/lockfile'
+require 'lock_jar/domain/dsl'
 
 #
 # LockJar manages Java Jars for Ruby.
@@ -38,7 +38,7 @@ module LockJar
   def self.install( *args, &blk )
     lockfile = nil
     opts = {}
-    scopes = ['compile', 'runtime']
+    groups = ['default']
       
     args.each do |arg|
       if arg.is_a?(Hash)
@@ -46,7 +46,7 @@ module LockJar
       elsif arg.is_a?( String )
         lockfile = arg
       elsif arg.is_a?( Array )
-        scopes = arg
+        groups = arg
       end
     end
     
@@ -55,14 +55,14 @@ module LockJar
       lockfile = 'Jarfile.lock'
     end
     
-    Runtime.instance.install( lockfile, scopes, opts, &blk )
+    Runtime.instance.install( lockfile, groups, opts, &blk )
   end
   
   
-  # Lists all dependencies as notations for scopes from the Jarfile.lock. Depending on the type of arg, a different configuration is set.
+  # Lists all dependencies as notations for groups from the Jarfile.lock. Depending on the type of arg, a different configuration is set.
   #
   # * An arg of a String will set the Jarfile.lock, e.g. 'Better.lock'.  Default lock file is *Jarfile.lock*.
-  # * An arg of an Array will set the scopes, e.g. ['compile','test'].  Defaults scopes are *compile* and *runtime*
+  # * An arg of an Array will set the groups, e.g. ['development','test'].  Defaults group is *default*
   # * An arg of a Hash will set the options, e.g. { :local_repo => 'path' }
   #   * :local_repo [String] sets the local repo path
   #   * :local_paths [Boolean] to true converts the notations to paths to jars in the local repo path
@@ -74,7 +74,7 @@ module LockJar
   def self.list( *args, &blk )
       lockfile = nil
       opts = {}
-      scopes = ['compile', 'runtime']
+      groups = ['default']
         
       args.each do |arg|
         if arg.is_a?(Hash)
@@ -82,7 +82,9 @@ module LockJar
         elsif arg.is_a?( String )
           lockfile = arg
         elsif arg.is_a?( Array )
-          scopes = arg
+          groups = arg
+        elsif arg.is_a?( LockJar::Domain::Lockfile )
+          lockfile = arg
         end
       end
       
@@ -91,12 +93,12 @@ module LockJar
         lockfile = 'Jarfile.lock'
       end
       
-      Runtime.instance.list( lockfile, scopes, opts, &blk )
+      Runtime.instance.list( lockfile, groups, opts, &blk )
   end
     
-  # LockJar.load(*args): Loads all dependencies to the classpath for scopes from the Jarfile.lock. Depending on the type of arg, a different configuration is set.
+  # LockJar.load(*args): Loads all dependencies to the classpath for groups from the Jarfile.lock. Depending on the type of arg, a different configuration is set.
   # * An arg of a String will set the Jarfile.lock, e.g. 'Better.lock'. Default lock file is *Jarfile.lock*.
-  # * An arg of an Array will set the scopes, e.g. ['compile','test'].Defaults scopes are *compile* and *runtime*.
+  # * An arg of an Array will set the groups, e.g. ['development','test'].Defaults group is *default*.
   # * An arg of a Hash will set the options, e.g. { :local_repo => 'path' }
   #    * :local_repo sets the local repo path
   #    * :resolve to true will make transitive dependences resolve before loading to classpath
@@ -107,7 +109,7 @@ module LockJar
   def self.load( *args, &blk )
       lockfile = nil
       opts = {}
-      scopes = ['compile', 'runtime']
+      groups = ['default']
         
       args.each do |arg|
         if arg.is_a?(Hash)
@@ -115,7 +117,9 @@ module LockJar
         elsif arg.is_a?( String )
           lockfile = arg
         elsif arg.is_a?( Array )
-          scopes = arg
+          groups = arg
+        elsif arg.is_a?( LockJar::Domain::Lockfile )
+          lockfile = arg
         end
       end
       
@@ -124,7 +128,7 @@ module LockJar
         lockfile = 'Jarfile.lock'
       end
       
-      Runtime.instance.load( lockfile, scopes, opts, &blk )
+      Runtime.instance.load( lockfile, groups, opts, &blk )
   end
   
   # Lock a Jarfile and generate a Jarfile.lock. 
@@ -147,7 +151,7 @@ module LockJar
     args.each do |arg|
       if arg.is_a?(Hash)
         opts.merge!( arg )
-      elsif arg.is_a?( String ) || arg.is_a?( LockJar::Dsl )
+      elsif arg.is_a?( String ) || arg.is_a?( LockJar::Domain::Dsl )
         jarfile = arg
       end
     end
@@ -161,14 +165,13 @@ module LockJar
   end
   
   #
-  # Read a Jafile.lock and convert it to a Hash
+  # Read a Jafile.lock and convert it to a LockJar::Domain::Lockfile
   #
   # @param [String] lockfile path to lockfile
   # @return [Hash] Lock Data
   def self.read( lockfile )
-    Runtime.instance.read_lockfile( lockfile )
+    LockJar::Domain::Lockfile.read( lockfile )
   end
  
 end
 
-#include LockJar::Rubygems::Kernel

data/lock_jar.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "lock_jar"
-  s.version = "0.6.2"
+  s.version = "0.7.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Michael Guymon"]
-  s.date = "2012-09-28"
+  s.date = "2012-10-17"
   s.description = "Manage Jar files for Ruby. In the spirit of Bundler, a Jarfile\n  is used to generate a Jarfile.lock that contains all the resolved jar dependencies for scopes runtime, compile, and test.\n  The Jarfile.lock can be used to populate the classpath"
   s.email = "michael@tobedevoured.com"
   s.executables = ["lockjar"]
@@ -27,22 +27,27 @@ Gem::Specification.new do |s|
     "bin/lockjar",
     "lib/lock_jar.rb",
     "lib/lock_jar/buildr.rb",
+    "lib/lock_jar/bundler.rb",
     "lib/lock_jar/class_loader.rb",
     "lib/lock_jar/cli.rb",
-    "lib/lock_jar/dsl.rb",
+    "lib/lock_jar/domain/artifact.rb",
+    "lib/lock_jar/domain/dsl.rb",
+    "lib/lock_jar/domain/dsl_helper.rb",
+    "lib/lock_jar/domain/gem_dsl.rb",
+    "lib/lock_jar/domain/jarfile_dsl.rb",
+    "lib/lock_jar/domain/lockfile.rb",
     "lib/lock_jar/maven.rb",
     "lib/lock_jar/registry.rb",
     "lib/lock_jar/resolver.rb",
-    "lib/lock_jar/rubygems.rb",
     "lib/lock_jar/runtime.rb",
     "lib/lock_jar/version.rb",
     "lock_jar.gemspec",
     "spec/Jarfile",
     "spec/lock_jar/class_loader_spec.rb",
-    "spec/lock_jar/dsl_spec.rb",
+    "spec/lock_jar/domain/dsl_helper_spec.rb",
+    "spec/lock_jar/domain/dsl_spec.rb",
     "spec/lock_jar/maven_spec.rb",
     "spec/lock_jar/resolver_spec.rb",
-    "spec/lock_jar/rubygems_spec.rb",
     "spec/lock_jar/runtime_spec.rb",
     "spec/lock_jar_spec.rb",
     "spec/pom.xml",
@@ -58,29 +63,29 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<naether>, ["~> 0.9.0"])
+      s.add_runtime_dependency(%q<naether>, ["~> 0.10.0"])
       s.add_runtime_dependency(%q<thor>, ["~> 0.14.6"])
       s.add_development_dependency(%q<rspec>, ["~> 2.9.0"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.8.4"])
       s.add_development_dependency(%q<yard>, ["~> 0.8.0"])
-      s.add_development_dependency(%q<solr_sail>, ["~> 0.0.6"])
+      s.add_development_dependency(%q<solr_sail>, ["~> 0.1.0"])
       s.add_development_dependency(%q<jruby-openssl>, [">= 0"])
     else
-      s.add_dependency(%q<naether>, ["~> 0.9.0"])
+      s.add_dependency(%q<naether>, ["~> 0.10.0"])
       s.add_dependency(%q<thor>, ["~> 0.14.6"])
       s.add_dependency(%q<rspec>, ["~> 2.9.0"])
       s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
       s.add_dependency(%q<yard>, ["~> 0.8.0"])
-      s.add_dependency(%q<solr_sail>, ["~> 0.0.6"])
+      s.add_dependency(%q<solr_sail>, ["~> 0.1.0"])
       s.add_dependency(%q<jruby-openssl>, [">= 0"])
     end
   else
-    s.add_dependency(%q<naether>, ["~> 0.9.0"])
+    s.add_dependency(%q<naether>, ["~> 0.10.0"])
     s.add_dependency(%q<thor>, ["~> 0.14.6"])
     s.add_dependency(%q<rspec>, ["~> 2.9.0"])
     s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
     s.add_dependency(%q<yard>, ["~> 0.8.0"])
-    s.add_dependency(%q<solr_sail>, ["~> 0.0.6"])
+    s.add_dependency(%q<solr_sail>, ["~> 0.1.0"])
     s.add_dependency(%q<jruby-openssl>, [">= 0"])
   end
 end