mvn2 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bbe17e1824645491f53d325e16cbc27fd78fb92e
-  data.tar.gz: b80978a9c66ff6b807a0d0cfbc352a9b49cc1057
+  metadata.gz: b39f2e1b31e73e8e0e46b2933b0a99a61a894f15
+  data.tar.gz: 8910e23d49347ba7beb82506f0e3fa34ebbecee9
 SHA512:
-  metadata.gz: ac64c92c0b0fdde3ef7f241594065286d9f7e0949e94cf3f442407541d91cad908ee83e484612defaa91abf1220f33f8e763f6a8e301c0e1774390510b9511cc
-  data.tar.gz: d2aefc76312bb99b7346327d6f189914ab3dba2a6271574d1dc0aa935e50d6c4aef330904877d549fc9b6201795682f61d97c96c3d6fd506c6419537859e4369
+  metadata.gz: 9f6c81c323f67a021138a7fcd5a655d6c660331942cedb07981aebc85b4c2a96f33325c21912e1f530a8d5f27374e94bab229c0a48acdfe378a3f77769b2477f
+  data.tar.gz: bd83204629ee2518a77280f9e01567e1235ad3fb4f6cad43ada9aebc3b6e22e3508d8f81fdb5d8e0591ae9d8f963ce89c0e63d38a7ae615526542089adaf1ba0

data/README.md

@@ -12,7 +12,7 @@ Install it yourself as:
 
 Version 2.0.0 introduces a plugin system.  Other gems can add plugins to mvn2.  The files have to match the pattern `mvn2/plugin/*.plugin.rb` in your gem's `lib/` folder.  If you do that, when the gem is installed, `mvn2` will automatically pick up on it and load it.
 
-Please see the plugin folder in this gem for examples of how to use the plugin system.  I might add an explanation here later, but for now, you'll just have to figure it out.  My `colorconfig` gem also has a plugin for `mvn2`
+Please see the plugin folder in this gem for examples of how to use the plugin system.  My `colorconfig` and `mvn2-say` gems also have plugins for `mvn2`
 
 ###optional parameters:
 * `-t` or `--timer` to display a timer while the build is in progress (default is display nothing)
@@ -41,4 +41,85 @@ Please see the plugin folder in this gem for examples of how to use the plugin s
 * `-1` or `--set-defaults` to set the defaults so you can just run `mvn2` without any parameters
 
 ###displays:
