kpm 0.7.2 → 0.8.0

data/lib/kpm/base_artifact.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require 'digest/sha1'
 require 'rexml/document'
 
 module KPM
-
   class ArtifactCorruptedException < IOError
     def message
       'Downloaded artifact failed checksum verification'
@@ -34,32 +35,32 @@ module KPM
     KAUI_CLASSIFIER  = nil
 
     class << self
-      def pull(logger, group_id, artifact_id, packaging='jar', classifier=nil, version='LATEST', destination_path=nil, sha1_file=nil, force_download=false, verify_sha1=true, overrides={}, ssl_verify=true)
-        coordinate_map = {:group_id => group_id, :artifact_id => artifact_id, :packaging => packaging, :classifier => classifier, :version => version}
+      def pull(logger, group_id, artifact_id, packaging = 'jar', classifier = nil, version = 'LATEST', destination_path = nil, sha1_file = nil, force_download = false, verify_sha1 = true, overrides = {}, ssl_verify = true)
+        coordinate_map = { group_id: group_id, artifact_id: artifact_id, packaging: packaging, classifier: classifier, version: version }
         pull_and_put_in_place(logger, coordinate_map, nil, destination_path, false, sha1_file, force_download, verify_sha1, overrides, ssl_verify)
       end
 
-      def pull_from_fs(logger, file_path, destination_path=nil)
+      def pull_from_fs(logger, file_path, destination_path = nil)
         pull_from_fs_and_put_in_place(logger, file_path, destination_path)
       end
 
-      def nexus_remote(overrides={}, ssl_verify=true, logger=nil)
+      def nexus_remote(overrides = {}, ssl_verify = true, logger = nil)
         # overrides typically comes from the kpm.yml where we expect keys as String
-        overrides_sym = (overrides || {}).each_with_object({}) {|(k,v), h| h[k.to_sym] = v}
+        overrides_sym = (overrides || {}).each_with_object({}) { |(k, v), h| h[k.to_sym] = v }
         nexus_config = nexus_defaults.merge(overrides_sym)
-        nexus_remote ||= KPM::NexusFacade::RemoteFactory.create(nexus_config, ssl_verify, logger)
+        KPM::NexusFacade::RemoteFactory.create(nexus_config, ssl_verify, logger)
       end
 
       def nexus_defaults
         {
-            url:        'https://oss.sonatype.org',
-            repository: 'releases'
+          url: 'https://oss.sonatype.org',
+          repository: 'releases'
         }
       end
 
       protected
 
-      def pull_and_put_in_place(logger, coordinate_map, plugin_name, destination_path=nil, skip_top_dir=true, sha1_file=nil, force_download=false, verify_sha1=true, overrides={}, ssl_verify=true)
+      def pull_and_put_in_place(logger, coordinate_map, plugin_name, destination_path = nil, skip_top_dir = true, sha1_file = nil, force_download = false, verify_sha1 = true, overrides = {}, ssl_verify = true)
         # Build artifact info
         artifact_info = artifact_info(logger, coordinate_map, sha1_file, force_download, overrides, ssl_verify)
         artifact_info[:plugin_name] = plugin_name
@@ -104,7 +105,7 @@ module KPM
           logger.info "      Starting download of #{coordinates} to #{tmp_destination_dir}"
 
           downloaded_artifact_info = pull_and_verify(logger, artifact_info[:sha1], coordinates, tmp_destination_dir, sha1_file, verify_sha1, overrides, ssl_verify)
-          remove_old_default_bundles(coordinate_map,artifact_info,downloaded_artifact_info)
+          remove_old_default_bundles(coordinate_map, artifact_info, downloaded_artifact_info)
           if artifact_info[:is_tgz]
             artifact_info[:bundle_dir] = Utils.unpack_tgz(downloaded_artifact_info[:file_path], artifact_info[:dir_name], skip_top_dir)
             FileUtils.rm downloaded_artifact_info[:file_path]
@@ -119,11 +120,11 @@ module KPM
       end
 
       # Logic similar than pull_and_put_in_place above
