mvn2 2.0.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c72be85209bb1530015bcd6b2eb25e2d426e25c0
-  data.tar.gz: 7c07e923c4bdb1ad8bf1e45bd5335045e47189e7
+  metadata.gz: bbe17e1824645491f53d325e16cbc27fd78fb92e
+  data.tar.gz: b80978a9c66ff6b807a0d0cfbc352a9b49cc1057
 SHA512:
-  metadata.gz: 4ef22f5679a9697663580798ca40473aa527a44380c57d497646fbd767c229d3640aecf124c75fa6c6836dc3c8fd8a931e83eb55101eb281af0efe9a2fee7747
-  data.tar.gz: f360db16d6a98677ca1822642c358339859d5373d34aac49d6c3b0b4d0dc94a70bd0ecfb783c56ab5c7fdaadb070bff3ba4344d7faee4a665ac0f5d2b7aa7c26
+  metadata.gz: ac64c92c0b0fdde3ef7f241594065286d9f7e0949e94cf3f442407541d91cad908ee83e484612defaa91abf1220f33f8e763f6a8e301c0e1774390510b9511cc
+  data.tar.gz: d2aefc76312bb99b7346327d6f189914ab3dba2a6271574d1dc0aa935e50d6c4aef330904877d549fc9b6201795682f61d97c96c3d6fd506c6419537859e4369

data/bin/mvn2

@@ -36,8 +36,8 @@ class MyOptions
   help_option ['--help'], desc: 'print out this help'
 end
 
-Mvn2::Plugins.get(:option, MyOptions)
-Mvn2::Plugins.get(:option_with_param, MyOptions)
+Mvn2::Plugins.get :option, MyOptions
+Mvn2::Plugins.get :option_with_param, MyOptions
 
 MyOptions.parse!
 

data/lib/mvn2/plugin/avg.plugin.rb

@@ -2,6 +2,7 @@ require 'mvn2/plugin'
 class AvgPlugin
   extend Mvn2::Plugin
   extend Mvn2::PluginType
+  extend Mvn2::TypeHelper
 
   register_variable :average
   register_variable :averages2
@@ -17,9 +18,7 @@ class AvgPlugin
   register_type(:block_average) { |list| basic_type(list) }
 
   register_type(:block_update) { |list|
-    result  = Mvn2::Plugins.get_var :result
-    average = Mvn2::Plugins.get_var :average
-    diff    = Mvn2::Plugins.get_var :diff
+    result, average, diff = Mvn2::Plugins.get_vars :result, :average, :diff
     basic_type(list, result, average, diff)
   }
 
@@ -90,10 +89,9 @@ class AvgPlugin
   end
 
   def self.read_advanced_avg
-    options   = Mvn2::Plugins.get_var :options
-    average   = Mvn2::Plugins.get_var :average
-    averages  = [average]
-    file_name = full_avg_file
+    options, average = Mvn2::Plugins.get_vars :options, :average
+    averages         = [average]
+    file_name        = full_avg_file
     if !Mvn2::Plugins.get(:block_full_average) && options[:advanced_average] && File.exist?(file_name)
       lines    = IO.readlines(file_name)
       data     = lines.filtermap { |line| float_filter(line) }
@@ -134,24 +132,18 @@ class AvgPlugin
       pkg     = options[:package] ? 2 : 0
       average = averages[(options[:skip_tests] ? 0 : 1) + pkg]
     end
-    Mvn2::Plugins.set_var :average, average
-    Mvn2::Plugins.set_var :averages2, averages
-    Mvn2::Plugins.set_var :counts, counts
+    Mvn2::Plugins.set_vars average: average, averages2: averages, counts: counts
   end
 
   def self.calc_new_avg(ind)
-    averages2      = Mvn2::Plugins.get_var :averages2
-    counts         = Mvn2::Plugins.get_var :counts
-    diff           = Mvn2::Plugins.get_var :diff
-    sum            = averages2[ind] * counts[ind] + diff
-    counts[ind]    += 1
-    averages2[ind] = sum / counts[ind]
+    averages2, counts, diff = Mvn2::Plugins.get_vars :averages2, :counts, :diff
+    sum                     = averages2[ind] * counts[ind] + diff
+    counts[ind]             += 1
+    averages2[ind]          = sum / counts[ind]
   end
 
   def self.update_avg
