mvn2 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3d25d900f40c6578c29991f7d1c234f7894b8a1c
+  data.tar.gz: 3e3881f9756edc657c746efadb2f89e44706bd89
+SHA512:
+  metadata.gz: f9f4feef2d939bc73012ab565262428faa9d113c1a86705bca6932206aa7a30cebbb404ac2d9b900402fa7210124c6b6917f4970f0387c30e927155d10d4ed7e
+  data.tar.gz: f1c75f175b6834fcb2660465335558b5d39d37120f80e34d46c695475b09b157f85e38101da59a188cd2276e11111e8018eac81d0715f4707b1a0d0f4c3ac05f

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+/.idea/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mvn2.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Eric Henderson
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,42 @@
+# mvn2
+
+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
+
+## Installation
+
+Install it yourself as:
+
+    $ gem install mvn2
+
+## Usage
+
+###optional parameters:
+* `-t` or `--timer` to display a timer while the build is in progress (default is display nothing)
+* `-s` or `--skip-tests` to skip tests (default is running tests)
+* `-n` or `--no-sticky` to make the growl notification non-sticky (default is sticky)
+* `-a` or `--display-all` to display all output (default is to only display the output after a compile failure, build success, test result, or reactor summary start line)
+* `-k` or `--track-average` to update the average (stored in `avg.txt`) and also display a progress bar while the build is in progress (default is not to do track average or display progress bar)
+* `-u` or `--track-full-average` to update the average list (stored in `avg-skip.txt` or `avg-test.txt`) and also display a progress bar while the build is in progress (default is to not do track average or display progress bar) (including this option will cause the progress bar to use the average calculated from the average list if available, but if `-k` or `--track-average` is specified, `avg.txt` will still be updated)
+* `-c` or `--colored` to display some colors in the timer/progress message
+* `--write-log` to write all of the output to a log file (default is to not write to a log file)
+* `--log-file NAME` to set the log file name to `NAME` (default is `build.log`)
+* `-d` or `--advanced-average` to 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 (default is to use overall average)
+* `--command-override CMD` to override the maven command (disables average tracking options and skip test option) (default is `clean install` (with optional `-D skipTests`) and not disabling any options)
+* `-p` or `--package` to run `mvn clean package` (with optional `-D skipTests`) (default is `mvn clean install` (with optional `-D skipTests`) (supports average tracking)
+* `-h` or `--hide-between` to hide the output between the end of test results (the line starting with "Tests run:") and the next trigger line
+* `-w` or `--show-average` to show the average(s) before and after the build (average tracking must be enabled) (default is to not show averages)
+* `-b` or `--block-update` to block the average feature from updating the file(s)
+* `-v` or `--override-colors` to override the colors with the ones configured by the [colorconfig][colorconfig] script
+* `-j` or `--show-projects` to show the `Building <project>` lines when outputting
+* `--run-before CMD` to run `CMD` before calling the maven build
+* `--run-after CMD` to run `CMD` after finishing the maven build
+* `--run-success CMD` to run `CMD` after finishing a successful maven build
+* `--run-failure CMD` to run `CMD` after finishing an unsuccessful maven build
+* `-e` or `--exception` to add the `-e -X` options to the `mvn` call
+* `-0` or `--live-print` to print filtered lines as they are outputted by maven
+* `-1` or `--set-defaults` to set the defaults so you can just run `mvn2` without any parameters
+* `--mobile-number NUM` to use the mobile number `NUM` (with country code and nothing other than digits) (country code for US is 1 so an example phone number would be `--mobile-number "13175649047"`) as the recipient of a text message (from **13179120742**) indicating the success or failure of a build and the name of the immediate folder of the build (requires gem `nexmo`)
+* `-2` or `--advanced-text` to upload the folder name, build time so far, and estimated percent complete (based on stored averages) to a server so that you can text **13179120742** (the number you get the build completion texts from) to get the status(es) of your ongoing build(s).  If you send the exact name of the folder (case-**sensitive**, only 1 at a time), it will only reply with entries matching that build.  If you text anything that does not exactly match a folder name, it will simply reply with all of the ongoing build statuses.  It identifies your builds by your mobile number, so make sure you're texting from the number you used as the parameter to the `--mobile-number NUM` option.
+
+###displays:
+a Growl notification indicating success or failure

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/mvn2

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'yaml'
+require 'net/http'
+require 'rubygems'
+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
+
+#abcd   h jkl n p  stuvw   012
+#    efg i   m o qr     xyz   3456789
+
+class MyOptions
+  extend OptionUtil
+
+  default_settings toggle: true
+
+  defaults_option 'mvn2-defaults.yaml', %w(-1 --set-defaults), desc: 'set the defaults so you can just run mvn2 without any parameters (local to each folder)'
+
+  help_option ['--help'], desc: 'print out this help'
+end
+
+Mvn2::Plugins.get(:option, MyOptions)
+Mvn2::Plugins.get(:option_with_param, MyOptions)
+
+MyOptions.parse!
+
+options = MyOptions.options
+
+Mvn2::Plugins.set_var(:options, options)
+
+Signal.trap('SIGINT') {
+  puts "\nBuild Canceled\n\n"
+  exit 1
+}
+
+class String
+  def start_with_any?(*strs)
+    strs.empty? ? false : strs.any? { |str| start_with?(str) }
+  end
+end
+
+Mvn2::Plugins.get :color_override
+
+class Mvn2Runner
+  HEADLESS    = ' -Djava.awt.headless=true'
+  INFO_LINE   = '[INFO] ------------------------------------------------------------------------'
+  BUILD_REGEX = /\[INFO\] Building (?!(jar|war|zip))/
+
+  def initialize(options)
+    @options = options
+    setup_cmd
+    Mvn2::Plugins.set_var :cmd, @cmd
+    Mvn2::Plugins.set_var :cmd_clean, @cmd_clean
+  end
+
+  def setup_cmd
+    flags      = Mvn2::Plugins.get :command_flag
+    goals      = Mvn2::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
+  end
+
+  def run
+    Mvn2::Plugins.get :before_start
+    run_and_filter_output
+    Mvn2::Plugins.get :after_end
+
+    operation_name = Mvn2::Plugins.get :operation_name
+    Mvn2::Plugins.set_var :message_text, "#{operation_name} #{(@result ? 'Successful' : 'Failed')}"
+
+    Mvn2::Plugins.get :notification
+  end
+end
+
+Mvn2Runner.new(options).run

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

@@ -0,0 +1,204 @@
+require 'mvn2/plugin'
+class AvgPlugin
+  extend Mvn2::Plugin
+  extend Mvn2::PluginType
+
+  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|
+    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)
+      else
+        item[:block].call(options)
+      end
+    }
+  }
+
+  register_type(:block_update) { |list|
+    options = Mvn2::Plugins.get_var :options
+    result  = Mvn2::Plugins.get_var :result
+    average = Mvn2::Plugins.get_var :average
+    diff    = Mvn2::Plugins.get_var :diff
+    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)
+      else
+        item[:block].call(options, result, average, diff)
+      end
+    }
+  }
+
+  register_type(:block_full_average) { |list|
+    if Mvn2::Plugins.get(:block_average)
+      true
+    else
+      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)
+        else
+          item[:block].call(options)
+        end
+      }
+    end
+  }
+
+  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)'
+
+  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
+
+  register(:before_run, order: 1) { |options|
+    read_avg
+    read_full_avg
+    read_advanced_avg
+    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
+  }
+
+  def self.full_avg_file
+    pieces = Mvn2::Plugins.get :full_avg_name
+    "avg#{pieces}.txt"
+  end
+
+  def self.float_filter(line)
+    begin
+      f = line.chomp
+      f.length == 0 || (f =~ /^\d+(\.\d+)?$/).nil? ? false : f.to_f
+    rescue
+      false
+    end
+  end
+
+  def self.read_full_avg
+    average   = Mvn2::Plugins.get_var :average
+    file_name = full_avg_file
+    if !Mvn2::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
+  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
+    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) }
+      averages = data.nmeans
+    end
+    Mvn2::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)
+      file = File.new(full_avg_file, 'a+')
+      file.puts(diff)
+      file.close
+    end
+  end
+
+  def self.get_data(averages, counts, lines, ind)
+    if lines.count > ind
+      parts         = lines[ind].chomp.split(';')
+      averages[ind] = parts[0].to_f
+      counts[ind]   = parts[1].to_i
+      averages[ind] = 0 if counts[ind] == 0
+    end
+  end
+
+  def self.read_avg
+    options  = Mvn2::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')
+      lines = IO.readlines('avg.txt')
+      get_data(averages, counts, lines, 0)
+      get_data(averages, counts, lines, 1)
+      get_data(averages, counts, lines, 2)
+      get_data(averages, counts, lines, 3)
+      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
+  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]
+  end
+
+  def self.update_avg
+    options   = Mvn2::Plugins.get_var :options
+    averages2 = Mvn2::Plugins.get_var :averages2
+    counts    = Mvn2::Plugins.get_var :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]}")
+    end
+  end
+
+  def self.show_averages
+    averages = Mvn2::Plugins.get_var :averages
+    unless averages.empty? || (averages.length == 1 && averages[0] == 0)
+      strs = averages.map { |a|
+        m, s = get_time_parts(a)
+        "#{m}:#{s}"
+      }
+      puts "\r\e[2KAverage(s): #{strs.join(', ')}"
+    end
+  end
+
+  def self.get_time_parts(time)
+    return (time / 60.0).floor, '%06.3f' % (time % 60)
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'mvn2/plugin'
+class CommandPlugin
+  extend Mvn2::Plugin
+  extend Mvn2::PluginType
+
+  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'
+
+  register :goal_override, order: 10, option: :package, goal: 'package'
+
+  register :goal_override, override_all: true, priority: 100, option: :command_override
+
+  register(:full_avg_name, order: 20) { |options| options[:package] ? '-package' : '' }
+
+  register(:operation_name, priority: 100) { |options| options[:command_override].nil? ? nil : 'Operation' }
+
+  register(:block_average) { |options| !options[:command_override].nil? }
+
+  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])
+  }
+
+  def self.run_cmd(cmd)
+    unless cmd.nil?
+      puts "$ #{cmd}"
+      system(cmd)
+      print "\n"
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'mvn2/plugin'
+class DefaultRunnerPlugin
+  extend Mvn2::Plugin
+  extend Mvn2::PluginType
+
+  register_variable :output
+
+  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(: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
+  }
+end

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

