kpm 0.7.2 → 0.10.0

data/lib/kpm/formatter.rb

@@ -1,22 +1,18 @@
+# frozen_string_literal: true
+
 # Extend String to be able to instantiate a object based on its classname
 class String
   def to_class
-    self.split('::').inject(Kernel) do |mod, class_name|
+    split('::').inject(Kernel) do |mod, class_name|
       mod.const_get(class_name)
     end
   end
 end
 
 module KPM
-
   class Formatter
-
-    def initialize
-    end
-
     # Used for normal types where to_s is enough
     class DefaultFormatter
-
       def initialize(label, input)
         @label = label
         @input = input
@@ -37,7 +33,6 @@ module KPM
 
     # Used for the version map
     class VersionFormatter
-
       def initialize(label, versions)
         @label = label
         @versions = versions
@@ -48,79 +43,112 @@ module KPM
       end
 
       def to_s
-        @versions.map { |q| sha1=format_sha(q[:sha1]); disabled=""; disabled="(x)" if q[:is_disabled]; default=""; default="(*)" if q[:is_default]; "#{q[:version]}#{sha1}#{default}#{disabled}" }.join(", ")
+        @versions.map do |q|
+          sha1 = format_sha(q[:sha1])
+          disabled = ''
+          disabled = '(x)' if q[:is_disabled]
+          default = ''
+          default = '(*)' if q[:is_default]
+          "#{q[:version]}#{sha1}#{default}#{disabled}"
+        end.join(', ')
       end
 
       def label
         "#{@label.to_s.upcase.gsub(/_/, ' ')} sha1=[], def=(*), del=(x)"
       end
 
+      private
+
       def format_sha(sha)
-        return "[???]" if sha.nil?
+        return '[???]' if sha.nil?
+
         "[#{sha[0..5]}..]"
       end
     end
 
-
     def format(data, labels = nil)
-      if data.nil? || data.size == 0
-        return
-      end
+      puts format_only(data, labels)
+    end
 
-      if labels.nil?
+    private
+
+    def format_only(data, labels = nil)
+      return if data.nil? || data.empty?
 
+      if labels.nil?
         # What we want to output
-        labels = [{:label => :plugin_name},
-                  {:label => :plugin_key},
-                  {:label => :type},
-                  {:label => :group_id},
-                  {:label => :artifact_id},
-                  {:label => :packaging},
-                  {:label => :versions, :formatter => VersionFormatter.name}]
+        labels = [{ label: :plugin_name },
+                  { label: :plugin_key },
+                  { label: :type },
+                  { label: :group_id },
+                  { label: :artifact_id },
+                  { label: :packaging },
+                  { label: :versions, formatter: VersionFormatter.name }]
       end
 
       # Compute label to print along with max size for each label
-      labels_format_argument = []
-      data.keys.each do |key|
+      labels_format_argument = compute_labels(data, labels)
+
+      border = compute_border(labels)
+
+      format_string = compute_format(labels)
+
+      formatted = "\n#{border}\n"
+      formatted += Kernel.format("#{format_string}\n", *labels_format_argument)
+      formatted += "#{border}\n"
+
+      data.each_key do |key|
         v = data[key]
-        labels.each do |e|
-          # sanitize entry at the same time
-          v[e[:label]] = v[e[:label]] || "???"
 
+        arguments = []
+        labels.inject(arguments) do |res, e|
           formatter = e[:formatter].nil? ? DefaultFormatter.new(e[:label], v[e[:label]]) : e[:formatter].to_class.new(e[:label], v[e[:label]])
-          prev_size = e.key?(:size) ? e[:size] : formatter.label.size
-          cur_size = formatter.size
-          e[:size] = prev_size < cur_size ? cur_size : prev_size
-          labels_format_argument << formatter.label
+          res << formatter.to_s
         end
+        formatted += Kernel.format("#{format_string}\n", *arguments)
       end
+      formatted += "#{border}\n\n"
 
+      formatted
+    end
 
+    def compute_format(labels)
+      format = '|'
+      labels.inject(format) { |res, lbl| "#{res} %#{lbl[:size]}s |" }
+    end
 
-      border = "_"
-      border = (0...labels.size).inject(border) { |res, i| res="#{res}_"; res }
-      border = labels.inject(border) { |res, lbl| (0...lbl[:size] + 2).each { |s| res="#{res}_" }; res }
-      format = "|"
-      format = labels.inject(format) { |res, lbl| res="#{res} %#{lbl[:size]}s |"; res }
-
-
+    def compute_border(labels)
+      border = '_'
+      border = (0...labels.size).inject(border) { |res, _i| "#{res}_" }
+      labels.inject(border) do |res, lbl|
+        (0...lbl[:size] + 2).each { |_s| res = "#{res}_" }
+        res
+      end
+    end
 
