lock_jar 0.13.0 → 0.14.0

data/lib/lock_jar/domain/dsl.rb

@@ -14,13 +14,13 @@
 # the License.
 
 require 'lock_jar/maven'
-require 'lock_jar/domain/dsl_helper'
+require 'lock_jar/domain/dsl_merger'
 require 'lock_jar/domain/artifact'
 
 module LockJar
   module Domain
+    #
     class Dsl
-
       DEFAULT_GROUP = ['default']
 
       attr_accessor :artifacts, :remote_repositories, :local_repository, :groups,
@@ -29,46 +29,31 @@ module LockJar
       attr_reader :file_path
 
       class << self
-
         def create(jarfile = nil, &blk)
           builder = new
           evaluate(builder, jarfile, &blk)
         end
 
         def evaluate(builder, jarfile = nil, &blk)
-          if jarfile.nil? && blk.nil?
-            raise "jarfile or block must be set"
-          end
+          fail 'jarfile or block must be set' if jarfile.nil? && blk.nil?
 
-          if jarfile
-            builder.instance_eval(DslHelper.read_file(jarfile.to_s), jarfile.to_s, 1)
-          end
+          builder.instance_eval(IO.read(jarfile.to_s), jarfile.to_s, 1) if jarfile
 
-          if blk
-            builder.instance_eval(&blk)
-          end
+          builder.instance_eval(&blk) if blk
 
           builder
         end
-
       end
 
       def initialize
-
         @remote_repositories = []
         @artifacts = { 'default' => [] }
-
         @group_changed = false
-
         @present_group = 'default'
-
         @local_repository = nil
         @maps = {}
-
         @excludes = []
-
         @merged = []
-
         @clear_repositories = false
       end
 
@@ -78,83 +63,78 @@ module LockJar
 
       def jar(notation, *args)
         opts = {}
-        if args.last.is_a? Hash
-          opts.merge!( args.last )
-        end
 
-        artifact = Jar.new( notation )
+        opts.merge!(args.last) if args.last.is_a? Hash
+
+        artifact = Jar.new(notation)
 
-        assign_groups( artifact, opts[:group] )
+        assign_groups(artifact, opts[:group])
       end
 
-      def local( *args )
-        unless args.empty?
-          if File.directory?( File.expand_path( args.first ) )
-            warn "[DEPRECATION] `local` to set local_repository is deprecated.  Please use `local_repo` instead."
-            local_repo(args.first)
-          else
-            path = args.shift
+      def local(*args)
+        return if args.empty?
 
-            opts = {}
-            if args.last.is_a? Hash
-              opts.merge!( args.last )
-            end
+        if File.directory?(File.expand_path(args.first))
+          warn(
+            '[DEPRECATED] `local` to set local_repository is deprecated. '\
+            'Please use `local_repo` instead'
+          )
+          local_repo(args.first)
+        else
+          path = args.shift
 
-            artifact = Local.new( path )
+          opts = {}
 
-            assign_groups( artifact, opts[:group] )
-          end
+          opts.merge!(args.last) if args.last.is_a? Hash
+
+          artifact = Local.new(path)
+
+          assign_groups(artifact, opts[:group])
         end
       end
 
-      def local_repo( path )
+      def local_repo(path)
         @local_repository = path
       end
 
       alias_method :name, :local_repository
 
       # Map a dependency to another dependency or local directory.
-      def map( notation, *args )
+      def map(notation, *args)
         @maps[notation] = args
       end
 
       #
       def pom(path, *args)
-        unless path =~ /\.xml$/i
-          raise "#{path} is an invalid pom path"
-        end
+        fail "#{path} is an invalid pom path" unless path =~ /\.xml$/i
 
-        opts = { :scopes => ['runtime', 'compile'] }
+        opts = { scopes: %w(runtime compile) }
 
-        if args.last.is_a? Hash
-          opts.merge! args.last
-        end
-
-        artifact = Pom.new( path, opts[:scopes] )
+        opts.merge!(args.last) if args.last.is_a? Hash
 
-        assign_groups( artifact, opts[:groups] )
+        assign_groups(Pom.new(path, opts[:scopes]), opts[:groups])
       end
 
-      def remote_repo( url, opts = {} )
+      def remote_repo(url, _opts = {})
         @remote_repositories << url
       end
       alias_method :remote_repository, :remote_repo
       alias_method :repository, :remote_repo
 