-    options   = Mvn2::Plugins.get_var :options
-    averages2 = Mvn2::Plugins.get_var :averages2
-    counts    = Mvn2::Plugins.get_var :counts
+    options, averages2, counts = Mvn2::Plugins.get_vars :options, :averages2, :counts
     if !Mvn2::Plugins.get(:block_average) && !Mvn2::Plugins.get(:block_update)
       options[:skip_tests] ? calc_new_avg(0) : calc_new_avg(1)
       IO.write('avg.txt', "#{averages2[0]};#{counts[0]}\n#{averages2[1]};#{counts[1]}\n#{averages2[2]};#{counts[2]}\n#{averages2[3]};#{counts[3]}")

data/lib/mvn2/plugin/filter.plugin.rb

@@ -26,8 +26,7 @@ class FilterPlugin
       str = ''
       str << INFO_LINE << "\n" unless info_line_last
       str << line << "\n"
-      Mvn2::Plugins.set_var :found, true
-      Mvn2::Plugins.set_var :info_line_last, false
+      Mvn2::Plugins.set_vars found: true, info_line_last: false
       str
     else
       nil
@@ -37,8 +36,7 @@ class FilterPlugin
   register(:line_filter, priority: 20) { |_, line|
     if line.start_with_any?('[ERROR] COMPILATION ERROR :', 'Results :')
       str = line << "\n"
-      Mvn2::Plugins.set_var :found, true
-      Mvn2::Plugins.set_var :info_line_last, false
+      Mvn2::Plugins.set_vars found: true, info_line_last: false
       str
     else
       nil
@@ -49,8 +47,7 @@ class FilterPlugin
     found = Mvn2::Plugins.get_var :found
     if found
       str = line << "\n"
-      Mvn2::Plugins.set_var :found, true
-      Mvn2::Plugins.set_var :info_line_last, line.start_with?(INFO_LINE)
+      Mvn2::Plugins.set_vars found: true, info_line_last: line.start_with?(INFO_LINE)
       str
     else
       nil
@@ -61,8 +58,7 @@ class FilterPlugin
     found = Mvn2::Plugins.get_var :found
     if options[:hide_between] && found && line.start_with?('Tests run:')
       str = line << "\n\n"
-      Mvn2::Plugins.set_var :found, false
-      Mvn2::Plugins.set_var :info_line_last, false
+      Mvn2::Plugins.set_vars found: false, info_line_last: false
       str
     else
       nil

data/lib/mvn2/plugin.rb

@@ -43,17 +43,33 @@ module Mvn2
       @vars[name] || nil
     end
 
+    def get_vars(*names)
+      names.map { |name| get_var(name) }
+    end
+
     def set_var(name, value)
       @vars[name] = value
     end
 
+    def set_vars(vars = {})
+      vars.each { |v| set_var(*v) }
+    end
+
     def self.get_var(name)
       instance.get_var(name)
     end
 
+    def self.get_vars(*names)
+      instance.get_vars(*names)
+    end
+
     def self.set_var(name, value)
       instance.set_var(name, value)
     end
+
+    def self.set_vars(vars = {})
+      instance.set_vars(vars)
+    end
   end
   module Plugin
     def register(type, options = {}, &block)
@@ -68,20 +84,51 @@ module Mvn2
     def register_variable(name, value = nil)
       Mvn2::Plugins.instance.register_variable(name, value)
     end
-
+  end
+  module TypeHelper
     def basic_type(list, *args)
       options = Mvn2::Plugins.get_var :options
       list.any? { |item|
         if item[:block].nil?
-          item[:options].has_key?(:option) && options[item[:options][:option]] == (item[:options].has_key?(:value) ? item[:options][:value] : true)
+          flag_boolean(item, options)
         else
           item[:block].call(options, *args)
         end
       }
     end
+
+    def flag_boolean(item, options)
+      item[:options].has_key?(:option) && options[item[:options][:option]] == (item[:options].has_key?(:value) ? item[:options][:value] : true)
+    end
+
+    def complex_filter(list, options, symbol)
+      list.filtermap { |item|
+        if item[:block].nil?
+          if item[:options].has_key?(symbol) && flag_boolean(item, options)
+            item[:options][symbol]
+          else
+            item[:options].has_key?(:option) && !options[item[:options][:option]].nil? ? options[item[:options][:option]] : false
+          end
+        else
+          rval = item[:block].call(options)
+          (rval.nil? || !rval) ? false : rval
+        end
+      }
+    end
+
+    def simple_type(list, *args)
+      options = Mvn2::Plugins.get_var :options
+      list.sort_by { |v| v[:options][:order] }.each { |item| item[:block].call(options, *args) }
+    end
+
+    def simple_type_with_result(list)
+      result = Mvn2::Plugins.get_var :result
+      simple_type(list, result)
+    end
   end
   class DefaultTypes
     extend Mvn2::PluginType
+    extend Mvn2::TypeHelper
 
     register_variable :options
     register_variable :result
@@ -100,16 +147,19 @@ module Mvn2
       }
     end
 