@@ -0,0 +1,8 @@
+require 'mvn2/plugin'
+class ExceptionPlugin
+  extend Mvn2::Plugin
+
+  register :option, sym: :exception, names: %w(-e --exception), desc: 'add the "-e -X" options to the mvn call'
+
+  register :command_flag, flag: '-e -X', option: :exception
+end

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

@@ -0,0 +1,85 @@
+require 'mvn2/plugin'
+
+class String
+  def start_with_any?(*strs)
+    strs.empty? ? false : strs.any? { |str| start_with?(str) }
+  end
+end
+
+class FilterPlugin
+  extend Mvn2::Plugin
+  extend Mvn2::PluginType
+
+  INFO_LINE   = '[INFO] ------------------------------------------------------------------------'
+  BUILD_REGEX = /\[INFO\] Building (?!(jar|war|zip))/
+
+  register_variable :info_line_last, false
+  register_variable :found, false
+
+  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'
+
+  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_var :found, true
+      Mvn2::Plugins.set_var :info_line_last, false
+      str
+    else
+      nil
+    end
+  }
+
+  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
+      str
+    else
+      nil
+    end
+  }
+
+  register(:line_filter, priority: 30) { |_, line|
+    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)
+      str
+    else
+      nil
+    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_var :found, false
+      Mvn2::Plugins.set_var :info_line_last, false
+      str
+    else
+      nil
+    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
+  }
+end

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