-      def group(*groups, &blk)
-         @group_changed = true
-         groups.each do |group|
-           @present_group = group.to_s
-           yield
-         end
-         @group_changed = false
-         @present_group = 'default'
+      def group(*groups, &_blk)
+        @group_changed = true
+        groups.each do |group|
+          @present_group = group.to_s
+          yield
+        end
+        @group_changed = false
+        @present_group = 'default'
       end
 
       # @deprecated Please use {#group} instead
       def scope(*scopes, &blk)
-        warn "[DEPRECATION] `scope` is deprecated.  Please use `group` instead."
-        group(*scopes,&blk)
+        warn '[DEPRECATED] `scope` is deprecated.  Please use `group` instead.'
+        group(*scopes, &blk)
       end
 
       def without_default_maven_repo
@@ -162,33 +142,24 @@ module LockJar
       end
 
       private
-      def assign_groups(artifact, groups=nil)
 
+      def assign_groups(artifact, groups = nil)
         if groups
-
-          unless groups.is_a? Array
-            groups = [groups]
-          end
+          groups = Array(groups)
 
           # include present group if within a group block
-          if @group_changed
-            groups << @present_group
-          end
+          groups << @present_group if @group_changed
 
         else
           groups = [@present_group]
         end
 
-        if artifact
-          groups.uniq.each do |group|
-            group_key = group.to_s
-            @artifacts[group_key] = [] unless @artifacts[group_key]
-            @artifacts[group_key] << artifact
-          end
-        end
-
+        groups.uniq.each do |group|
+          group_key = group.to_s
+          @artifacts[group_key] = [] unless @artifacts[group_key]
+          @artifacts[group_key] << artifact
+        end if artifact
       end
-
     end
   end
 end

data/lib/lock_jar/domain/dsl_merger.rb

@@ -0,0 +1,76 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with this
+# work for additional information regarding copyright ownership. The ASF
+# licenses this file to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+module LockJar
+  module Domain
+    # Merge DSLs
+    class DslMerger
+      attr_reader :into_dsl, :from_dsl, :into_groups
+
+      # @param [LockJar::Domain::Dsl] into_dsl dsl that is merged into
+      # @param [LockJar::Domain::Dsl] from_dsl dsl that is merged from
+      # @param [String] into_group force only runtime and default groups to be
+      #                            loaded into this group
+      def initialize(into_dsl, from_dsl, into_groups = nil)
+        @into_dsl = into_dsl
+        @from_dsl = from_dsl
+        @into_groups = into_groups
+      end
+
+      # Merge LockJar::Domain::Dsl
+      # @return [LockJar::Domain::Dsl]
+      def merge
+        merged_dsl = into_dsl.dup
+
+        merged_dsl.remote_repositories = remote_repositories
+
+        merged_dsl.artifacts = artifact_groups(into_groups)
+
+        from_dsl.maps.each do |artifact, paths|
+          maps = into_dsl.maps[artifact] || []
+          merged_dsl.maps[artifact] = (maps + paths).uniq
+        end
+
+        from_dsl.excludes.each do |exclude|
+          merged_dsl.excludes << exclude unless into_dsl.excludes.include? exclude
+        end
+
+        merged_dsl.merged << from_dsl.file_path if from_dsl.file_path
+
+        merged_dsl
+      end
+
+      private
+
+      def remote_repositories
+        (into_dsl.remote_repositories + from_dsl.remote_repositories).uniq
+      end
+
+      def artifact_groups(restrict = nil)
+        artifacts = Hash.new { |hash, key| hash[key] = [] }
+
+        from_dsl.artifacts.each do |group, group_artifacts|
+          next if restrict && !restrict.include?(group)
+          artifacts[group] += into_dsl.artifacts[group] || []
+          group_artifacts.each do |art|
+            artifacts[group] << art unless artifacts[group].include? art
+          end
+        end
+
+        artifacts
+      end
+    end
+  end
+end

data/lib/lock_jar/domain/gem_dsl.rb

@@ -15,31 +15,29 @@
 
 require 'lock_jar/maven'
 require 'lock_jar/domain/jarfile_dsl'
-require 'lock_jar/domain/dsl_helper'
+require 'lock_jar/domain/dsl_merger'
 
 module LockJar
   module Domain
+    # Jarfile found in a Gem
     class GemDsl < JarfileDsl
-  
       attr_accessor :gem_dir
-      
+
       class << self
-        alias :overriden_create :create
         def create(spec, jarfile)
           builder = new
           builder.gem_dir = spec.gem_dir
-          
-          jarfile = File.join( spec.gem_dir, jarfile )
-          builder.file_path = "gem:#{spec.name}:#{jarfile.gsub( "#{spec.base_dir}/", "" )}.lock"
-          
+
+          builder.file_path = "gem:#{spec.name}:Jarfile.lock"
+
           evaluate(builder, jarfile)
         end
       end
-      
-      alias :overriden_pom :pom
+
+      alias_method :overriden_pom, :pom
       def pom(path, *args)
-        overriden_pom( File.join( gem_dir, path), *args)
+        overriden_pom(File.join(gem_dir, path), *args)
       end
     end
   end
-end
+end

data/lib/lock_jar/domain/jarfile_dsl.rb

@@ -14,34 +14,22 @@
 # the License.
 
 require 'lock_jar/maven'
-require 'lock_jar/domain/dsl_helper'
+require 'lock_jar/domain/dsl_merger'
 
 module LockJar
   module Domain
+    # Jarfile DSL
     class JarfileDsl < Dsl
-  
-      attr_accessor :file_path, :bundler_enabled
-      
+      attr_accessor :file_path
+
       class << self
-        alias :overriden_create :create
         def create(jarfile)
           builder = new
           builder.file_path = jarfile
-          
-          evaluate(builder, jarfile)
-        end
-      end
 
-      def bundler(*groups)
-        if groups.nil?
-          groups = [:default]
-        else
-          groups = groups.map(&:to_sym)
+          evaluate(builder, jarfile)
         end
-
-        @bundler_enabled = groups
       end
-  
     end
   end
-end
+end

data/lib/lock_jar/domain/lockfile.rb

@@ -13,21 +13,22 @@
 # License for the specific language governing permissions and limitations under
 # the License.
 
-require "yaml"
-require 'lock_jar/version'
+require 'yaml'
 require 'set'
+require 'lock_jar/version'
 
 module LockJar
   module Domain
+    # Class representation of the lock file
     class Lockfile
-
       attr_accessor :local_repository, :maps, :excludes, :remote_repositories,
                     :version, :groups, :gems, :merged
 
-      def self.read( path )
+      # rubocop:disable Metrics/PerceivedComplexity
+      def self.read(path)
         lockfile = Lockfile.new
 
-        lock_data = YAML.load_file( path )
+        lock_data = YAML.load_file(path)
 
         lockfile.version = lock_data['version'] || LockJar::VERSION
         lockfile.merged = lock_data['merged']
@@ -36,10 +37,12 @@ module LockJar
         lockfile.maps = lock_data['maps'] || []
         lockfile.excludes = lock_data['excludes'] || []
         lockfile.groups = lock_data['groups'] || lock_data['scopes'] || {}
-        lockfile.remote_repositories = Set.new( Array(lock_data['remote_repositories'] || lock_data['repositories']) )
+        lockfile.remote_repositories =
+          Set.new(Array(lock_data['remote_repositories'] || lock_data['repositories']))
         lockfile.gems = lock_data['gems'] || []
         lockfile
       end
+      # rubocop:enable Metrics/PerceivedComplexity
 
       def initialize
         @groups = { 'default' => {} }
@@ -55,25 +58,15 @@ module LockJar
       def to_hash
         lock_data = { 'version' => @version }
 
-        unless local_repository.nil?
-          lock_data['local_repository'] = local_repository
-        end
+        lock_data['local_repository'] = local_repository unless local_repository.nil?
 
-        unless merged.empty?
-          lock_data['merged'] = merged
-        end
+        lock_data['merged'] = merged unless merged.empty?
 
-        if maps.size > 0
-          lock_data['maps'] = maps
-        end
+        lock_data['maps'] = maps if maps.size > 0
 
-        if excludes.size > 0
-          lock_data['excludes'] = excludes
-        end
+        lock_data['excludes'] = excludes if excludes.size > 0
 
-        unless gems.empty?
-          lock_data['gems'] = gems
-        end
+        lock_data['gems'] = gems unless gems.empty?
 
         lock_data['groups'] = groups
 
@@ -89,9 +82,9 @@ module LockJar
         to_hash.to_yaml
       end
 
-      def write( path )
-        File.open( path, "w") do |f|
-          f.write( to_yaml )
+      def write(path)
+        File.open(path, 'w') do |f|
+          f.write(to_yaml)
         end
       end
     end

data/lib/lock_jar/logging.rb

@@ -1,12 +1,13 @@
 require 'naether/java'
 
 module LockJar