-      def pull_from_fs_and_put_in_place(logger, file_path, destination_path=nil)
+      def pull_from_fs_and_put_in_place(logger, file_path, destination_path = nil)
         artifact_info = {
-            :skipped => false,
-            :repository_path => file_path,
-            :is_tgz => file_path.end_with?('.tar.gz') || file_path.end_with?('.tgz')
+          skipped: false,
+          repository_path: file_path,
+          is_tgz: file_path.end_with?('.tar.gz') || file_path.end_with?('.tgz')
         }
 
         populate_fs_info(artifact_info, destination_path)
@@ -148,7 +149,7 @@ module KPM
         return false if artifact_info[:sha1].nil?
 
         # If there is no such sha1_file, we don't skip
-        return false if sha1_file.nil? || !File.exists?(sha1_file)
+        return false if sha1_file.nil? || !File.exist?(sha1_file)
 
         #
         # At this point we have a valid sha1_file and a remote sha1
@@ -168,9 +169,9 @@ module KPM
         end
       end
 
-      def artifact_info(logger, coordinate_map, sha1_file=nil, force_download=false, overrides={}, ssl_verify=true)
+      def artifact_info(logger, coordinate_map, sha1_file = nil, force_download = false, overrides = {}, ssl_verify = true)
         info = {
-            :skipped => false
+          skipped: false
         }
 
         sha1_checker = sha1_file ? Sha1Checker.from_file(sha1_file) : nil
@@ -179,16 +180,14 @@ module KPM
         begin
           nexus_info = nexus_remote(overrides, ssl_verify, logger).get_artifact_info(coordinates)
         rescue KPM::NexusFacade::ArtifactMalformedException => e
-          raise StandardError.new("Invalid coordinates #{coordinate_map}: #{e}")
+          raise StandardError, "Invalid coordinates #{coordinate_map}: #{e}"
         rescue StandardError => e
           logger.warn("Unable to retrieve coordinates #{coordinate_map}: #{e}")
           cached_coordinates = sha1_checker ? sha1_checker.artifact_info(coordinates) : nil
-          if force_download || !cached_coordinates
-            raise e
-          else
-            # Use the cache
-            return cached_coordinates
-          end
+          raise e if force_download || !cached_coordinates
+
+          # Use the cache
+          return cached_coordinates
         end
 
         xml = REXML::Document.new(nexus_info)
@@ -204,7 +203,7 @@ module KPM
 
       def update_destination_path(info, destination_path)
         # In case LATEST was specified, use the actual version as the directory name
-        destination_path = KPM::root if destination_path.nil?
+        destination_path = KPM.root if destination_path.nil?
         plugin_dir, version_dir = File.split(destination_path)
         destination_path = Pathname.new(plugin_dir).join(info[:version]).to_s if version_dir == 'LATEST' && !info[:version].nil?
         destination_path
@@ -231,13 +230,14 @@ module KPM
         destination_path
       end
 
-      def pull_and_verify(logger, remote_sha1, coordinates, destination_dir, sha1_file, verify_sha1, overrides={}, ssl_verify=true)
+      def pull_and_verify(logger, remote_sha1, coordinates, destination_dir, sha1_file, verify_sha1, overrides = {}, ssl_verify = true)
         info = nexus_remote(overrides, ssl_verify, logger).pull_artifact(coordinates, destination_dir)
 
         # Always verify sha1 and if incorrect either throw or log when we are asked to bypass sha1 verification
         verified = verify(logger, coordinates, info[:file_path], remote_sha1)
-        if !verified
+        unless verified
           raise ArtifactCorruptedException if verify_sha1
+
           logger.warn("Skip sha1 verification for  #{coordinates}")
         end
 
@@ -258,13 +258,10 @@ module KPM
 
         local_sha1 = Digest::SHA1.file(file_path).hexdigest
         res = local_sha1 == remote_sha1
-        if !res
-          logger.warn("Sha1 verification failed for #{coordinates} : local_sha1 = #{local_sha1}, remote_sha1 = #{remote_sha1}")
-        end
+        logger.warn("Sha1 verification failed for #{coordinates} : local_sha1 = #{local_sha1}, remote_sha1 = #{remote_sha1}") unless res
         res
       end
 
-
       # Magic methods...
 
       def path_looks_like_a_directory(path)
@@ -275,12 +272,12 @@ module KPM
 
         last_part = File.basename(path).downcase
 
-        %w(.pom .xml .war .jar .xsd .tar.gz .tgz .gz .zip).each do |classic_file_extension|
+        %w[.pom .xml .war .jar .xsd .tar.gz .tgz .gz .zip].each do |classic_file_extension|
           return false if last_part.end_with?(classic_file_extension)
         end
 
         # Known magic files
-        %w(root).each do |classic_filename|
+        %w[root].each do |classic_filename|
           return false if last_part == classic_filename
         end
 
@@ -296,12 +293,9 @@ module KPM
 
         existing_default_bundles.each do |bundle|
           bundle_name = Utils.get_plugin_name_from_file_path(bundle)
-          is_downloaded = downloaded_default_bundles.index {|file_name| file_name.include? bundle_name}
-          unless is_downloaded.nil?
-            FileUtils.remove(bundle)
-          end
+          is_downloaded = downloaded_default_bundles.index { |file_name| file_name.include? bundle_name }
+          FileUtils.remove(bundle) unless is_downloaded.nil?
         end
-
       end
     end
   end

data/lib/kpm/base_installer.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 require 'pathname'
 require 'zip'
 
 module KPM
   class BaseInstaller
-
     LATEST_VERSION = 'LATEST'
     SHA1_FILENAME = 'sha1.yml'
     DEFAULT_BUNDLES_DIR = Pathname.new('/var').join('tmp').join('bundles').to_s
@@ -15,13 +16,13 @@ module KPM
       @trace_logger = KPM::TraceLogger.new
     end
 
-    def install_killbill_server(specified_group_id=nil, specified_artifact_id=nil, specified_packaging=nil, specified_classifier=nil, specified_version=nil, specified_webapp_path=nil,  bundles_dir=nil, force_download=false, verify_sha1=true)
+    def install_killbill_server(specified_group_id = nil, specified_artifact_id = nil, specified_packaging = nil, specified_classifier = nil, specified_version = nil, specified_webapp_path = nil, bundles_dir = nil, force_download = false, verify_sha1 = true)
       group_id = specified_group_id || KPM::BaseArtifact::KILLBILL_GROUP_ID
       artifact_id = specified_artifact_id || KPM::BaseArtifact::KILLBILL_ARTIFACT_ID
       packaging = specified_packaging || KPM::BaseArtifact::KILLBILL_PACKAGING
       classifier = specified_classifier || KPM::BaseArtifact::KILLBILL_CLASSIFIER
       version = specified_version || LATEST_VERSION
-      webapp_path = specified_webapp_path || KPM::root
+      webapp_path = specified_webapp_path || KPM.root
       bundles_dir = Pathname.new(bundles_dir || DEFAULT_BUNDLES_DIR).expand_path
       sha1_file = "#{bundles_dir}/#{SHA1_FILENAME}"
 
@@ -32,60 +33,55 @@ module KPM
 
       @logger.debug("Installing Kill Bill server: group_id=#{group_id} artifact_id=#{artifact_id} packaging=#{packaging} classifier=#{classifier} version=#{version} webapp_path=#{webapp_path}")
       artifact_info = KPM::KillbillServerArtifact.pull(@logger,
-                                       group_id,
-                                       artifact_id,
-                                       packaging,
-                                       classifier,
-                                       version,
-                                       webapp_path,
-                                       sha1_file,
-                                       force_download,
-                                       verify_sha1,
-                                       @nexus_config,
-                                       @nexus_ssl_verify)
+                                                       group_id,
+                                                       artifact_id,
+                                                       packaging,
+                                                       classifier,
+                                                       version,
+                                                       webapp_path,
+                                                       sha1_file,
+                                                       force_download,
+                                                       verify_sha1,
+                                                       @nexus_config,
+                                                       @nexus_ssl_verify)
       # store trace info to be returned as JSON by the KPM::Installer.install method
-      @trace_logger.add('killbill',
-                           artifact_info.merge({'status'=> (artifact_info[:skipped] ? 'UP_TO_DATE': 'INSTALLED'),
-                            :group_id => group_id, :artifact_id => artifact_id, :packaging => packaging, :classifier => classifier}))
+      @trace_logger.add('killbill', nil,
+                        artifact_info.merge('status' => (artifact_info[:skipped] ? 'UP_TO_DATE' : 'INSTALLED'),
+                                            :group_id => group_id, :artifact_id => artifact_id, :packaging => packaging, :classifier => classifier))
     end
 
-    def install_kaui(specified_group_id=nil, specified_artifact_id=nil, specified_packaging=nil, specified_classifier=nil, specified_version=nil, specified_webapp_path=nil,  bundles_dir=nil, force_download=false, verify_sha1=true)
+    def install_kaui(specified_group_id = nil, specified_artifact_id = nil, specified_packaging = nil, specified_classifier = nil, specified_version = nil, specified_webapp_path = nil, bundles_dir = nil, force_download = false, verify_sha1 = true)
       group_id = specified_group_id || KPM::BaseArtifact::KAUI_GROUP_ID
       artifact_id = specified_artifact_id || KPM::BaseArtifact::KAUI_ARTIFACT_ID
       packaging = specified_packaging || KPM::BaseArtifact::KAUI_PACKAGING
       classifier = specified_classifier || KPM::BaseArtifact::KAUI_CLASSIFIER
       version = specified_version || LATEST_VERSION
-      webapp_path = specified_webapp_path || KPM::root
+      webapp_path = specified_webapp_path || KPM.root
       bundles_dir = Pathname.new(bundles_dir || DEFAULT_BUNDLES_DIR).expand_path
       sha1_file = "#{bundles_dir}/#{SHA1_FILENAME}"
 
       @logger.debug("Installing Kaui: group_id=#{group_id} artifact_id=#{artifact_id} packaging=#{packaging} classifier=#{classifier} version=#{version} webapp_path=#{webapp_path}")
       artifact_info = KPM::KauiArtifact.pull(@logger,
-                             group_id,
-                             artifact_id,
-                             packaging,
-                             classifier,
-                             version,
-                             webapp_path,
-                             sha1_file,
-                             force_download,
-                             verify_sha1,
-                             @nexus_config,
-                             @nexus_ssl_verify)
+                                             group_id,
+                                             artifact_id,
+                                             packaging,
+                                             classifier,
+                                             version,
+                                             webapp_path,
+                                             sha1_file,
+                                             force_download,
+                                             verify_sha1,
+                                             @nexus_config,
+                                             @nexus_ssl_verify)
       # store trace info to be returned as JSON by the KPM::Installer.install method
-      @trace_logger.add('kaui',
-                           artifact_info.merge({'status'=> (artifact_info[:skipped] ? 'UP_TO_DATE': 'INSTALLED'),
-                            :group_id => group_id, :artifact_id => artifact_id, :packaging => packaging, :classifier => classifier}))
-
-
+      @trace_logger.add('kaui', nil,
+                        artifact_info.merge('status' => (artifact_info[:skipped] ? 'UP_TO_DATE' : 'INSTALLED'),
+                                            :group_id => group_id, :artifact_id => artifact_id, :packaging => packaging, :classifier => classifier))
     end
 
-    def install_plugin(plugin_key, raw_kb_version=nil, specified_group_id=nil, specified_artifact_id=nil, specified_packaging=nil, specified_classifier=nil, specified_version=nil, bundles_dir=nil, specified_type=nil, force_download=false, verify_sha1=true, verify_jruby_jar=false)
-
+    def install_plugin(plugin_key, raw_kb_version = nil, specified_group_id = nil, specified_artifact_id = nil, specified_packaging = nil, specified_classifier = nil, specified_version = nil, bundles_dir = nil, specified_type = nil, force_download = false, verify_sha1 = true, verify_jruby_jar = false)
       # plugin_key needs to exist
-      if plugin_key.nil?
-        raise ArgumentError.new 'Aborting installation: User needs to specify a pluginKey'
-      end
+      raise ArgumentError, 'Aborting installation: User needs to specify a pluginKey' if plugin_key.nil?
 
       # Lookup artifact and perform validation against input
       looked_up_group_id, looked_up_artifact_id, looked_up_packaging, looked_up_classifier, looked_up_version, looked_up_type = KPM::PluginsDirectory.lookup(plugin_key, true, raw_kb_version)
@@ -95,21 +91,17 @@ module KPM
       validate_installation_arg!(plugin_key, 'type', specified_type, looked_up_type)
       validate_installation_arg!(plugin_key, 'classifier', specified_classifier, looked_up_classifier)
 
-
       # If there is no entry in plugins_directory.yml and the group_id is not the killbill default group_id, the key provided must be a user key and must have a namespace
       if looked_up_artifact_id.nil? &&
-          specified_group_id != KPM::BaseArtifact::KILLBILL_JAVA_PLUGIN_GROUP_ID &&
-          specified_group_id != KPM::BaseArtifact::KILLBILL_RUBY_PLUGIN_GROUP_ID &&
-          plugin_key.split(':').size == 1
-        raise ArgumentError.new "Aborting installation: pluginKey = #{plugin_key} does not exist in plugin_directory.yml so format of the key must have a user namespace (e.g namespace:key)"
+         specified_group_id != KPM::BaseArtifact::KILLBILL_JAVA_PLUGIN_GROUP_ID &&
+         specified_group_id != KPM::BaseArtifact::KILLBILL_RUBY_PLUGIN_GROUP_ID &&
+         plugin_key.split(':').size == 1
+        raise ArgumentError, "Aborting installation: pluginKey = #{plugin_key} does not exist in plugin_directory.yml so format of the key must have a user namespace (e.g namespace:key)"
       end
 
-
       # Specified parameters have always precedence except for the artifact_id (to map stripe to stripe-plugin)
       artifact_id = looked_up_artifact_id || specified_artifact_id
-      if artifact_id.nil?
-        raise ArgumentError.new "Aborting installation: unable to lookup plugin #{specified_artifact_id}"
-      end
+      raise ArgumentError, "Aborting installation: unable to lookup plugin #{specified_artifact_id}" if artifact_id.nil?
 
       bundles_dir = Pathname.new(bundles_dir || DEFAULT_BUNDLES_DIR).expand_path
       plugins_dir = bundles_dir.join('plugins')
@@ -136,10 +128,9 @@ module KPM
       _, plugin_name = plugins_manager.get_plugin_key_and_name(plugin_key)
 
       # Before we do the install we verify that the entry we have in the plugin_identifiers.json matches our current request
-      coordinate_map = {:group_id => group_id, :artifact_id => artifact_id, :packaging => packaging, :classifier => classifier}
+      coordinate_map = { group_id: group_id, artifact_id: artifact_id, packaging: packaging, classifier: classifier }
       validate_plugin_key!(plugins_dir, plugin_key, coordinate_map)
 
-
       @logger.debug("Installing plugin: group_id=#{group_id} artifact_id=#{artifact_id} packaging=#{packaging} classifier=#{classifier} version=#{version} destination=#{destination}")
       artifact_info = KPM::KillbillPluginArtifact.pull(@logger,
                                                        group_id,
@@ -156,8 +147,8 @@ module KPM
                                                        @nexus_ssl_verify)
       # store trace info to be returned as JSON by the KPM::Installer.install method
       @trace_logger.add('plugins', plugin_key,
-                           artifact_info.merge({'status'=> (artifact_info[:skipped] ? 'UP_TO_DATE': 'INSTALLED'),
-                            :group_id => group_id, :artifact_id => artifact_id, :packaging => packaging, :classifier => classifier}))
+                        artifact_info.merge('status' => (artifact_info[:skipped] ? 'UP_TO_DATE' : 'INSTALLED'),
+                                            :group_id => group_id, :artifact_id => artifact_id, :packaging => packaging, :classifier => classifier))
 
       # Update with resolved version
       coordinate_map[:version] = artifact_info[:version]
@@ -169,14 +160,19 @@ module KPM
       artifact_info
     end
 
+    def install_plugin_from_fs(plugin_key, raw_file_path, name, version, bundles_dir = nil, type = 'java')
+      # Expand glob if needed
+      file_paths = Dir.glob(raw_file_path)
+      raise ArgumentError, "Cannot install plugin: no file found at #{raw_file_path}" if file_paths.empty?
+      raise ArgumentError, "Cannot install plugin: multiple files found at #{raw_file_path}" if file_paths.size > 1
+
+      file_path = file_paths[0]
 
-    def install_plugin_from_fs(plugin_key, file_path, name, version, bundles_dir=nil, type='java')
       bundles_dir = Pathname.new(bundles_dir || DEFAULT_BUNDLES_DIR).expand_path
       plugins_dir = bundles_dir.join('plugins')
 
-      if version.nil?
-        version = Utils.get_version_from_file_path(file_path)
-      end
+      version = Utils.get_version_from_file_path(file_path) if version.nil?
+      raise ArgumentError, 'Cannot install plugin: missing version' if version.nil?
 
       if type.to_s == 'java'
         plugin_name = name.nil? ? Utils.get_plugin_name_from_file_path(file_path) : name
@@ -194,28 +190,26 @@ module KPM
 
       # store trace info to be returned as JSON by the KPM::Installer.install method
       @trace_logger.add('plugins', plugin_key,
-                           artifact_info.merge({'status'=>'INSTALLED'}))
+                        artifact_info.merge('status' => 'INSTALLED'))
 
       artifact_info
     end
 
-    def uninstall_plugin(plugin_name_or_key, plugin_version=nil, bundles_dir=nil)
+    def uninstall_plugin(plugin_name_or_key, plugin_version = nil, bundles_dir = nil)
       bundles_dir = Pathname.new(bundles_dir || DEFAULT_BUNDLES_DIR).expand_path
       plugins_dir = bundles_dir.join('plugins')
 
       plugins_manager = PluginsManager.new(plugins_dir, @logger)
 
       plugin_key, plugin_name = plugins_manager.get_plugin_key_and_name(plugin_name_or_key)
-      if plugin_name.nil?
-        raise ArgumentError.new "Cannot uninstall plugin: Unknown plugin name or plugin key = #{plugin_name_or_key}"
-      end
+      raise ArgumentError, "Cannot uninstall plugin: Unknown plugin name or plugin key = #{plugin_name_or_key}" if plugin_name.nil?
 
       modified = plugins_manager.uninstall(plugin_name, plugin_version || :all)
       plugins_manager.remove_plugin_identifier_key(plugin_key)
       modified
     end
 
-    def install_default_bundles(bundles_dir, specified_version=nil, kb_version=nil, force_download=false, verify_sha1=true)
+    def install_default_bundles(bundles_dir, specified_version = nil, kb_version = nil, force_download = false, verify_sha1 = true)
       group_id = 'org.kill-bill.billing'
       artifact_id = 'killbill-platform-osgi-bundles-defaultbundles'
       packaging = 'tar.gz'
@@ -247,15 +241,13 @@ module KPM
                                     @nexus_config,
                                     @nexus_ssl_verify)
 