-      puts "\n#{border}\n"
-      puts "#{format}\n" % labels_format_argument
-      puts "#{border}\n"
+    # Return labels for each row and update the labels hash with the size of each column
+    def compute_labels(data, labels)
+      seen_labels = Set.new
 
-      data.keys.each do |key|
+      labels_format_argument = []
+      data.each_key do |key|
         v = data[key]
+        labels.each do |e|
+          # sanitize entry at the same time
+          v[e[:label]] = v[e[:label]] || '???'
 
-        arguments = []
-        labels.inject(arguments) do |res, e|
+          # Always recompute the size
           formatter = e[:formatter].nil? ? DefaultFormatter.new(e[:label], v[e[:label]]) : e[:formatter].to_class.new(e[:label], v[e[:label]])
-          res << formatter.to_s
+          prev_size = e.key?(:size) ? e[:size] : formatter.label.size
+          cur_size = formatter.size
+          e[:size] = prev_size < cur_size ? cur_size : prev_size
+
+          # Labels should be unique though
+          labels_format_argument << formatter.label unless seen_labels.include?(e[:label])
+          seen_labels << e[:label]
         end
-        puts "#{format}\n" % arguments
       end
-      puts "#{border}\n\n"
-
+      labels_format_argument
     end
   end
 end

data/lib/kpm/inspector.rb

@@ -1,15 +1,14 @@
-module KPM
+# frozen_string_literal: true
 
+module KPM
   class Inspector
-
-    def initialize
-    end
+    def initialize; end
 
     def inspect(bundles_dir)
       bundles_dir = Pathname.new(bundles_dir || KPM::BaseInstaller::DEFAULT_BUNDLES_DIR).expand_path
-      plugins= bundles_dir.join('plugins')
-      ruby_plugins_path=bundles_dir.join('plugins/ruby')
-      java_plugins_path=bundles_dir.join('plugins/java')
+      plugins = bundles_dir.join('plugins')
+      ruby_plugins_path = bundles_dir.join('plugins/ruby')
+      java_plugins_path = bundles_dir.join('plugins/java')
 
       all_plugins = {}
       build_plugins_for_type(ruby_plugins_path, 'ruby', all_plugins)
@@ -27,37 +26,33 @@ module KPM
       formatter.format(all_plugins)
     end
 
-
     private
 
     def add_sha1_info(bundles_dir, all_plugins)
-
       sha1_filename = KPM::BaseInstaller::SHA1_FILENAME
       sha1_file = "#{bundles_dir}/#{sha1_filename}"
       sha1_checker = Sha1Checker.from_file(sha1_file)
 
-      all_plugins.keys.each do |cur_plugin_name|
+      all_plugins.each_key do |cur_plugin_name|
         cur = all_plugins[cur_plugin_name]
 
         sha1_checker.all_sha1.each do |e|
           coord, sha1 = e
           coordinate_map = KPM::Coordinates.get_coordinate_map(coord)
 
-          if coordinate_map[:group_id] == cur[:group_id] &&
-              coordinate_map[:artifact_id] == cur[:artifact_id] &&
-              coordinate_map[:packaging] == cur[:packaging]
-
-            found_version = cur[:versions].select { |v| v[:version] == coordinate_map[:version] }[0]
-            found_version[:sha1] = sha1 if found_version
-          end
+          next unless coordinate_map[:group_id] == cur[:group_id] &&
+                      coordinate_map[:artifact_id] == cur[:artifact_id] &&
+                      coordinate_map[:packaging] == cur[:packaging]
 
+          found_version = cur[:versions].select { |v| v[:version] == coordinate_map[:version] }[0]
+          found_version[:sha1] = sha1 if found_version
         end
       end
     end
 
     def add_plugin_identifier_info(plugins, all_plugins)
       plugins_manager = PluginsManager.new(plugins, @logger)
-      all_plugins.keys.each do |cur|
+      all_plugins.each_key do |cur|
         plugin_key, entry = plugins_manager.get_identifier_key_and_entry(cur)
         all_plugins[cur][:plugin_key] = plugin_key
         all_plugins[cur][:group_id] = entry ? entry['group_id'] : nil
@@ -67,31 +62,27 @@ module KPM
       end
     end
 
-
     def build_plugins_for_type(plugins_path, type, res)
-      if !File.exists?(plugins_path)
-        return []
-      end
-      get_entries(plugins_path).inject(res) do |out, e|
+      return [] unless File.exist?(plugins_path)
+
+      get_entries(plugins_path).each_with_object(res) do |e, out|
         plugin_map = build_plugin_map(e, plugins_path.join(e), type)
         out[e] = plugin_map
-        out
       end
     end
 
     def build_plugin_map(plugin_name, plugin_path, type)