@@ -0,0 +1,13 @@
+require 'mvn2/plugin'
+class GrowlPlugin
+  extend Mvn2::Plugin
+  extend Mvn2::PluginType
+
+  register :option, sym: :no_sticky, names: %w(-n --no-sticky), desc: 'make the growl notification non-sticky'
+
+  register(:notification, order: 100) { |options, _, cmd_clean, message_text|
+    begin
+      `growlnotify -n Terminal -a Terminal#{(options[:no_sticky] ? '' : ' -s')} -m "#{message_text}" -t "#{cmd_clean}" 2>&1`
+    end until $?.success?
+  }
+end

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

@@ -0,0 +1,29 @@
+require 'mvn2/plugin'
+class LivePrintPlugin
+  extend Mvn2::Plugin
+
+  register :option, sym: :display_all, names: %w(-a --display-all), desc: 'display all output'
+
+  register :option, sym: :live_print, names: %w(-0 --live-print), desc: 'print filtered lines as they are outputted by maven'
+
+  register(:line_filter, priority: 10 ** 6) { |options, line| options[:display_all] ? line : nil }
+
+  register :runner_enable, key: :live_print, option: :live_print
+  register :runner_enable, key: :live_print, option: :display_all
+
+  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
+      IO.popen(cmd).each do |l|
+        log_file << l unless log_file.nil?
+        output = Mvn2::Plugins.get :line_filter, l
+        puts "\r\e[2K#{output}" unless output.nil?
+        result = true if l.chomp.start_with?('[INFO] BUILD SUCCESS')
+      end
+    ensure
+      log_file.close unless log_file.nil?
+    end
+    result
+  }
+end

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