+  #
   class Logging
     def self.verbose!
       Naether::Java.exec_static_method(
-        "com.tobedevoured.naether.LogUtil",
-        "setDefaultLogLevel",
-        ["info"]
+        'com.tobedevoured.naether.LogUtil',
+        'setDefaultLogLevel',
+        ['info']
       )
     end
   end

data/lib/lock_jar/maven.rb

@@ -16,15 +16,12 @@
 require 'naether/maven'
 
 module LockJar
-  
   # Helper for providing Maven specific operations
   #
   # @author Michael Guymon
-  # 
+  #
   class Maven
-    
     class << self
-      
       #
       # Get the version of a POM
       #
@@ -32,11 +29,11 @@ module LockJar
       #
       # @return [String] version of POM
       #
-      def pom_version( pom_path )
-        maven = Naether::Maven.create_from_pom( pom_path )
-        maven.version()
+      def pom_version(pom_path)
+        maven = Naether::Maven.create_from_pom(pom_path)
+        maven.version
       end
-      
+
       #
       # Get dependencies of a Pom
       #
@@ -45,32 +42,33 @@ module LockJar
       #
       # @return [String] version of POM
       #
-      def dependencies( pom_path, scopes = ['compile', 'runtime'] )
-        maven = Naether::Maven.create_from_pom( pom_path )
+      def dependencies(pom_path, scopes = %w(compile runtime))
+        maven = Naether::Maven.create_from_pom(pom_path)
         maven.dependencies(scopes)
       end
-      
+
       #
       # Write a POM from list of notations
       #
       # @param [String] pom notation
       # @param [String] file_path path of new pom
       # @param [Hash] opts
-      # @option opts [Boolean] :include_resolved to add dependencies of resolve dependencies from Jarfile.lock. Default is true.
+      # @option opts [Boolean] :include_resolved to add dependencies of resolve
+      #                        dependencies from Jarfile.lock. Default is true.
       # @option opts [Array] :dependencies Array of of mixed dependencies:
-      #  * [String] Artifact notation, such as groupId:artifactId:version, e.g. 'junit:junit:4.7' 
+      #  * [String] Artifact notation, such as groupId:artifactId:version, e.g. 'junit:junit:4.7'
       #  * [Hash] of a single artifaction notation => scope - { 'junit:junit:4.7' => 'test' }
       #
-      def write_pom( notation, file_path, opts = {} )
-        opts = {:include_resolved => true}.merge( opts )
-        
-        maven = Naether::Maven.create_from_notataion( notation )
-        
+      def write_pom(notation, file_path, opts = {})
+        opts = { include_resolved: true }.merge(opts)
+
+        maven = Naether::Maven.create_from_notataion(notation)
+
         if opts[:include_resolved]
           # Passes in nil to the resolver to get the cache
-          maven.load_naether( Runtime.instance.resolver.naether )
+          maven.load_naether(Runtime.instance.resolver.naether)
         end
-        
+
         if opts[:dependencies]
           opts[:dependencies].each do |dep|
             if dep.is_a? Array
@@ -80,22 +78,24 @@ module LockJar
             end
           end
         end
-        maven.write_pom( file_path )
+
+        maven.write_pom(file_path)
       end
-      
+
       #
       # Deploy an artifact to a Maven repository
       #
       # @param [String] notation of artifact
       # @param [String] file_path path to the Jar
       # @param [String] url Maven repository deploying to
-      # @param [Hash] deploy_opts options for deploying 
+      # @param [Hash] deploy_opts options for deploying
       # @param [Hash] lockjar_opts options for initializing LockJar
       #
-      def deploy_artifact( notation, file_path, url, deploy_opts = {}, lockjar_opts = {} )
-        Runtime.instance.resolver(lockjar_opts).naether.deploy_artifact( notation, file_path, url, deploy_opts )
+      def deploy_artifact(notation, file_path, url, deploy_opts = {}, lockjar_opts = {})
+        Runtime.instance.resolver(lockjar_opts).naether.deploy_artifact(
+          notation, file_path, url, deploy_opts)
       end
-      
+
       #
       # Install an artifact to a local repository
       #
@@ -104,9 +104,9 @@ module LockJar
       # @param [String] jar_path path to the jar
       # @param [Hash] opts options
       #
-      def install( notation, pom_path, jar_path, opts = {} )
-        Runtime.instance.resolver(opts).naether.install( notation, pom_path, jar_path )
+      def install(notation, pom_path, jar_path, opts = {})
+        Runtime.instance.resolver(opts).naether.install(notation, pom_path, jar_path)
       end
     end
   end
-end
+end