-
-      plugin_map = {:plugin_name => plugin_name, :plugin_path => plugin_path.to_s, :type => type}
+      plugin_map = { plugin_name: plugin_name, plugin_path: plugin_path.to_s, type: type }
       entries = get_entries(plugin_path)
-      set_default = entries.select { |e| e == "SET_DEFAULT" }[0]
+      set_default = entries.select { |e| e == 'SET_DEFAULT' }[0]
       default_version = File.basename(File.readlink(plugin_path.join(set_default))) if set_default
 
-      versions = entries.select do |e|
-        e != "SET_DEFAULT"
-      end.inject([]) do |out, e|
-        is_disabled = File.exists?(plugin_path.join(e).join('tmp').join('disabled.txt'))
-        out << {:version => e, :is_default => default_version == e, :is_disabled => is_disabled, :sha1 => nil};
-        out
+      non_default = entries.reject do |e|
+        e == 'SET_DEFAULT'
+      end
+      versions = non_default.each_with_object([]) do |e, out|
+        is_disabled = File.exist?(plugin_path.join(e).join('tmp').join('disabled.txt'))
+        out << { version: e, is_default: default_version == e, is_disabled: is_disabled, sha1: nil }
       end
 
       versions.sort! { |a, b| a[:version] <=> b[:version] }
@@ -103,6 +94,5 @@ module KPM
     def get_entries(path)
       Dir.entries(path).select { |entry| entry != '.' && entry != '..' && File.directory?(File.join(path, entry)) }
     end
-
   end
 end

data/lib/kpm/installer.rb

@@ -1,40 +1,36 @@
+# frozen_string_literal: true
+
 require 'logger'
 require 'pathname'
 require 'yaml'
 
 module KPM
   class Installer < BaseInstaller
-
-    def self.from_file(config_path=nil, logger=nil)
-      if config_path.nil?
-        # Install Kill Bill, Kaui and the KPM plugin by default
-        config = build_default_config
-      else
-        config = YAML::load_file(config_path)
-      end
+    def self.from_file(config_path = nil, logger = nil)
+      config = if config_path.nil?
+                 # Install Kill Bill, Kaui and the KPM plugin by default
+                 build_default_config
+               else
+                 YAML.load_file(config_path)
+               end
       Installer.new(config, logger)
     end
 
-    def self.build_default_config(all_kb_versions=nil)
+    def self.build_default_config(all_kb_versions = nil)
       latest_stable_version = get_kb_latest_stable_version(all_kb_versions)
 
       {
-          'killbill' => {
-              'version' => latest_stable_version.to_s,
-              'plugins' => {
-                  'ruby' => [
-                      {'name' => 'kpm'}
-                  ]
-              }
-          },
-          'kaui' => {
-              # Note: we assume no unstable version of Kaui is published today
-              'version' => 'LATEST'
-          }
+        'killbill' => {
+          'version' => latest_stable_version.to_s
+        },
+        'kaui' => {
+          # Note: we assume no unstable version of Kaui is published today
+          'version' => 'LATEST'
+        }
       }
     end
 
-    def self.get_kb_latest_stable_version(all_kb_versions=nil)
+    def self.get_kb_latest_stable_version(all_kb_versions = nil)
       all_kb_versions ||= KillbillServerArtifact.versions(KillbillServerArtifact::KILLBILL_ARTIFACT_ID,
                                                           KillbillServerArtifact::KILLBILL_PACKAGING,
                                                           KillbillServerArtifact::KILLBILL_CLASSIFIER,
@@ -42,10 +38,14 @@ module KPM
                                                           true).to_a
       latest_stable_version = Gem::Version.new('0.0.0')
       all_kb_versions.each do |kb_version|
-        version = Gem::Version.new(kb_version) rescue nil
+        version = begin
+                    Gem::Version.new(kb_version)
+                  rescue StandardError
+                    nil
+                  end
         next if version.nil?
 
-        major, minor, patch, pre = version.segments
+        _major, minor, _patch, pre = version.segments
         next if !pre.nil? || minor.nil? || minor.to_i.odd?
 
         latest_stable_version = version if version > latest_stable_version
@@ -54,7 +54,7 @@ module KPM
       latest_stable_version.to_s
     end
 
-    def initialize(raw_config, logger=nil)
+    def initialize(raw_config, logger = nil)
       @config = raw_config['killbill']
       @kaui_config = raw_config['kaui']
 
@@ -65,14 +65,26 @@ module KPM
         logger.level = Logger::INFO
       end
 
-      nexus_config = !@config.nil? ? @config['nexus'] : (!@kaui_config.nil? ? @kaui_config['nexus'] : nil)
+      nexus_config = if !@config.nil?
+                       @config['nexus']
+                     elsif !@kaui_config.nil?
+                       @kaui_config['nexus']
+                     else
+                       nil
+                     end
       nexus_ssl_verify = !nexus_config.nil? ? nexus_config['ssl_verify'] : true
 
       super(logger, nexus_config, nexus_ssl_verify)
     end
 
-    def install(force_download=false, verify_sha1=true)
-      bundles_dir = !@config.nil? ? @config['plugins_dir'] : (!@kaui_config.nil? ? @kaui_config['plugins_dir'] : nil)
+    def install(force_download = false, verify_sha1 = true)
+      bundles_dir = if !@config.nil?
+                      @config['plugins_dir']
+                    elsif !@kaui_config.nil?
+                      @kaui_config['plugins_dir']
+                    else
+                      nil
+                    end
       bundles_dir ||= DEFAULT_BUNDLES_DIR
 
       help = nil
@@ -80,9 +92,7 @@ module KPM
         help = install_tomcat if @config['webapp_path'].nil?
         install_killbill_server(@config['group_id'], @config['artifact_id'], @config['packaging'], @config['classifier'], @config['version'], @config['webapp_path'], bundles_dir, force_download, verify_sha1)
         install_plugins(bundles_dir, @config['version'], force_download, verify_sha1)
-        unless @config['default_bundles'] == false
-          install_default_bundles(bundles_dir, @config['default_bundles_version'], @config['version'], force_download, verify_sha1)
-        end
+        install_default_bundles(bundles_dir, @config['default_bundles_version'], @config['version'], force_download, verify_sha1) unless @config['default_bundles'] == false
         clean_up_descriptors(bundles_dir)
       end
 
@@ -95,13 +105,13 @@ module KPM
         install_kaui(@kaui_config['group_id'], @kaui_config['artifact_id'], @kaui_config['packaging'], @kaui_config['classifier'], @kaui_config['version'], @kaui_config['webapp_path'], bundles_dir, force_download, verify_sha1)
       end
 
-      @trace_logger.add('help',help)
+      @trace_logger.add('help', nil, help)
       @trace_logger.to_json
     end
 
     private
 
-    def install_tomcat(dir=Dir.pwd)
+    def install_tomcat(dir = Dir.pwd)
       # Download and unpack Tomcat
       manager = KPM::TomcatManager.new(dir, @logger)
       manager.download
@@ -109,9 +119,7 @@ module KPM
       # Update main config
       root_war_path = manager.setup
       @config['webapp_path'] = root_war_path
-      unless @kaui_config.nil?
-        @kaui_config['webapp_path'] = Pathname.new(File.dirname(root_war_path)).join('kaui.war').to_s
-      end
+      @kaui_config['webapp_path'] = Pathname.new(File.dirname(root_war_path)).join('kaui.war').to_s unless @kaui_config.nil?
 
       # Help message
       manager.help
@@ -123,7 +131,7 @@ module KPM
     end
 
     def install_java_plugins(bundles_dir, raw_kb_version, force_download, verify_sha1)
-      return if @config['plugins'].nil? or @config['plugins']['java'].nil?
+      return if @config['plugins'].nil? || @config['plugins']['java'].nil?
 
       infos = []
       @config['plugins']['java'].each do |plugin|
@@ -134,13 +142,13 @@ module KPM
     end
 
     def install_ruby_plugins(bundles_dir, raw_kb_version, force_download, verify_sha1)
-      return if @config['plugins'].nil? or @config['plugins']['ruby'].nil?
+      return if @config['plugins'].nil? || @config['plugins']['ruby'].nil?
 
-      verify_jruby_jar=true
+      verify_jruby_jar = true
       infos = []
       @config['plugins']['ruby'].each do |plugin|
         infos << install_plugin(plugin['name'], raw_kb_version, plugin['group_id'], plugin['artifact_id'], plugin['packaging'], plugin['classifier'], plugin['version'], bundles_dir, 'ruby', force_download, verify_sha1, verify_jruby_jar)
-        verify_jruby_jar=false
+        verify_jruby_jar = false
       end
 
       infos
@@ -161,11 +169,11 @@ module KPM
       plugin_identifiers = plugins_manager.read_plugin_identifiers
       removed_identifiers = []
       plugin_identifiers.each do |plugin_key, plugin|
-        if !installed_plugins.has_key?(plugin['plugin_name'])
-          _, plugin_entry = plugins_manager.get_identifier_key_and_entry(plugin_key)
-          plugins_manager.remove_plugin_identifier_key(plugin_key)
-          removed_identifiers << plugin_entry
-        end
+        next if installed_plugins.key?(plugin['plugin_name'])
+
+        _, plugin_entry = plugins_manager.get_identifier_key_and_entry(plugin_key)
+        plugins_manager.remove_plugin_identifier_key(plugin_key)
+        removed_identifiers << plugin_entry
       end
 
       removed_identifiers
@@ -182,6 +190,5 @@ module KPM
         sha1checker.remove_entry!(coordinates)
       end
     end
-
   end
 end