lock_jar 0.13.0 → 0.14.0

data/lib/lock_jar/runtime.rb

@@ -13,7 +13,6 @@
 # License for the specific language governing permissions and limitations under
 # the License.
 
-require 'rubygems'
 require 'yaml'
 require 'singleton'
 require 'lock_jar/resolver'
@@ -21,11 +20,18 @@ require 'lock_jar/registry'
 require 'lock_jar/domain/dsl'
 require 'lock_jar/domain/jarfile_dsl'
 require 'lock_jar/domain/lockfile'
+require 'lock_jar/runtime/load'
+require 'lock_jar/runtime/lock'
+require 'lock_jar/runtime/list'
+require 'lock_jar/runtime/install'
 
 module LockJar
-
+  #
   class Runtime
     include Singleton
+    include Load
+    include List
+    include Install
 
     attr_reader :current_resolver
 
@@ -33,25 +39,27 @@ module LockJar
       @current_resolver = nil
     end
 
-    def resolver( opts = {} )
+    def lock(jarfile_or_dsl, opts = {}, &blk)
+      Lock.new(self).lock(jarfile_or_dsl, opts, &blk)
+    end
+
+    def opts
+      current_resolver.opts if current_resolver
+    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])
-        end
+      if !opts.nil?
+        opts[:local_repo] = File.expand_path(opts[:local_repo]) if opts[:local_repo]
+      elsif @current_resolver
+        opts = @current_resolver.opts
       else
-        if @current_resolver
-          opts = @current_resolver.opts
-        else
-          opts = {}
-        end
+        opts = {}
       end
 
       if @current_resolver.nil? || opts != @current_resolver.opts
-        @current_resolver = LockJar::Resolver.new( opts )
+        @current_resolver = LockJar::Resolver.new(opts)
       end
 
       @current_resolver
@@ -61,309 +69,29 @@ module LockJar
       @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
-        if jarfile_or_dsl.is_a? LockJar::Domain::Dsl
-          jarfile = jarfile_or_dsl
-        else
-          jarfile = LockJar::Domain::JarfileDsl.create( jarfile_or_dsl )
-        end
-      end
-
-      unless blk.nil?
-        dsl = LockJar::Domain::Dsl.create(&blk)
-        if jarfile.nil?
-          jarfile = dsl
-        else
-          jarfile = LockJar::Domain::DslHelper.merge( jarfile, dsl )
-        end
-      end
-
-      if jarfile.respond_to?(:bundler_enabled ) && jarfile.bundler_enabled
-        require 'lock_jar_bundler/bundler'
-
-        LockJar::Bundler.bundled_jarfiles(jarfile.bundler_enabled).each do |bundled_jarfile|
-          jarfile = LockJar::Domain::DslHelper.merge( jarfile, LockJar::Domain::JarfileDsl.create(bundled_jarfile) )
-        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
-      end
-
-      lockfile = LockJar::Domain::Lockfile.new
-
-      if jarfile.clear_repositories
-        resolver(opts).clear_remote_repositories
-      else
-        repos = resolver(opts).remote_repositories
-        lockfile.remote_repositories += repos.to_a if repos
-      end
-
-      jarfile.remote_repositories.each do |repo|
-        resolver(opts).add_remote_repository( repo )
-        lockfile.remote_repositories << repo
-      end
-
-      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.select{ |artifact| artifact.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 = {}
-
-            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
-              # 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
-
-            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
-      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
-        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
-            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?
-        # 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
-        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)
+    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']
+        next unless lockfile.groups[group.to_s]
+        dependencies += lockfile.groups[group.to_s]['dependencies']
 
-          if with_locals
-            locals = lockfile.groups[group.to_s]['locals']
-            dependencies += locals if locals
-          end
+        if with_locals
+          locals = lockfile.groups[group.to_s]['locals']
+          dependencies += locals if locals
         end
       end
 
       dependencies
     end
 
-    def dsl_dependencies( dsl, groups, with_locals = true)
-
+    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]
-        end
+        dependencies += dsl.artifacts[group.to_s] if dsl.artifacts[group.to_s]
       end
 
       unless with_locals

data/lib/lock_jar/version.rb

@@ -1,3 +1,4 @@
+# the version
 module LockJar
-  VERSION = '0.13.0'
+  VERSION = '0.14.0'
 end

data/lib/lock_jar.rb

@@ -13,12 +13,13 @@
 # License for the specific language governing permissions and limitations under
 # the License.
 
-require "yaml"
-require 'rubygems'
+require 'yaml'
 require 'lock_jar/resolver'
 require 'lock_jar/runtime'
 require 'lock_jar/version'
 require 'lock_jar/domain/lockfile'
+require 'lock_jar/domain/jarfile_dsl'
+require 'lock_jar/domain/gem_dsl'
 require 'lock_jar/domain/dsl'
 
 #
@@ -27,128 +28,159 @@ require 'lock_jar/domain/dsl'
 # @author Michael Guymon
 #
 module LockJar
+  class << self
+    #
+    # Override LockJar configuration
+    #
+    def config(opts)
+      Runtime.instance.resolver(opts)
+    end
 
-  #
-  # Override LockJar configuration
-  #
-  def self.config( opts )
-    Runtime.instance.resolver( opts )
-  end
-
-  def self.install( *args, &blk )
-    lockfile, groups, opts = extract_args :lockfile, args, &blk
-    Runtime.instance.install( lockfile, groups, opts, &blk )
-  end
-
-
-  # 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 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
-  #   * :resolve [Boolean] to true will make transitive dependences resolve before loading to classpath
-  #
-  # A block can be passed in, overriding values from a Jarfile.lock.
-  #
-  # @return [Array] of jar and mapped path
-  def self.list( *args, &blk )
-    lockfile, groups, opts = extract_args :lockfile, args, &blk
-    Runtime.instance.list( lockfile, groups, opts, &blk )
-  end
+    def install(*args, &blk)
+      lockfile, groups, opts = extract_args :lockfile, args, &blk
+      Runtime.instance.install(lockfile, groups, opts, &blk)
+    end
 
-  # 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 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
-  #
-  # A block can be passed in, overriding values from a Jarfile.lock.
-  #
-  # @return [Array] of absolute paths of jars and mapped paths loaded into claspath
-  def self.load( *args, &blk )
-    lockfile, groups, opts = extract_args :lockfile, args, &blk
-    Runtime.instance.load( lockfile, groups, opts, &blk )
-  end
+    # 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 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
+    #   * :resolve [Boolean] to true will make transitive dependences resolve
+    #                        before loading to classpath
+    #
+    # A block can be passed in, overriding values from a Jarfile.lock.
+    #
+    # @return [Array] of jar and mapped path
+    def list(*args, &blk)
+      lockfile, groups, opts = extract_args :lockfile, args, &blk
+      Runtime.instance.list(lockfile, groups, opts, &blk)
+    end
 
-  # Lock a Jarfile and generate a Jarfile.lock.
-  #
-  # LockJar.lock accepts an Array for parameters. Depending on the type of arg, a different configuration is set.
-  #
-  # * An arg of a String will set the Jarfile, e.g. 'Jarfile.different'. Default Jarfile is *Jarfile*.
-  # * An arg of a Hash will set the options, e.g. { :local_repo => 'path' }
-  #   * :download_artifacts if true, will download jars to local repo. Defaults to true.
-  #   * :local_repo sets the local repo path
-  #   * :lockfile sets the Jarfile.lock path. Default lockfile is *Jarfile.lock*.
-  #
-  # A block can be passed in, overriding values from a Jarfile.
-  #
-  # @return [Hash] Lock data
-  def self.lock( *args, &blk )
-    jarfile, groups, opts = extract_args :jarfile, args, &blk
-    Runtime.instance.lock( jarfile, opts, &blk )
-  end
+    # 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 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
+    #    * :resolve [Boolean] to true will make transitive dependences resolve
+    #                         before loading to classpath
+    #    * :disable [Boolean] to true will disable any additional calls to load and lock
+    #
+    # A block can be passed in, overriding values from a Jarfile.lock.
+    #
+    # @return [Array] of absolute paths of jars and mapped paths loaded into claspath
+    def load(*args, &blk)
+      if Runtime.instance.opts.nil? || !Runtime.instance.opts[:disable]
+        lockfile, groups, opts = extract_args(:lockfile, args, &blk)
+        Runtime.instance.load(lockfile, groups, opts, &blk)
+      else
+        puts 'LockJar#load has been disabled'
+        []
+      end
+    end
 