-a Growl notification indicating success or failure
+a Growl notification indicating success or failure
+
+##Plugin System
+
+The following is my initial documentation of the plugin system.  It may be improved as I have time.
+
+-----
+
+Version 2.0.0 introduces a plugin system.  Other gems can add plugins to mvn2.  The files have to match the pattern `mvn2/plugin/*.plugin.rb` in your gem's `lib/` folder.  If you do that, when the gem is installed, `mvn2` will automatically pick up on it and load it.
+
+Two examples of this are my gems `colorconfig` and `mvn2-say`.
+
+The `Mvn2::Plugin` module is used for registering a plugin of a defined type.  It defines the `register` method.  You should use `extend` so that you can define things statically.  There is no need for a `build` method because it automatically adds the plugins at the time you call the method.
+
+Here is an example:
+
+```ruby
+register :option, sym: :timer, names: %w(-t --timer), desc: 'display a timer while the build is in progress'
+```
+
+And another:
+
+```ruby
+register(:before_run, order: 2) { |options|
+  Mvn2::Plugins.set_var :time1, Time.now
+  Mvn2::Plugins.set_var :thread, options[:timer] ? Thread.new {
+    start_time = Mvn2::Plugins.get_var :time1
+    while true
+      print "\r#{get_timer_message(start_time, Time.now)}"
+      sleep(0.05)
+    end
+  } : nil
+}
+```
+
+The `register` method takes a first parameter of the plugin type identifier, followed by an optional (but probably necessary) hash of options, and an optional block (usable with most built-in plugin types, required by some).
+
+-----
+
+If you want to define a new plugin type, you can extend the `Mvn2::PluginType`.  This defines the `register_type` and `register_variable` methods.  Technically, you don't really need to register a variable, but if you want to give it a certain starting value, you will need to register it and pass over the value.  `register_type` takes a first parameter of the plugin type identifier, followed by a block.  The block will always take a first parameter of the list of instances, followed by any additional parameters passed to the plugin when it is called.  The block has the task of taking the list of plugin instances and turning it into whatever result the plugin is supposed to have.
+
+Here is an example:
+
+```ruby
+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)
+    else
+      flag[:block].call(options, flags)
+    end
+  }
+  flags.join
+}
+```
+
+-----
+
+You might notice in the second plugin example, as well as the plugin type example, methods are called on `Mvn2::Plugins`.  This is the class that stores all of the plugins and types.  It has various methods, but the ones involved in making a plugin are:
+
+* `Mvn2::Plugins.get(type, *args)`
+    * Gets the result of a plugin type.  The first parameter is the plugin type identifier, followed by any additional arguments the plugin type takes.
+* `Mvn2::Plugins.get_var(name)`
+    * Gets a single variable by name
+* `Mvn2::Plugins.get_vars(*names)`
+    * Gets a list of variables by name.  Useful for getting a lot of variables in one line.
+* `Mvn2::Plugins.set_var(name, value)`
+    * Sets a single variable of the given name to the given value.
+* `Mvn2::Plugins.set_vars(vars = {})`
+    * Sets a list of variables to the values specified.  It use a hash format, so you can do something like `Mvn2::Plugins.set_vars found: true, info_line_last: false`
+
+If you come up with a plugin, feel free to publish it on your own (that's what the plugin system is designed to support).  If you think it should be part of the built-in plugin set, you can always file a pull request.
+
+## Contributing
+
+1. Fork it ( http://github.com/henderea/mvn2/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/bin/mvn2

@@ -8,23 +8,14 @@ require 'everyday-cli-utils'
 include EverydayCliUtils
 import :maputil, :format, :kmeans, :option
 require 'mvn2/plugin'
-begin
-  Gem.find_latest_files('/mvn2/plugin/*.plugin.rb').each { |plugin|
-    #noinspection RubyResolve
-    begin
-      require plugin
-    rescue LoadError => e
-      puts "Error in loading plugin '#{plugin}'"
-      puts e.inspect
-    end
-  }
-rescue Exception => e
-  puts 'Error in loading plugins'
-  puts e.inspect
-end
+require 'everyday-plugins'
+
+include EverydayPlugins
+
+Plugins.load_plugins 'mvn2'
 
-#abcd   h jkl n p  stuvw   012
-#    efg i   m o qr     xyz   3456789
+#abcd   h jkl n p  stuvw y 012
+#    efg i   m o qr     x z   3456789
 
 class MyOptions
   extend OptionUtil
@@ -36,14 +27,14 @@ class MyOptions
   help_option ['--help'], desc: 'print out this help'
 end
 
-Mvn2::Plugins.get :option, MyOptions
-Mvn2::Plugins.get :option_with_param, MyOptions
+Plugins.get :option, MyOptions
+Plugins.get :option_with_param, MyOptions
 
 MyOptions.parse!
 
 options = MyOptions.options
 
-Mvn2::Plugins.set_var(:options, options)
+Plugins.set_var(:options, options)
 
 Signal.trap('SIGINT') {
   puts "\nBuild Canceled\n\n"
@@ -56,7 +47,7 @@ class String
   end
 end
 
-Mvn2::Plugins.get :color_override
+Plugins.get :color_override
 
 class Mvn2Runner
   HEADLESS    = ' -Djava.awt.headless=true'
@@ -66,32 +57,32 @@ class Mvn2Runner
   def initialize(options)
     @options = options
     setup_cmd
-    Mvn2::Plugins.set_var :cmd, @cmd
-    Mvn2::Plugins.set_var :cmd_clean, @cmd_clean
+    Plugins.set_var :cmd, @cmd
+    Plugins.set_var :cmd_clean, @cmd_clean
   end
 
   def setup_cmd
-    flags      = Mvn2::Plugins.get :command_flag
-    goals      = Mvn2::Plugins.get :goal_override
+    flags      = Plugins.get :command_flag
+    goals      = Plugins.get :goal_override
     @cmd       = "mvn #{goals}#{flags}#{HEADLESS} 2>&1"
     @cmd_clean = @cmd[0...(-5-HEADLESS.length)]
   end
 
   def run_and_filter_output
-    Mvn2::Plugins.get :before_run
-    @result = Mvn2::Plugins.get :runner
-    Mvn2::Plugins.get :after_run
+    Plugins.get :before_run
+    @result = Plugins.get :runner
+    Plugins.get :after_run
   end
 
   def run
-    Mvn2::Plugins.get :before_start
+    Plugins.get :before_start
     run_and_filter_output
-    Mvn2::Plugins.get :after_end
+    Plugins.get :after_end
 
-    operation_name = Mvn2::Plugins.get :operation_name
-    Mvn2::Plugins.set_var :message_text, "#{operation_name} #{(@result ? 'Successful' : 'Failed')}"
+    operation_name = Plugins.get :operation_name
+    Plugins.set_var :message_text, "#{operation_name} #{(@result ? 'Successful' : 'Failed')}"
 
-    Mvn2::Plugins.get :notification
+    Plugins.get :notification
   end
 end
 

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

@@ -1,70 +1,85 @@
 require 'mvn2/plugin'
+require 'everyday-plugins'
+include EverydayPlugins
 class AvgPlugin
-  extend Mvn2::Plugin
-  extend Mvn2::PluginType
+  extend Plugin
+  extend PluginType
   extend Mvn2::TypeHelper
 
-  register_variable :average
-  register_variable :averages2
-  register_variable :counts
-
-  register_type(:full_avg_name) { |list|
-    options = Mvn2::Plugins.get_var :options
-    pieces  = []
-    list.sort_by { |v| v[:options][:order] }.each { |name| pieces << name[:block].call(options) }
-    pieces.join
-  }
-
-  register_type(:block_average) { |list| basic_type(list) }
-
-  register_type(:block_update) { |list|
-    result, average, diff = Mvn2::Plugins.get_vars :result, :average, :diff
-    basic_type(list, result, average, diff)
-  }
-
-  register_type(:block_full_average) { |list| Mvn2::Plugins.get(:block_average) || basic_type(list) }
-
-  register :option, sym: :track_average, names: %w(-k --track-average), desc: 'update the average and also display a progress bar while the build is in progress'
+  def self.def_vars
+    register_variable :average
+    register_variable :averages2
+    register_variable :counts
+  end
 
-  register :option, sym: :track_full_average, names: %w(-u --track-full-average), desc: 'update the average list and also display a progress bar while the build is in progress'
+  def_vars
 
-  register :option, sym: :advanced_average, names: %w(-d --advanced-average), desc: 'use k-means (with minimum optimal k) to find a list of averages and use the closest one for the progress bar and displayed average'
+  def self.def_types
+    register_type(:full_avg_name) { |list|
+      options = Plugins.get_var :options
+      pieces  = []
+      list.sort_by { |v| v[:options][:order] }.each { |name| pieces << name[:block].call(options) }
+      pieces.join
+    }
 
-  register :option, sym: :show_average, names: %w(-w --show-average), desc: 'show the average(s) before and after the build (average tracking must be enabled)'
+    register_type(:block_average) { |list| basic_type(list) }
 
-  register :option, sym: :block_update, names: %w(-b --block-update), desc: 'block the average feature from updating the file(s)'
+    register_type(:block_update) { |list|
+      result, average, diff = Plugins.get_vars :result, :average, :diff
+      basic_type(list, result, average, diff)
+    }
 
-  register :block_update, option: :block_update
+    register_type(:block_full_average) { |list| Plugins.get(:block_average) || basic_type(list) }
+  end
 
-  register(:block_update) { |options, result, average, diff| !(result || (!options[:skip_tests] && diff >= average / 2.0)) }
+  def_types
 
-  register :block_full_average, option: :track_full_average, value: false
+  def self.def_options
+    register :option, sym: :track_average, names: %w(-k --track-average), desc: 'update the average and also display a progress bar while the build is in progress'
+    register :option, sym: :track_full_average, names: %w(-u --track-full-average), desc: 'update the average list and also display a progress bar while the build is in progress'
+    register :option, sym: :advanced_average, names: %w(-d --advanced-average), desc: 'use k-means (with minimum optimal k) to find a list of averages and use the closest one for the progress bar and displayed average'
+    register :option, sym: :show_average, names: %w(-w --show-average), desc: 'show the average(s) before and after the build (average tracking must be enabled)'
+    register :option, sym: :block_update, names: %w(-b --block-update), desc: 'block the average feature from updating the file(s)'
+  end
 
-  register :block_average, option: :track_average, value: false
+  def_options
 
-  register(:before_run, order: 1) { |options|
-    read_avg
-    read_full_avg
-    read_advanced_avg
-    show_averages if options[:show_average]
-  }
+  def self.def_blockers
+    register :block_update, option: :block_update
+    register(:block_update) { |options, result, average, diff| !(result || (!options[:skip_tests] && diff >= average / 2.0)) }
+    register :block_full_average, option: :track_full_average, value: false
+    register :block_average, option: :track_average, value: false
+  end
 
-  register(:after_run, order: 2) { |_, _|
-    update_avg
-    update_full_avg
-  }
+  def_blockers
 
-  register(:after_run, order: 4) { |options, _|
-    if options[:show_average]
+  def self.def_actions
+    register(:before_run, order: 1) { |options|
       read_avg
       read_full_avg
       read_advanced_avg
-      show_averages
-    end
-  }
+      show_averages if options[:show_average]
+    }
+
+    register(:after_run, order: 2) { |_, _|
+      update_avg
+      update_full_avg
+    }
+
+    register(:after_run, order: 4) { |options, _|
+      if options[:show_average]
+        read_avg
+        read_full_avg
+        read_advanced_avg
+        show_averages
+      end
+    }
+  end
+
+  def_actions
 
   def self.full_avg_file
-    pieces = Mvn2::Plugins.get :full_avg_name
+    pieces = Plugins.get :full_avg_name
     "avg#{pieces}.txt"
   end
 
@@ -78,31 +93,31 @@ class AvgPlugin
   end
 
   def self.read_full_avg
-    average   = Mvn2::Plugins.get_var :average
+    average   = Plugins.get_var :average
     file_name = full_avg_file
-    if !Mvn2::Plugins.get(:block_full_average) && File.exist?(file_name)
+    if !Plugins.get(:block_full_average) && File.exist?(file_name)
       lines   = IO.readlines(file_name)
       data    = lines.filtermap { |line| float_filter(line) }
       average = data.average
     end
-    Mvn2::Plugins.set_var :average, average
+    Plugins.set_var :average, average
   end
 
   def self.read_advanced_avg
-    options, average = Mvn2::Plugins.get_vars :options, :average
+    options, average = 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)
+    if !Plugins.get(:block_full_average) && options[:advanced_average] && File.exist?(file_name)
       lines    = IO.readlines(file_name)
       data     = lines.filtermap { |line| float_filter(line) }
       averages = data.nmeans
     end
-    Mvn2::Plugins.set_var :averages, averages
+    Plugins.set_var :averages, averages
   end
 
   def self.update_full_avg
-    diff = Mvn2::Plugins.get_var :diff
-    if !Mvn2::Plugins.get(:block_full_average) && !Mvn2::Plugins.get(:block_update)
+    diff = Plugins.get_var :diff
+    if !Plugins.get(:block_full_average) && !Plugins.get(:block_update)
       file = File.new(full_avg_file, 'a+')
       file.puts(diff)
       file.close
@@ -119,11 +134,11 @@ class AvgPlugin
   end
 
   def self.read_avg
-    options  = Mvn2::Plugins.get_var :options
+    options  = Plugins.get_var :options
     average  = 0
     averages = [0, 0, 0, 0]
     counts   = [0, 0, 0, 0]
-    if !Mvn2::Plugins.get(:block_average) && File.exist?('avg.txt')
+    if !Plugins.get(:block_average) && File.exist?('avg.txt')
       lines = IO.readlines('avg.txt')
       get_data(averages, counts, lines, 0)
       get_data(averages, counts, lines, 1)
@@ -132,26 +147,26 @@ class AvgPlugin
       pkg     = options[:package] ? 2 : 0
       average = averages[(options[:skip_tests] ? 0 : 1) + pkg]
     end
-    Mvn2::Plugins.set_vars average: average, averages2: averages, counts: counts
+    Plugins.set_vars average: average, averages2: averages, counts: counts
   end
 
   def self.calc_new_avg(ind)
-    averages2, counts, diff = Mvn2::Plugins.get_vars :averages2, :counts, :diff
+    averages2, counts, diff = 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, averages2, counts = Mvn2::Plugins.get_vars :options, :averages2, :counts
-    if !Mvn2::Plugins.get(:block_average) && !Mvn2::Plugins.get(:block_update)
+    options, averages2, counts = Plugins.get_vars :options, :averages2, :counts
+    if !Plugins.get(:block_average) && !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]}")
     end
   end
 
   def self.show_averages