-    register_type(:option) { |list, options| register_option(list, options) { |id, names, option| options.option id, names, option[:options] } }
+    def self.def_options
+      register_type(:option) { |list, options| register_option(list, options) { |id, names, option| options.option id, names, option[:options] } }
+      register_type(:option_with_param) { |list, options| register_option(list, options) { |id, names, option| options.option_with_param id, names, option[:options] } }
+    end
 
-    register_type(:option_with_param) { |list, options| register_option(list, options) { |id, names, option| options.option_with_param id, names, option[:options] } }
+    def_options
 
     register_type(:command_flag) { |list|
       options = Mvn2::Plugins.get_var :options
       flags   = []
       list.each { |flag|
         if flag[:block].nil?
-          flags << " #{flag[:options][:flag]}" if flag[:options].has_key?(:option) && options[flag[:options][:option]] == (flag[:options].has_key?(:value) ? flag[:options][:value] : true)
+          flags << " #{flag[:options][:flag]}" if flag_boolean(flag, options)
         else
           flag[:block].call(options, flags)
         end
@@ -117,64 +167,32 @@ module Mvn2
       flags.join
     }
 
-    register_type(:before_run) { |list|
-      options = Mvn2::Plugins.get_var :options
-      list.sort_by { |v| v[:options][:order] }.each { |item| item[:block].call(options) }
-    }
-
-    register_type(:after_run) { |list|
-      options = Mvn2::Plugins.get_var :options
-      result  = Mvn2::Plugins.get_var :result
-      list.sort_by { |v| v[:options][:order] }.each { |item| item[:block].call(options, result) }
-    }
-
-    register_type(:before_start) { |list|
-      options = Mvn2::Plugins.get_var :options
-      list.sort_by { |v| v[:options][:order] }.each { |item| item[:block].call(options) }
-    }
-
-    register_type(:after_end) { |list|
-      options = Mvn2::Plugins.get_var :options
-      result  = Mvn2::Plugins.get_var :result
-      list.sort_by { |v| v[:options][:order] }.each { |item| item[:block].call(options, result) }
-    }
+    def self.def_actions
+      register_type(:before_run) { |list| simple_type(list) }
+      register_type(:after_run) { |list| simple_type_with_result(list) }
+      register_type(:before_start) { |list| simple_type(list) }
+      register_type(:after_end) { |list| simple_type_with_result(list) }
+      register_type(:notification) { |list|
+        options, result, cmd_clean, message_text = Mvn2::Plugins.get_vars :options, :result, :cmd_clean, :message_text
+        list.sort_by { |v| v[:options][:order] }.each { |item| item[:block].call(options, result, cmd_clean, message_text) }
+      }
+    end
 
-    register_type(:notification) { |list|
-      options      = Mvn2::Plugins.get_var :options
-      result       = Mvn2::Plugins.get_var :result
-      cmd_clean    = Mvn2::Plugins.get_var :cmd_clean
-      message_text = Mvn2::Plugins.get_var :message_text
-      list.sort_by { |v| v[:options][:order] }.each { |item| item[:block].call(options, result, cmd_clean, message_text) }
-    }
+    def_actions
 
-    register_type(:log_file_name) { |list|
+    def self.get_name(list)
       options = Mvn2::Plugins.get_var :options
-      name    = nil
-      list.sort_by { |v| -v[:options][:priority] }.each { |item|
-        if item[:block].nil?
-          if item[:options].has_key?(:name) && item[:options].has_key?(:option) && options[item[:options][:option]] == (item[:options].has_key?(:value) ? item[:options][:value] : true)
-            name = item[:options][:name]
-            break
-          elsif item[:options].has_key?(:option) && !options[item[:options][:option]].nil?
-            name = options[item[:options][:option]]
-            break
-          end
-        else
-          rval = item[:block].call(options)
-          unless rval.nil?
-            name = rval
-            break
-          end
-        end
-      }
-      name
-    }
+      rval    = complex_filter(list.sort_by { |v| -v[:options][:priority] }, options, :name)
+      (rval.nil? || rval.empty?) ? false : rval.first
+    end
 
-    register_type(:log_file_disable) { |list| basic_type(list) }
+    def self.def_logs
+      register_type(:log_file_name) { |list| get_name(list) }
+      register_type(:log_file_disable) { |list| basic_type(list) }
+      register_type(:log_file_enable) { |list| (Mvn2::Plugins.get(:log_file_name).nil? || Mvn2::Plugins.get(:log_file_disable)) ? false : basic_type(list) }
+    end
 
-    register_type(:log_file_enable) { |list|
-      (Mvn2::Plugins.get(:log_file_name).nil? || Mvn2::Plugins.get(:log_file_disable)) ? false : basic_type(list)
-    }
+    def_logs
 
     register_type(:line_filter) { |list, line|
       options = Mvn2::Plugins.get_var :options
@@ -197,8 +215,7 @@ module Mvn2
     register_type(:runner_enable) { |list, key| basic_type(list.select { |v| v[:options][:key] == key }) }
 
     register_type(:runner) { |list|
-      options = Mvn2::Plugins.get_var :options
-      cmd     = Mvn2::Plugins.get_var :cmd
+      options, cmd = Mvn2::Plugins.get_vars :options, :cmd
       Mvn2::Plugins.set_var :result, false
       list.sort_by { |v| -v[:options][:priority] }.each { |item|
         if Mvn2::Plugins.get(:runner_enable, item[:options][:key])
@@ -210,24 +227,11 @@ module Mvn2
       Mvn2::Plugins.get_var :result
     }
 
-    def self.goal_filter(item, options)
-      if item[:block].nil?
-        if item[:options].has_key?(:goal) && item[:options].has_key?(:option) && options[item[:options][:option]] == (item[:options].has_key?(:value) ? item[:options][:value] : true)
-          item[:options][:goal]
-        else
-          item[:options].has_key?(:option) && !options[item[:options][:option]].nil? ? options[item[:options][:option]] : false
-        end
-      else
-        rval = item[:block].call(options)
-        (rval.nil? || !rval) ? false : rval
-      end
-    end
-
     register_type(:goal_override) { |list|
       options        = Mvn2::Plugins.get_var :options
-      full_overrides = list.select { |v| v[:options][:override_all] }.sort_by { |v| -v[:options][:priority] }.filtermap { |item| goal_filter(item, options) }
+      full_overrides = complex_filter(list.select { |v| v[:options][:override_all] }.sort_by { |v| -v[:options][:priority] }, options, :goal)
       if full_overrides.nil? || full_overrides.empty?
-        goals = list.select { |v| !v[:options][:override_all] }.sort_by { |v| v[:options][:order] }.filtermap { |item| goal_filter(item, options) }
+        goals = complex_filter(list.select { |v| !v[:options][:override_all] }.sort_by { |v| v[:options][:order] }, options, :goal)
         goals = ['install'] if (goals - ['clean']).empty?
         goals = ['clean'] + goals unless goals.include?('clean')
         goals.join(' ')
@@ -236,28 +240,7 @@ module Mvn2
       end
     }
 
-    register_type(:operation_name) { |list|
-      options = Mvn2::Plugins.get_var :options
-      name    = false
-      list.sort_by { |v| -v[:options][:priority] }.each { |item|
-        if item[:block].nil?
-          if item[:options].has_key?(:name) && item[:options].has_key?(:option) && options[item[:options][:option]] == (item[:options].has_key?(:value) ? item[:options][:value] : true)
-            name = item[:options][:name]
-            break
-          elsif item[:options].has_key?(:option) && !options[item[:options][:option]].nil?
-            name = options[item[:options][:option]]
-            break
-          end
-        else
-          rval = item[:block].call(options)
-          unless rval.nil? || !rval
-            name = rval
-            break
-          end
-        end
-      }
-      name || 'Operation'
-    }
+    register_type(:operation_name) { |list| get_name(list) || 'Operation' }
 
     DEFAULT_COLOR_OPTS = {
         time:    {

data/lib/mvn2/version.rb

@@ -1,3 +1,3 @@
 module Mvn2
-  VERSION = '2.0.2'
+  VERSION = '2.1.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mvn2
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.1.0
 platform: ruby
 authors:
 - Eric Henderson