-      @trace_logger.add('default_bundles',
-                        info.merge({'status'=> (info[:skipped] ? 'UP_TO_DATE': 'INSTALLED'),
-                         :group_id => group_id, :artifact_id => artifact_id, :packaging => packaging, :classifier => classifier}))
+      @trace_logger.add('default_bundles', nil,
+                        info.merge('status' => (info[:skipped] ? 'UP_TO_DATE' : 'INSTALLED'),
+                                   :group_id => group_id, :artifact_id => artifact_id, :packaging => packaging, :classifier => classifier))
 
       # The special JRuby bundle needs to be called jruby.jar
       # TODO .first - code smell
-      unless info[:skipped]
-        File.rename Dir.glob("#{destination}/killbill-platform-osgi-bundles-jruby-*.jar").first, destination.join('jruby.jar')
-      end
+      File.rename Dir.glob("#{destination}/killbill-platform-osgi-bundles-jruby-*.jar").first, destination.join('jruby.jar') unless info[:skipped]
 
       info
     end
@@ -263,21 +255,16 @@ module KPM
     private
 
     def validate_installation_arg!(plugin_key, arg_type, specified_arg, looked_up_arg)
-
       # If nothing was specified, or if we don't find anything from the lookup, nothing to validate against
-      if specified_arg.nil? || looked_up_arg.nil?
-        return
-      end
+      return if specified_arg.nil? || looked_up_arg.nil?
 
-      if specified_arg.to_s != looked_up_arg.to_s
-        raise ArgumentError.new "Aborting installation for plugin_key #{plugin_key}: specified value #{specified_arg} for #{arg_type} does not match looked_up value #{looked_up_arg}"
-      end
+      raise ArgumentError, "Aborting installation for plugin_key #{plugin_key}: specified value #{specified_arg} for #{arg_type} does not match looked_up value #{looked_up_arg}" if specified_arg.to_s != looked_up_arg.to_s
     end
 
     def validate_plugin_key!(plugins_dir, plugin_key, coordinate_map)
       plugins_manager = PluginsManager.new(plugins_dir, @logger)
       res = plugins_manager.validate_plugin_identifier_key(plugin_key, coordinate_map)
-      raise ArgumentError.new "Failed to validate plugin key #{plugin_key}" if !res
+      raise ArgumentError, "Failed to validate plugin key #{plugin_key}" unless res
     end
 
     def update_plugin_identifier(plugins_dir, plugin_key, type, coordinate_map, artifact_info)
@@ -289,7 +276,7 @@ module KPM
       plugins_manager.add_plugin_identifier_key(plugin_key, plugin_name, type, coordinate_map)
     end
 
-    def mark_as_active(plugins_dir, artifact_info, artifact_id=nil)
+    def mark_as_active(plugins_dir, artifact_info, _artifact_id = nil)
       # Mark this bundle as active
       plugins_manager = PluginsManager.new(plugins_dir, @logger)
       plugins_manager.set_active(artifact_info[:bundle_dir])
@@ -298,14 +285,14 @@ module KPM
     def warn_if_jruby_jar_missing(bundles_dir)
       platform_dir = bundles_dir.join('platform')
       jruby_jar = platform_dir.join('jruby.jar')
-      if !File.exists?(jruby_jar)
-        @logger.warn("  Missing installation for jruby.jar under #{platform_dir}. This is required for ruby plugin installation");
+      if !File.exist?(jruby_jar)
+        @logger.warn("  Missing installation for jruby.jar under #{platform_dir}. This is required for ruby plugin installation")
       else
         version = extract_jruby_jar_version(jruby_jar)
         if version
           @logger.info("  Detected jruby.jar version #{version}")
         else
-          @logger.warn("  Failed to detect jruby.jar version for #{jruby_jar}");
+          @logger.warn("  Failed to detect jruby.jar version for #{jruby_jar}")
         end
       end
     end
@@ -320,10 +307,9 @@ module KPM
       if selected_entries && selected_entries.size == 1
         zip_entry = selected_entries[0]
         content = zip_entry.get_input_stream.read
-        return content.split("\n").select { |e| e.start_with?("version")}[0].split("=")[1]
+        return content.split("\n").select { |e| e.start_with?('version') }[0].split('=')[1]
       end
       nil
     end
-
   end
 end