-    averages = Mvn2::Plugins.get_var :averages
+    averages = Plugins.get_var :averages
     unless averages.empty? || (averages.length == 1 && averages[0] == 0)
       strs = averages.map { |a|
         m, s = get_time_parts(a)

data/lib/mvn2/plugin/command.plugin.rb

@@ -1,33 +1,44 @@
-require 'mvn2/plugin'
+require 'everyday-plugins'
+include EverydayPlugins
 class CommandPlugin
-  extend Mvn2::Plugin
-  extend Mvn2::PluginType
+  extend Plugin
+  extend PluginType
+
+  def self.def_options
+    register :option_with_param, sym: :command_override, names: ['--command-override'], desc: 'override the maven command (disables average tracking options and skip test option)'
+    register :option, sym: :package, names: %w(-p --package), desc: 'run "mvn clean package" (with optional "-D skipTests")'
+    register :option_with_param, sym: :run_before, names: ['--run-before'], desc: 'run a command before calling the maven build'
+    register :option_with_param, sym: :run_after, names: ['--run-after'], desc: 'run a command after finishing the maven build'
+    register :option_with_param, sym: :run_success, names: ['--run-success'], desc: 'run a command after finishing a successful maven build'
+    register :option_with_param, sym: :run_failure, names: ['--run-failure'], desc: 'run a command after finishing an unsuccessful maven build'
+  end
 
-  register :option_with_param, sym: :command_override, names: ['--command-override'], desc: 'override the maven command (disables average tracking options and skip test option)'
+  def_options
 
-  register :option, sym: :package, names: %w(-p --package), desc: 'run "mvn clean package" (with optional "-D skipTests")'
+  def self.def_others
+    register :goal_override, order: 10, option: :package, goal: 'package'
 
-  register :option_with_param, sym: :run_before, names: ['--run-before'], desc: 'run a command before calling the maven build'
-  register :option_with_param, sym: :run_after, names: ['--run-after'], desc: 'run a command after finishing the maven build'
-  register :option_with_param, sym: :run_success, names: ['--run-success'], desc: 'run a command after finishing a successful maven build'
-  register :option_with_param, sym: :run_failure, names: ['--run-failure'], desc: 'run a command after finishing an unsuccessful maven build'
+    register :goal_override, override_all: true, priority: 100, option: :command_override
 
-  register :goal_override, order: 10, option: :package, goal: 'package'
+    register(:full_avg_name, order: 20) { |options| options[:package] ? '-package' : '' }
 
-  register :goal_override, override_all: true, priority: 100, option: :command_override
+    register(:operation_name, priority: 100) { |options| options[:command_override].nil? ? nil : 'Operation' }
 
-  register(:full_avg_name, order: 20) { |options| options[:package] ? '-package' : '' }
+    register(:block_average) { |options| !options[:command_override].nil? }
+  end
 
-  register(:operation_name, priority: 100) { |options| options[:command_override].nil? ? nil : 'Operation' }
+  def_others
 
-  register(:block_average) { |options| !options[:command_override].nil? }
+  def self.def_actions
+    register(:before_start, order: 10) { |options| run_cmd(options[:run_before]) }
 
-  register(:before_start, order: 10) { |options| run_cmd(options[:run_before]) }
+    register(:after_end, order: 10) { |options, result|
+      run_cmd(options[:run_after])
+      result ? run_cmd(options[:run_success]) : run_cmd(options[:run_failure])
+    }
+  end
 
-  register(:after_end, order: 10) { |options, result|
-    run_cmd(options[:run_after])
-    result ? run_cmd(options[:run_success]) : run_cmd(options[:run_failure])
-  }
+  def_actions
 
   def self.run_cmd(cmd)
     unless cmd.nil?

data/lib/mvn2/plugin/default_runner.plugin.rb

@@ -1,30 +1,39 @@
-require 'mvn2/plugin'
+require 'everyday-plugins'
+include EverydayPlugins
 class DefaultRunnerPlugin
-  extend Mvn2::Plugin
-  extend Mvn2::PluginType
+  extend Plugin
+  extend PluginType
 
   register_variable :output
 
-  register(:runner_enable, key: :default) { |_| true }
+  def self.def_runners
+    register(:runner_enable, key: :default) { |_| true }
 
-  register(:runner, key: :default, priority: 0) { |_, cmd|
-    output = `#{cmd}`
-    result = $?.success?
-    Mvn2::Plugins.set_var :output, output
-    result
-  }
+    register(:runner, key: :default, priority: 0) { |_, cmd|
+      output = `#{cmd}`
+      result = $?.success?
+      Plugins.set_var :output, output
+      result
+    }
+  end
 
-  register(:after_run, order: 1000) { |_, _|
-    runner = Mvn2::Plugins.get_var :runner
-    if runner == :default
-      output = Mvn2::Plugins.get_var :output
-      IO.write(Mvn2::Plugins.get(:log_file_name), output) if Mvn2::Plugins.get(:log_file_enable)
-      output.each_line { |l|
-        tmp = Mvn2::Plugins.get :line_filter, l
-        puts tmp unless tmp.nil?
-      }
-      found = Mvn2::Plugins.get_var :found
-      output.each_line { |line| puts line } unless found
-    end
-  }
+  def_runners
+
+  def self.def_actions
+    register(:after_run, order: 1000) { |_, _|
+      runner = Plugins.get_var :runner
+      if runner == :default
+        output = Plugins.get_var :output
+        IO.write(Plugins.get(:log_file_name), output) if Plugins.get(:log_file_enable)
+        output.each_line { |l|
+          tmp = Plugins.get :line_filter, l
+          puts tmp unless tmp.nil?
+        }
+        found = Plugins.get_var :found
+        output.each_line { |line| puts line } unless found
+      end
+    }
+  end
+
+  def_actions
 end

data/lib/mvn2/plugin/exception.plugin.rb

@@ -1,6 +1,7 @@
-require 'mvn2/plugin'
+require 'everyday-plugins'
+include EverydayPlugins
 class ExceptionPlugin
-  extend Mvn2::Plugin
+  extend Plugin
 
   register :option, sym: :exception, names: %w(-e --exception), desc: 'add the "-e -X" options to the mvn call'
 

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

@@ -1,4 +1,5 @@
-require 'mvn2/plugin'
+require 'everyday-plugins'
+include EverydayPlugins
 
 class String
   def start_with_any?(*strs)
@@ -7,75 +8,102 @@ class String
 end
 
 class FilterPlugin
-  extend Mvn2::Plugin
-  extend Mvn2::PluginType
+  extend Plugin
+  extend PluginType
 
   INFO_LINE   = '[INFO] ------------------------------------------------------------------------'
   BUILD_REGEX = /\[INFO\] Building (?!(jar|war|zip))/
 
-  register_variable :info_line_last, false
-  register_variable :found, false
+  def self.def_vars
+    register_variable :info_line_last, false
+    register_variable :found, false
+  end
+
+  def_vars
 
-  register :option, sym: :hide_between, names: %w(-h --hide-between), desc: 'hide the output between the end of test results (the line starting with "Tests run:") and the next trigger line'
+  def self.def_options
+    register :option, sym: :hide_between, names: %w(-h --hide-between), desc: 'hide the output between the end of test results (the line starting with "Tests run:") and the next trigger line'
+    register :option, sym: :show_projects, names: %w(-j --show-projects), desc: 'show the "Building <project>" lines when outputting'
+  end
 
-  register :option, sym: :show_projects, names: %w(-j --show-projects), desc: 'show the "Building <project>" lines when outputting'
+  def_options
 
-  register(:line_filter, priority: 10) { |_, line|
-    info_line_last = Mvn2::Plugins.get_var :info_line_last
-    if line.start_with_any?('[INFO] BUILD SUCCESS', '[INFO] Reactor Summary:', '[INFO] BUILD FAILURE')
-      str = ''
-      str << INFO_LINE << "\n" unless info_line_last
-      str << line << "\n"
-      Mvn2::Plugins.set_vars found: true, info_line_last: false
-      str
-    else
-      nil
-    end
-  }
+  def self.def_filters
+    def_filter1
+    def_filter2
+    def_filter3
+    def_filter4
+    def_filter5
+  end
 
-  register(:line_filter, priority: 20) { |_, line|
-    if line.start_with_any?('[ERROR] COMPILATION ERROR :', 'Results :')
-      str = line << "\n"
-      Mvn2::Plugins.set_vars found: true, info_line_last: false
-      str
-    else
-      nil
-    end
-  }
+  def self.def_filter1
+    register(:line_filter, priority: 10) { |_, line|
+      info_line_last = Plugins.get_var :info_line_last
+      if line.start_with_any?('[INFO] BUILD SUCCESS', '[INFO] Reactor Summary:', '[INFO] BUILD FAILURE')
+        str = ''
+        str << INFO_LINE << "\n" unless info_line_last
+        str << line << "\n"
+        Plugins.set_vars found: true, info_line_last: false
+        str
+      else
+        nil
+      end
+    }
+  end
 
-  register(:line_filter, priority: 30) { |_, line|
-    found = Mvn2::Plugins.get_var :found
-    if found
-      str = line << "\n"
-      Mvn2::Plugins.set_vars found: true, info_line_last: line.start_with?(INFO_LINE)
-      str
-    else
-      nil
-    end
-  }
+  def self.def_filter2
+    register(:line_filter, priority: 20) { |_, line|
+      if line.start_with_any?('[ERROR] COMPILATION ERROR :', 'Results :')
+        str = line << "\n"
+        Plugins.set_vars found: true, info_line_last: false
+        str
+      else
+        nil
+      end
+    }
+  end
 
-  register(:line_filter, priority: 40) { |options, line|
-    found = Mvn2::Plugins.get_var :found
-    if options[:hide_between] && found && line.start_with?('Tests run:')
-      str = line << "\n\n"
-      Mvn2::Plugins.set_vars found: false, info_line_last: false
-      str
-    else
-      nil
-    end
-  }
+  def self.def_filter3
+    register(:line_filter, priority: 30) { |_, line|
+      found = Plugins.get_var :found
+      if found
+        str = line << "\n"
+        Plugins.set_vars found: true, info_line_last: line.start_with?(INFO_LINE)
+        str
+      else
+        nil
+      end
+    }
+  end
+
+  def self.def_filter4
+    register(:line_filter, priority: 40) { |options, line|
+      found = Plugins.get_var :found
+      if options[:hide_between] && found && line.start_with?('Tests run:')
+        str = line << "\n\n"
+        Plugins.set_vars found: false, info_line_last: false
+        str
+      else
+        nil
+      end
+    }
+  end
+
+  def self.def_filter5
+    register(:line_filter, priority: 50) { |options, line|
+      info_line_last = Plugins.get_var :info_line_last
+      if options[:show_projects] && line =~ BUILD_REGEX
+        str = ''
+        str << INFO_LINE << "\n" unless info_line_last
+        str << line << "\n"
+        str << INFO_LINE << "\n"
+        Plugins.set_var :info_line_last, true
+        str
+      else
+        nil
+      end
+    }
+  end
 
-  register(:line_filter, priority: 50) { |options, line|
-    info_line_last = Mvn2::Plugins.get_var :info_line_last
-    if options[:show_projects] && line =~ BUILD_REGEX
-      str = ''
-      str << INFO_LINE << "\n" unless info_line_last
-      str << line << "\n"
-      str << INFO_LINE << "\n"
-      Mvn2::Plugins.set_var :info_line_last, true
-      str
-    else
-      nil
-    end
-  }
+  def_filters
 end

data/lib/mvn2/plugin/growl.plugin.rb

@@ -1,7 +1,8 @@
-require 'mvn2/plugin'
+require 'everyday-plugins'
+include EverydayPlugins
 class GrowlPlugin
-  extend Mvn2::Plugin
-  extend Mvn2::PluginType
+  extend Plugin
+  extend PluginType
 
   register :option, sym: :no_sticky, names: %w(-n --no-sticky), desc: 'make the growl notification non-sticky'
 

data/lib/mvn2/plugin/live_print.plugin.rb

@@ -1,6 +1,7 @@
-require 'mvn2/plugin'
+require 'everyday-plugins'
+include EverydayPlugins
 class LivePrintPlugin
-  extend Mvn2::Plugin
+  extend Plugin
 
   register :option, sym: :display_all, names: %w(-a --display-all), desc: 'display all output'
 
@@ -14,10 +15,10 @@ class LivePrintPlugin
   register(:runner, key: :live_print, priority: 1000) { |_, cmd|
     result = false
     begin
-      log_file = Mvn2::Plugins.get(:log_file_enable) ? File.open(Mvn2::Plugins.get(:log_file_name), 'w+') : nil
+      log_file = Plugins.get(:log_file_enable) ? File.open(Plugins.get(:log_file_name), 'w+') : nil
       IO.popen(cmd).each do |l|
         log_file << l unless log_file.nil?
-        output = Mvn2::Plugins.get :line_filter, l
+        output = Plugins.get :line_filter, l
         puts "\r\e[2K#{output}" unless output.nil?
         result = true if l.chomp.start_with?('[INFO] BUILD SUCCESS')
       end

data/lib/mvn2/plugin/logging.plugin.rb

@@ -1,7 +1,8 @@
-require 'mvn2/plugin'
+require 'everyday-plugins'
+include EverydayPlugins
 class LoggingPlugin
-  extend Mvn2::Plugin
-  extend Mvn2::PluginType
+  extend Plugin
+  extend PluginType
 
   register :option, sym: :write_log, names: %w(-l --write-log), desc: 'write all of the output to a log file'
   register :option_with_param, sym: :log_file, names: ['--log-file'], desc: 'set the log file name', default: 'build.log'

data/lib/mvn2/plugin/skip_tests.plugin.rb

@@ -1,6 +1,7 @@
-require 'mvn2/plugin'
+require 'everyday-plugins'
+include EverydayPlugins
 class SkipTestsPlugin
-  extend Mvn2::Plugin
+  extend Plugin
 
   register :option, sym: :skip_tests, names: %w(-s --skip-tests), desc: 'skip tests'
 

data/lib/mvn2/plugin/timer.plugin.rb

@@ -1,7 +1,8 @@
-require 'mvn2/plugin'
+require 'everyday-plugins'
+include EverydayPlugins
 class TimerPlugin
-  extend Mvn2::Plugin
-  extend Mvn2::PluginType
+  extend Plugin
+  extend PluginType
 
   register_variable :time1
   register_variable :diff
@@ -12,9 +13,9 @@ class TimerPlugin
   register :option, sym: :colored, names: %w(-c --colored), desc: 'display some colors in the timer/progress message'
 
   register(:before_run, order: 2) { |options|
-    Mvn2::Plugins.set_var :time1, Time.now
-    Mvn2::Plugins.set_var :thread, options[:timer] ? Thread.new {
-      start_time = Mvn2::Plugins.get_var :time1
+    Plugins.set_var :time1, Time.now
+    Plugins.set_var :thread, options[:timer] ? Thread.new {
+      start_time = Plugins.get_var :time1
       while true
         print "\r#{get_timer_message(start_time, Time.now)}"
         sleep(0.05)
@@ -24,12 +25,12 @@ class TimerPlugin
 
   register(:after_run, order: 1) { |_, _|
     time2 = Time.now
-    time1 = Mvn2::Plugins.get_var :time1
-    Mvn2::Plugins.set_var :diff, time2 - time1
+    time1 = Plugins.get_var :time1
+    Plugins.set_var :diff, time2 - time1
   }
 
   register(:after_run, order: 3) { |_, _|
-    thread = Mvn2::Plugins.get_var :thread
+    thread = Plugins.get_var :thread
     unless thread.nil?
       thread.kill
       print "\n"
@@ -37,7 +38,7 @@ class TimerPlugin
   }
 
   def self.colorize_if_should(text)
-    options = Mvn2::Plugins.get_var :options
+    options = Plugins.get_var :options
     options[:colored] ? text.format_all : text.remove_format
   end
 
@@ -48,7 +49,7 @@ class TimerPlugin
   end
 
   def self.get_closest(time)
-    averages = Mvn2::Plugins.get_var :averages
+    averages = Plugins.get_var :averages
     averages.min { |a, b| (a - time).abs <=> (b - time).abs }
   end
 

data/lib/mvn2/plugin.rb

@@ -1,93 +1,14 @@
 require 'everyday-cli-utils'
 include EverydayCliUtils
 import :maputil
+require 'everyday-plugins'
+include EverydayPlugins
 
 module Mvn2
-  class Plugins
-    def self.instance
-      @instance ||= Plugins.new
-    end
-
-    def initialize
-      @ext   = {}
-      @types = {}
-      @vars  = {}
-    end
-
-    def register(type, options = {}, &block)
-      @ext[type] ||= []
-      @ext[type] << { options: options, block: block }
-    end
-
-    def register_type(type, &block)
-      @types[type] = block
-    end
-
-    def register_variable(name, value = nil)
-      @vars[name] = value
-    end
-
-    def [](type)
-      @ext[type] || []
-    end
-
-    def get(type, *args)
-      @types[type].call(self[type], *args)
-    end
-
-    def self.get(type, *args)
-      instance.get(type, *args)
-    end
-
-    def get_var(name)
-      @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)
-      Mvn2::Plugins.instance.register(type, options, &block)
-    end
-  end
-  module PluginType
-    def register_type(type, &block)
-      Mvn2::Plugins.instance.register_type(type, &block)
-    end
-
-    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
+      options = Plugins.get_var :options
       list.any? { |item|
         if item[:block].nil?
           flag_boolean(item, options)
@@ -117,25 +38,24 @@ module Mvn2
     end
 
     def simple_type(list, *args)
-      options = Mvn2::Plugins.get_var :options
+      options = 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
+      result = Plugins.get_var :result
       simple_type(list, result)
     end
-  end
-  class DefaultTypes
-    extend Mvn2::PluginType
-    extend Mvn2::TypeHelper
 
-    register_variable :options
-    register_variable :result
-    register_variable :runner
-    register_variable :cmd
-    register_variable :cmd_clean
-    register_variable :message_text
+    def get_name(list)
+      options = Plugins.get_var :options
+      rval    = complex_filter(list.sort_by { |v| -v[:options][:priority] }, options, :name)
+      (rval.nil? || rval.empty?) ? false : rval.first
+    end
+  end
+  class OptionTypes
+    extend PluginType
+    extend TypeHelper
 
     def self.register_option(list, options)
       list.sort_by { |v| v[:options][:sym].to_s }.each { |option|
@@ -153,19 +73,10 @@ module Mvn2
     end
 
     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_boolean(flag, options)
-        else
-          flag[:block].call(options, flags)
-        end
-      }
-      flags.join
-    }
+  end
+  class ActionTypes
+    extend PluginType
+    extend TypeHelper
 
     def self.def_actions
       register_type(:before_run) { |list| simple_type(list) }
@@ -173,74 +84,119 @@ module Mvn2
       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
+        options, result, cmd_clean, message_text = 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
 
     def_actions
-
-    def self.get_name(list)
-      options = Mvn2::Plugins.get_var :options
-      rval    = complex_filter(list.sort_by { |v| -v[:options][:priority] }, options, :name)
-      (rval.nil? || rval.empty?) ? false : rval.first
-    end
+  end
+  class LogTypes
+    extend PluginType
+    extend TypeHelper
 
     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) }
+      register_type(:log_file_enable) { |list| (Plugins.get(:log_file_name).nil? || Plugins.get(:log_file_disable)) ? false : basic_type(list) }
     end
 
     def_logs
+  end
+  class FilterTypes
+    extend PluginType
+    extend TypeHelper
+
+    def self.def_filter
+      register_type(:line_filter) { |list, line|
+        options = Plugins.get_var :options
+        line    = line.chomp
+        result  = nil
+        begin
+          list.sort_by { |v| -v[:options][:priority] }.each { |item|
+            tmp = item[:block].call(options, line)
+            unless tmp.nil?
+              result = tmp || nil
+              break
+            end
+          }
+        rescue
+          result = line
+        end
+        result
+      }
+    end
+
+    def_filter
+  end
+  class RunnerTypes
+    extend PluginType
+    extend TypeHelper
 
-    register_type(:line_filter) { |list, line|
-      options = Mvn2::Plugins.get_var :options
-      line    = line.chomp
-      result  = nil
-      begin
+    def self.def_runner
+      register_type(:runner_enable) { |list, key| basic_type(list.select { |v| v[:options][:key] == key }) }
+
+      register_type(:runner) { |list|
+        options, cmd = Plugins.get_vars :options, :cmd
+        Plugins.set_var :result, false
         list.sort_by { |v| -v[:options][:priority] }.each { |item|
-          tmp = item[:block].call(options, line)
-          unless tmp.nil?
-            result = tmp || nil
+          if Plugins.get(:runner_enable, item[:options][:key])
+            Plugins.set_var :runner, item[:options][:key]
+            Plugins.set_var :result, item[:block].call(options, cmd)
             break
           end
         }
-      rescue
-        result = line
-      end
-      result
-    }
+        Plugins.get_var :result
+      }
+    end
 
-    register_type(:runner_enable) { |list, key| basic_type(list.select { |v| v[:options][:key] == key }) }
+    def_runner
+  end
+  class CommandTypes
+    extend PluginType
+    extend TypeHelper
+
+    def self.def_command
+      def_command_flag
+      def_command_goal
+      register_type(:operation_name) { |list| get_name(list) || 'Operation' }
+    end
+
+    def self.def_command_flag
+      register_type(:command_flag) { |list|
+        options = Plugins.get_var :options
+        flags   = []
+        list.each { |flag|
+          if flag[:block].nil?
+            flags << " #{flag[:options][:flag]}" if flag_boolean(flag, options)
+          else
+            flag[:block].call(options, flags)
+          end
+        }
+        flags.join
+      }
+    end
 
-    register_type(:runner) { |list|
-      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])
-          Mvn2::Plugins.set_var :runner, item[:options][:key]
-          Mvn2::Plugins.set_var :result, item[:block].call(options, cmd)
-          break
+    def self.def_command_goal
+      register_type(:goal_override) { |list|
+        options        = Plugins.get_var :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 = 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(' ')
+        else
+          full_overrides.first
         end
       }
-      Mvn2::Plugins.get_var :result
-    }
-
-    register_type(:goal_override) { |list|
-      options        = Mvn2::Plugins.get_var :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 = 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(' ')
-      else
-        full_overrides.first
-      end
-    }
+    end
 
-    register_type(:operation_name) { |list| get_name(list) || 'Operation' }
+    def_command
+  end
+  class ColorTypes
+    extend PluginType
+    extend TypeHelper
 
     DEFAULT_COLOR_OPTS = {
         time:    {
@@ -257,17 +213,36 @@ module Mvn2
         },
     }
 
-    register_type(:color_override) { |list|
-      options = Mvn2::Plugins.get_var :options
-      opts    = DEFAULT_COLOR_OPTS
-      list.sort_by { |v| -v[:options][:priority] }.each { |item|
-        rval = item[:block].call(options)
-        unless rval.nil? || !rval
-          opts = rval
-          break
-        end
+    def self.def_color
+      register_type(:color_override) { |list|
+        options = Plugins.get_var :options
+        opts    = DEFAULT_COLOR_OPTS
+        list.sort_by { |v| -v[:options][:priority] }.each { |item|
+          rval = item[:block].call(options)
+          unless rval.nil? || !rval
+            opts = rval
+            break
+          end
+        }
+        opts.each { |opt| Format.color_profile opt[0], fgcolor: opt[1][:fg], bgcolor: opt[1][:bg] }
       }
-      opts.each { |opt| Format.color_profile opt[0], fgcolor: opt[1][:fg], bgcolor: opt[1][:bg] }
-    }
+    end
+
+    def_color
+  end
+  class DefaultTypes
+    extend PluginType
+    extend TypeHelper
+
+    def self.def_vars
+      register_variable :options
+      register_variable :result
+      register_variable :runner
+      register_variable :cmd
+      register_variable :cmd_clean
+      register_variable :message_text
+    end
+
+    def_vars
   end
 end

data/lib/mvn2/version.rb

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

data/mvn2.gemspec

@@ -23,4 +23,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake', '~> 10.0'
 
   spec.add_dependency 'everyday-cli-utils', '>= 1.3.0'
+  spec.add_dependency 'everyday-plugins', '>= 1.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mvn2
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Eric Henderson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-02 00:00:00.000000000 Z
+date: 2014-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: everyday-plugins
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 description: a Ruby script that runs a maven build, including (or not including) tests,
   and only outputs the lines that come after a compile failure, build success, test
   result, or reactor summary start line