@@ -0,0 +1,12 @@
+require 'mvn2/plugin'
+class LoggingPlugin
+  extend Mvn2::Plugin
+  extend Mvn2::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'
+
+  register :log_file_name, priority: 1000, option: :log_file
+
+  register :log_file_enable, option: :write_log
+end

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

@@ -0,0 +1,12 @@
+require 'mvn2/plugin'
+class SkipTestsPlugin
+  extend Mvn2::Plugin
+
+  register :option, sym: :skip_tests, names: %w(-s --skip-tests), desc: 'skip tests'
+
+  register :command_flag, flag: '-D skipTests', option: :skip_tests
+
+  register(:full_avg_name, order: 10) { |options| options[:skip_tests] ? '-skip' : '-test' }
+
+  register(:operation_name, priority: 10) { |options| options[:skip_tests] ? 'Build' : 'Tests' }
+end

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

@@ -0,0 +1,66 @@
+require 'mvn2/plugin'
+class TimerPlugin
+  extend Mvn2::Plugin
+  extend Mvn2::PluginType
+
+  register_variable :time1
+  register_variable :diff
+  register_variable :thread
+
+  register :option, sym: :timer, names: %w(-t --timer), desc: 'display a timer while the build is in progress'
+
+  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
+      while true
+        print "\r#{get_timer_message(start_time, Time.now)}"
+        sleep(0.05)
+      end
+    } : nil
+  }
+
+  register(:after_run, order: 1) { |_, _|
+    time2 = Time.now
+    time1 = Mvn2::Plugins.get_var :time1
+    Mvn2::Plugins.set_var :diff, time2 - time1
+  }
+
+  register(:after_run, order: 3) { |_, _|
+    thread = Mvn2::Plugins.get_var :thread
+    unless thread.nil?
+      thread.kill
+      print "\n"
+    end
+  }
+
+  def self.colorize_if_should(text)
+    options = Mvn2::Plugins.get_var :options
+    options[:colored] ? text.format_all : text.remove_format
+  end
+
+  def self.get_avg_message(amin, asec, avg, diff, m, s)
+    progress = ((diff.to_f / avg.to_f) * 100.0)
+    bars     = [progress.floor, 100].min
+    "[#{'=' * bars}>#{' ' * (100 - bars)}] {#{m}:#{s}}(:time) ({~#{'%.3f' % progress}%}(:percent)) (average: {#{amin}:#{asec}}(:average))"
+  end
+
+  def self.get_closest(time)
+    averages = Mvn2::Plugins.get_var :averages
+    averages.min { |a, b| (a - time).abs <=> (b - time).abs }
+  end
+
+  def self.get_timer_message(start_time, time)
+    diff       = time - start_time
+    avg        = get_closest(diff)
+    amin, asec = get_time_parts(avg)
+    m, s       = get_time_parts(diff)
+    colorize_if_should((avg == 0) ? "{#{m}:#{s}}(:time)" : get_avg_message(amin, asec, avg, diff, m, s))
+  end
+
+  def self.get_time_parts(time)
+    return (time / 60.0).floor, '%06.3f' % (time % 60)
+  end
+end

data/lib/mvn2/plugin.rb