-  #
-  # 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 )
-    LockJar::Domain::Lockfile.read( lockfile )
-  end
+    # Lock a Jarfile and generate a Jarfile.lock.
+    #
+    # LockJar.lock accepts an Array for parameters. Depending on the type of
+    # arg, a different configuration is set.
+    #
+    # * An arg of a String will set the Jarfile, e.g. 'Jarfile.different'.
+    #   Default Jarfile is *Jarfile*.
+    # * An arg of a Hash will set the options, e.g. { :local_repo => 'path' }
+    #   * :download_artifacts if true, will download jars to local repo. Defaults to true.
+    #   * :local_repo sets the local repo path
+    #   * :lockfile sets the Jarfile.lock path. Default lockfile is *Jarfile.lock*.
+    #   * :disable [Boolean] to true will disable any additional calls to load and lock
+
+    # A block can be passed in, overriding values from a Jarfile.
+    #
+    # @return [Hash] Lock data
+    def lock(*args, &blk)
+      if Runtime.instance.opts.nil? || !Runtime.instance.opts[:disable]
+        jarfile, _, opts = extract_args(:jarfile, args, &blk)
+        Runtime.instance.lock(jarfile, opts, &blk)
+      else
+        puts 'LockJar#lock has been disabled'
+        []
+      end
+    end
 
-  # Add a Jarfile to be included when LockJar.lock_registered_jarfiles is called.
-  #
-  # @param [String] jarfile path to register
-  # @return [Array] All registered jarfiles
-  def self.register_jarfile( jarfile )
-    fail "Jarfile not found: #{ jarfile }" unless File.exists? jarfile
-    registered_jarfiles << jarfile
-  end
+    #
+    # Read a Jafile.lock and convert it to a LockJar::Domain::Lockfile
+    #
+    # @param [String] lockfile path to lockfile
+    # @return [Hash] Lock Data
+    def read(lockfile)
+      LockJar::Domain::Lockfile.read(lockfile)
+    end
 
-  def self.reset_registered_jarfiles
-    @@registered_jarfiles = []
-  end
+    # Add a Jarfile to be included when LockJar.lock_registered_jarfiles is called.
+    #
+    # @param [String] jarfile path to register
+    # @param [GemSpec] gem spec if the Jarfile is from a gem
+    # @return [Array] All registered jarfiles
+    def register_jarfile(jarfile, gem_spec = nil)
+      fail "Jarfile not found: #{jarfile}" unless File.exist? jarfile
+      registered_jarfiles[jarfile] = gem_spec
+    end
 
-  def self.registered_jarfiles
-    @@registered_jarfiles ||= []
-  end
+    # Clear all registered jarfiles
+    def reset_registered_jarfiles
+      @registered_jarfiles = {}
+    end
 
-  # Lock the registered Jarfiles and generate a Jarfile.lock.
-  #
-  # Options and groups are passed through to the LockJar.lock method, but
-  # if a Jarfile is specified, it will be ignored. Use LockJar.register_jarfile
-  # to add dependencies.
-  #
-  # A block can be passed in, overriding values from the Jarfiles.
-  #
-  # @return [Hash] Lock data
-  def self.lock_registered_jarfiles( *args, &blk )
-    jarfiles = registered_jarfiles
-    return if jarfiles.empty?
-    instances = jarfiles.map do |jarfile|
-      LockJar::Domain::JarfileDsl.create jarfile
+    # Hash of registered jarfiles
+    def registered_jarfiles
+      @registered_jarfiles ||= {}
     end
-    combined = instances.reduce do |result, inst|
-      LockJar::Domain::DslHelper.merge result, inst
+
+    # Lock the registered Jarfiles and generate a Jarfile.lock.
+    #
+    # Options and groups are passed through to the LockJar.lock method, but
+    # if a Jarfile is specified, it will be ignored. Use LockJar.register_jarfile
+    # to add dependencies.
+    #
+    # A block can be passed in, overriding values from the Jarfiles.
+    #
+    # @return [Hash] Lock data
+    def lock_registered_jarfiles(*args, &blk)
+      jarfiles = registered_jarfiles
+      return if jarfiles.empty?
+      instances = jarfiles.map do |jarfile, spec|
+        if spec
+          LockJar::Domain::GemDsl.create spec, jarfile
+        else
+          LockJar::Domain::JarfileDsl.create jarfile
+        end
+      end
+      combined = instances.reduce do |result, inst|
+        LockJar::Domain::DslMerger.new(result, inst).merge
+      end
+      args = args.reject { |arg| arg.is_a? String }
+      lock(combined, *args, &blk)
     end
-    args = args.reject { |arg| arg.is_a? String }
-    lock combined, *args, &blk
   end
 
   private
 
-  def self.extract_args(type, args, &blk )
+  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  def self.extract_args(type, args, &blk)
     lockfile_or_path = nil
     opts = {}
     groups = ['default']
     args.each do |arg|
       case arg
       when Hash
-        opts.merge!( arg )
+        opts.merge!(arg)
       when String
         lockfile_or_path = arg
       when LockJar::Domain::Lockfile
@@ -168,5 +200,5 @@ module LockJar
     end
     [lockfile_or_path, groups, opts]
   end
+  # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 end
-