@@ -0,0 +1,323 @@
+require 'everyday-cli-utils'
+include EverydayCliUtils
+import :maputil
+
+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 set_var(name, value)
+      @vars[name] = value
+    end
+
+    def self.get_var(name)
+      instance.get_var(name)
+    end
+
+    def self.set_var(name, value)
+      instance.set_var(name, value)
+    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
+  class DefaultTypes
+    extend Mvn2::PluginType
+
+    register_variable :options
+    register_variable :result
+    register_variable :runner
+    register_variable :cmd
+    register_variable :cmd_clean
+    register_variable :message_text
+
+    register_type(:option) { |list, options|
+      list.sort_by { |v| v[:options][:sym].to_s }.each { |option|
+        id      = option[:options].delete(:sym)
+        names   = option[:options].delete(:names)
+        default = option[:options].delete(:default) || nil
+        options.option id, names, option[:options]
+        options.default_options id => default unless default.nil?
+      }
+    }
+
+    register_type(:option_with_param) { |list, options|
+      list.sort_by { |v| v[:options][:sym].to_s }.each { |option|
+        id      = option[:options].delete(:sym)
+        names   = option[:options].delete(:names)
+        default = option[:options].delete(:default) || nil
+        options.option_with_param id, names, option[:options]
+        options.default_options id => default unless default.nil?
+      }
+    }
+
+    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
+    }
+
+    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) }
+    }
+
+    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) }
+    }
+
+    register_type(:log_file_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
+    }
+
+    register_type(:log_file_disable) { |list|
+      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)
+        else
+          item[:block].call(options)
+        end
+      }
+    }
+
+    register_type(:log_file_enable) { |list|
+      if Mvn2::Plugins.get(:log_file_name).nil? || Mvn2::Plugins.get(:log_file_disable)
+        false
+      else
+        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)
+          else
+            item[:block].call(options)
+          end
+        }
+      end
+    }
+
+    register_type(:line_filter) { |list, line|
+      options = Mvn2::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
+    }
+
+    register_type(:runner_enable) { |list, key|
+      options = Mvn2::Plugins.get_var :options
+      list.select { |v| v[:options][:key] == key }.any? { |item|
+        if item[:block].nil?
+          item[:options].has_key?(:option) && options[item[:options][:option]] == (item[:options].has_key?(:value) ? item[:options][:value] : true)
+        else
+          item[:block].call(options)
+        end
+      }
+    }
+
+    register_type(:runner) { |list|
+      options = Mvn2::Plugins.get_var :options
+      cmd     = Mvn2::Plugins.get_var :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
+        end
+      }
+      Mvn2::Plugins.get_var :result
+    }
+
+    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|
+        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
+      }
+      if full_overrides.nil? || full_overrides.empty?
+        goals = list.select { |v| !v[:options][:override_all] }.sort_by { |v| v[:options][:order] }.filtermap { |item|
+          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
+        }
+        goals = ['install'] if (goals - ['clean']).empty?
+        goals = ['clean'] + goals unless goals.include?('clean')
+        goals.join(' ')
+      else
+        full_overrides.first
+      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'
+    }
+
+    DEFAULT_COLOR_OPTS = {
+        time:    {
+            fg: :green,
+            bg: :none,
+        },
+        percent: {
+            fg: :purple,
+            bg: :none,
+        },
+        average: {
+            fg: :cyan,
+            bg: :none,
+        },
+    }
+
+    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
+      }
+      opts.each { |opt| Format.color_profile opt[0], fgcolor: opt[1][:fg], bgcolor: opt[1][:bg] }
+    }
+  end
+end

data/lib/mvn2/version.rb

@@ -0,0 +1,3 @@
+module Mvn2
+  VERSION = '2.0.0'
+end

data/lib/mvn2.rb

@@ -0,0 +1 @@
+require 'mvn2/version'

data/mvn2.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+#noinspection RubyResolve
+require 'mvn2/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'mvn2'
+  spec.version     = Mvn2::VERSION
+  spec.authors     = ['Eric Henderson']
+  spec.email       = ['henderea@gmail.com']
+  spec.summary     = %q{Maven helper}
+  spec.description = %q{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}
+  spec.homepage    = 'https://github.com/henderea/mvn2'
+  spec.license     = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake', '~> 10.0'
+
+  spec.add_dependency 'everyday-cli-utils', '>= 1.3.0'
+  spec.add_dependency 'colorconfig', '>= 1.0.0'
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: mvn2
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- Eric Henderson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: everyday-cli-utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: colorconfig
+  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
+email:
+- henderea@gmail.com
+executables:
+- mvn2
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/mvn2
+- lib/mvn2.rb
+- lib/mvn2/plugin.rb
+- lib/mvn2/plugin/avg.plugin.rb
+- lib/mvn2/plugin/command.plugin.rb
+- lib/mvn2/plugin/default_runner.plugin.rb
+- lib/mvn2/plugin/exception.plugin.rb
+- lib/mvn2/plugin/filter.plugin.rb
+- lib/mvn2/plugin/growl.plugin.rb
+- lib/mvn2/plugin/live_print.plugin.rb
+- lib/mvn2/plugin/logging.plugin.rb
+- lib/mvn2/plugin/skip_tests.plugin.rb
+- lib/mvn2/plugin/timer.plugin.rb
+- lib/mvn2/version.rb
+- mvn2.gemspec
+homepage: https://github.com/henderea/mvn2
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: Maven helper
+test_files: []
+has_rdoc: