everyday-cli-utils 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f620a7c1e67d6366c45323874f2346bf710ce9b6
+  data.tar.gz: 96c78fb64efef0e03dc1bf26b6f1d8a9e7b2d49f
+SHA512:
+  metadata.gz: 5982ac1f4c14e8321e82b9b5c5d194226cd5721f08148d09d896c5d5e17edc6bd29ef450df64f3bc510988da0778a95822531829eff1fc20d3563c15f364564d
+  data.tar.gz: a54b86c5ca17e02dab387bfcf12550b2c32b34effa6b3d762e06ed124a891bb5980e3ca05da192445230064e41d87032d8e59573a20381cd413e9d2fd0c04f24

data/.coveralls.yml

@@ -0,0 +1,2 @@
+service_name: travis-ci
+repo_token: dLtsGeDKaRp2Jj9aynRpJ3Qx23AoJ3qaj

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/.rspec

@@ -0,0 +1,3 @@
+--color
+--format progress
+-rspec_helper

data/.travis.yml

@@ -0,0 +1,2 @@
+language: ruby
+gemfile: Gemfile.ci

data/Gemfile

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

data/Gemfile.ci

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'bundler', '~> 1.5'
+gem 'rake', '~> 10.0'
+gem 'simplecov', '>= 0.8.2'
+gem 'coveralls', '>= 0.7.0'
+gem 'rspec'

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,33 @@
+# EverydayCliUtils
+
+[![Build Status](https://travis-ci.org/henderea/everyday-cli-utils.png?branch=master)](https://travis-ci.org/henderea/everyday-cli-utils)
+[![Code Climate](https://codeclimate.com/github/henderea/everyday-cli-utils.png)](https://codeclimate.com/github/henderea/everyday-cli-utils)
+[![Coverage Status](https://coveralls.io/repos/henderea/everyday-cli-utils/badge.png?branch=master)](https://coveralls.io/r/henderea/everyday-cli-utils?branch=master)
+
+A set of CLI and general utilities.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'everyday-cli-utils'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install everyday-cli-utils
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( http://github.com/henderea/everyday-cli-utils/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/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/everyday-cli-utils.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'everyday-cli-utils/version'
+
+Gem::Specification.new do |spec|
+  spec.name     = 'everyday-cli-utils'
+  spec.version  = EverydayCliUtils::VERSION
+  spec.authors  = ['Eric Henderson']
+  spec.email    = ['henderea@gmail.com']
+  spec.summary  = %q{A few CLI utils}
+  spec.homepage = 'https://github.com/henderea/everyday-cli-utils'
+  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_development_dependency 'simplecov', '>= 0.8.2'
+  spec.add_development_dependency 'coveralls', '>= 0.7.0'
+  spec.add_development_dependency 'rspec'
+
+  spec.add_dependency 'curses'
+end

data/lib/everyday-cli-utils/ask.rb

@@ -0,0 +1,30 @@
+require 'readline'
+
+module EverydayCliUtils
+  module Ask
+    def self::setup_options(options)
+      mapped = []
+      options.each_with_index { |v, k|
+        mapped << "#{k+1}) #{v.to_s}"
+      }
+      mapped.join("\n")
+    end
+
+    def self::ask(question, options, &block)
+      val = '-1'
+      while true
+        print "#{question}\n\n#{setup_options(options)}\n\n"
+        val = Readline.readline("Please enter your choice (1 - #{options.count}): ", true)
+        if !(val =~ /^\d+$/).nil? && (1..options.count).include?(val.to_i)
+          break
+        end
+        print "\n\nYou must enter an integer between 1 and #{options.count}. Please try again.\n\n"
+      end
+      block.call(options[val.to_i - 1])
+    end
+
+    def self::hash_to_options(hash, extra = [])
+      hash.keys + extra
+    end
+  end
+end

data/lib/everyday-cli-utils/curses_utils.rb

@@ -0,0 +1,38 @@
+module CursesUtils
+  COLOR_TO_CURSES = {
+      :black  => Curses::COLOR_BLACK,
+      :red    => Curses::COLOR_RED,
+      :green  => Curses::COLOR_GREEN,
+      :yellow => Curses::COLOR_YELLOW,
+      :blue   => Curses::COLOR_BLUE,
+      :purple => Curses::COLOR_MAGENTA,
+      :cyan   => Curses::COLOR_CYAN,
+      :white  => Curses::COLOR_WHITE,
+      :none   => -1,
+  }
+
+  def find_color(bgcolor, fgcolor)
+    @colors.find_index { |v| v[0] == (fgcolor || :none) && v[1] == (bgcolor || :none) }
+  end
+
+  def add_color(bgcolor, fgcolor)
+    Curses::init_pair(@colors.count + 1, COLOR_TO_CURSES[fgcolor || :none], COLOR_TO_CURSES[bgcolor || :none])
+    ind = @colors.count + 1
+    @colors << [fgcolor || :none, bgcolor || :none]
+    ind
+  end
+
+
+  private
+  def handle_color(fgcolor, bgcolor)
+    return 0 if (fgcolor.nil? || fgcolor == :none) && (bgcolor.nil? || bgcolor == :none)
+    ind = find_color(bgcolor, fgcolor)
+    ind = ind.nil? ? add_color(bgcolor, fgcolor) : ind + 1
+    Curses::color_pair(ind)
+  end
+
+  def get_format(str)
+    bold, underline, fgcolor, bgcolor = Format::parse_format(str)
+    (bold ? Curses::A_BOLD : 0) | (underline ? Curses::A_UNDERLINE : 0) | handle_color(fgcolor, bgcolor)
+  end
+end

data/lib/everyday-cli-utils/format.rb

@@ -0,0 +1,128 @@
+module EverydayCliUtils
+  module Format
+    def self.build_format_hash(first_chr)
+      {
+          :black  => "#{first_chr}0",
+          :red    => "#{first_chr}1",
+          :green  => "#{first_chr}2",
+          :yellow => "#{first_chr}3",
+          :blue   => "#{first_chr}4",
+          :purple => "#{first_chr}5",
+          :cyan   => "#{first_chr}6",
+          :white  => "#{first_chr}7",
+          :none   => nil,
+      }
+    end
+
+    FORMAT_TO_CODE   = {
+        :bold      => '1',
+        :underline => '4',
+    }
+    FG_COLOR_TO_CODE = build_format_hash('3')
+    BG_COLOR_TO_CODE = build_format_hash('4')
+
+    def self::format(text, format_code)
+      (format_code.nil? || format_code == '') ? text : "\e[#{format_code}m#{text}\e[0m"
+    end
+
+    def self::build_string(bold, underline, fgcolor, bgcolor)
+      str      = ''
+      hit      = false
+      hit, str = handle_bold(bold, hit, str)
+      hit, str = handle_underline(hit, str, underline)
+      hit, str = handle_fg_color(fgcolor, hit, str)
+      handle_bg_color(bgcolor, hit, str)
+    end
+
+    def self.handle_bold(bold, hit, str)
+      if bold
+        hit = true
+        str = FORMAT_TO_CODE[:bold]
+      end
+      return hit, str
+    end
+
+    def self.handle_underline(hit, str, underline)
+      if underline
+        str += ';' if hit
+        hit = true
+        str += FORMAT_TO_CODE[:underline]
+      end
+      return hit, str
+    end
+
+    def self.handle_fg_color(fgcolor, hit, str)
+      unless fgcolor.nil? || FG_COLOR_TO_CODE[fgcolor].nil?
+        str += ';' if hit
+        hit = true
+        str += FG_COLOR_TO_CODE[fgcolor]
+      end
+      return hit, str
+    end
+
+    def self.handle_bg_color(bgcolor, hit, str)
+      unless bgcolor.nil? || BG_COLOR_TO_CODE[bgcolor].nil?
+        str += ';' if hit
+        str += BG_COLOR_TO_CODE[bgcolor]
+      end
+      str
+    end
+
+    def self::parse_format(str)
+      parts     = str.split(';')
+      bold      = false
+      underline = false
+      fgcolor   = :none
+      bgcolor   = :none
+      parts.each { |v|
+        if v == FORMAT_TO_CODE[:bold]
+          bold = true
+        elsif v == FORMAT_TO_CODE[:underline]
+          underline = true
+        elsif v[0] == '3'
+          fgcolor = FG_COLOR_TO_CODE.invert[v]
+        elsif v[0] == '4'
+          bgcolor = BG_COLOR_TO_CODE.invert[v]
+        end
+      }
+      return bold, underline, fgcolor, bgcolor
+    end
+
+    def self::colorize(text, fgcolor = nil, bgcolor = nil)
+      self::format(text, self::build_string(false, false, fgcolor, bgcolor))
+    end
+
+    def self::bold(text, fgcolor = nil, bgcolor = nil)
+      self::format(text, self::build_string(true, false, fgcolor, bgcolor))
+    end
+
+    def self::underline(text, fgcolor = nil, bgcolor = nil)
+      self::format(text, self::build_string(false, true, fgcolor, bgcolor))
+    end
+
+    def self::boldunderline(text, fgcolor = nil, bgcolor = nil)
+      self::format(text, self::build_string(true, true, fgcolor, bgcolor))
+    end
+  end
+end
+
+class String
+  alias :old_method_missing :method_missing
+  alias :old_respond_to? :respond_to?
+
+  def method_missing(method, *args)
+    name   = method.to_s
+    colors = 'black|red|green|yellow|blue|purple|cyan|white|none'
+    if (name =~ /format(_bold)?(_underline)?(?:_fg_(#{colors}))?(?:_bg_(#{colors}))?/).nil?
+      old_method_missing(method, *args)
+    else
+      EverydayCliUtils::Format::format(self, EverydayCliUtils::Format::build_string(!$1.nil?, !$2.nil?, $3.nil? ? nil : $3.to_sym, $4.nil? ? nil : $4.to_sym))
+    end
+  end
+
+  def respond_to?(method)
+    name   = method.to_s
+    colors = 'black|red|green|yellow|blue|purple|cyan|white|none'
+    (!(name =~ /format(_bold)?(_underline)?(?:_fg_(#{colors}))?(?:_bg_(#{colors}))?/).nil?) || old_respond_to?(method)
+  end
+end

data/lib/everyday-cli-utils/histogram.rb

@@ -0,0 +1,43 @@
+require_relative 'maputil'
+
+module EverydayCliUtils
+  class Histogram
+    def self.setup(collection, height, width)
+      mi     = collection.min
+      ma     = collection.max
+      diff   = ma - mi
+      step   = diff.to_f / (width.to_f - 1)
+      counts = Array.new(width, 0)
+      collection.each { |v| counts[((v - mi).to_f / step.to_f).floor] += 1 }
+      max_y = counts.max
+      lines = Array.new(height) { ' ' * width }
+      return counts, lines, max_y, mi, step
+    end
+
+    def self.add_graph(counts, height, lines, max_y, width)
+      (0...width).each { |i|
+        h = ((counts[i].to_f / max_y.to_f) * height.to_f).round
+        ((height - h)...height).each { |j|
+          lines[j][i] = '#'
+        }
+        if h == 0 && counts[i] > 0
+          lines[height - 1][i] = '_'
+        end
+      }
+    end
+
+    def self.add_averages(height, ks, lines, mi, step, width)
+      lines[height] = ' ' * width
+      ks.each { |v| lines[height][((v - mi) / step).to_i] = '|' }
+    end
+  end
+end
+
+module Enumerable
+  def histogram(ks = nil, width = 100, height = 50)
+    counts, lines, max_y, mi, step = EverydayCliUtils::Histogram.setup(self, height, width)
+    EverydayCliUtils::Histogram.add_graph(counts, height, lines, max_y, width)
+    EverydayCliUtils::Histogram.add_averages(height, ks, lines, mi, step, width) unless ks.nil?
+    lines
+  end
+end

data/lib/everyday-cli-utils/kmeans.rb

@@ -0,0 +1,154 @@
+require_relative 'maputil'
+
+module EverydayCliUtils
+  class Kmeans
+    def self.normal(x, avg, std)
+      exp = -(((x - avg) / std) ** 2.0) / 2.0
+      ((Math.exp(exp) / (std * Math.sqrt(2.0 * Math::PI))))
+    end
+
+    def self.f_test(clusters, means, cnt, avg)
+      cnt2 = clusters.count { |i| !i.empty? }
+      ev   = f_test_ev(avg, clusters, cnt2, means)
+      uv   = f_test_uv(clusters, cnt, cnt2, means)
+      (ev / uv)
+    end
+
+    def self.f_test_ev(avg, clusters, cnt2, means)
+      ev = 0.0
+      (0...means.count).each { |i| ev += clusters[i].empty? ? 0.0 : clusters[i].count * ((means[i] - avg) ** 2.0) }
+      ev / (cnt2 - 1.0)
+    end
+
+    def self.f_test_uv(clusters, cnt, cnt2, means)
+      uv = 0.0
+      (0...means.count).each { |i|
+        unless clusters[i].empty?
+          (0...clusters[i].count).each { |j|
+            uv += (clusters[i][j] - means[i]) * (clusters[i][j] - means[i])
+          }
+        end
+      }
+      uv / (cnt - cnt2)
+    end
+
+    def self.f_test2(clusters, means, cnt)
+      uv   = 0.0
+      cnt2 = clusters.count { |i| !i.empty? }
+      (0...means.count).each { |i| uv += f_test2_calc(clusters, i, means, uv) unless clusters[i].empty? }
+      (uv / (cnt - cnt2))
+    end
+
+    def self.f_test2_calc(clusters, i, means, uv)
+      tmp = 0.0
+      (0...clusters[i].count).each { |j|
+        tmp += (clusters[i][j] - means[i]) ** 2.0
+      }
+      tmp /= clusters[i].count
+      Math.sqrt(tmp)
+    end
+
+    def self.nmeans_setup_1(collection)
+      su  = collection.sum
+      cnt = collection.count
+      avg = su / cnt
+      ks1 = collection.kmeans(1)
+      return avg, cnt, ks1
+    end
+
+    def self.nmeans_setup_2(collection, avg, cnt, ks1)
+      cso = collection.get_clusters(ks1)
+      ft1 = f_test2(cso, ks1, cnt)
+      ks  = collection.kmeans(2)
+      cs  = collection.get_clusters(ks)
+      ft  = f_test(cs, ks, cnt, avg)
+      ft2 = f_test2(cs, ks, cnt)
+      return ft, ft1, ft2, ks
+    end
+
+    def self.run_nmean(collection, avg, cnt, ft, ft2, k, ks)
+      kso  = ks
+      fto  = ft
+      fto2 = ft2
+      ks   = collection.kmeans(k)
+      cs   = collection.get_clusters(ks)
+      ft   = f_test(cs, ks, cnt, avg)
+      ft2  = f_test2(cs, ks, cnt)
+      return ft, ft2, fto, fto2, ks, kso
+    end
+
+    def self.run_nmeans(avg, cnt, collection, ft, ft1, ft2, ks, ks1, max_k, threshold)
+      (3..[max_k, cnt].min).each { |k|
+        ft, ft2, fto, fto2, ks, kso = run_nmean(collection, avg, cnt, ft, ft2, k, ks)
+        return kso if ((ft - fto) / fto) < threshold && fto2 < ft1
+      }
+      ft2 >= ft1 ? ks1 : ks
+    end
+
+    def self.run_kmean(collection, ks)
+      kso      = ks
+      clusters = collection.get_clusters(kso)
+      ks       = []
+      clusters.each_with_index { |val, key| ks[key] = (val.count <= 0) ? kso[key] : (val.sum / val.count) }
+      ks.sort
+      return kso, ks
+    end
+  end
+end
+
+module Enumerable
+  def outliers(sensitivity = 0.5, k = nil)
+    ks = k.nil? ? nmeans : kmeans(k)
+    cs = get_clusters(ks)
+
+    outliers = []
+
+    ks.each_with_index { |avg, i| outliers += find_outliers(avg, cs, i, sensitivity) }
+    outliers
+  end
+
+  def find_outliers(avg, cs, i, sensitivity)
+    csi = cs[i]
+    std = csi.std_dev
+    cnt = csi.count
+    csi.select { |c| (EverydayCliUtils::Kmeans.normal(c, avg, std) * cnt) < sensitivity }
+  end
+
+  def nmeans(max_k = 10, threshold = 0.05)
+    collection    = self.floats
+    avg, cnt, ks1 = EverydayCliUtils::Kmeans.nmeans_setup_1(collection)
+    return ks1 if cnt == 1
+    ft, ft1, ft2, ks = EverydayCliUtils::Kmeans.nmeans_setup_2(collection, avg, cnt, ks1)
+    EverydayCliUtils::Kmeans.run_nmeans(avg, cnt, collection, ft, ft1, ft2, ks, ks1, max_k, threshold)
+  end
+
+  def kmeans(k)
+    mi   = min
+    ma   = max
+    diff = ma - mi
+    ks   = []
+    (1..k).each { |i| ks[i - 1] = mi + (i * (diff / (k + 1.0))) }
+    kso = false
+    while ks != kso
+      kso, ks = EverydayCliUtils::Kmeans.run_kmean(self, ks)
+    end
+    ks
+  end
+
+  def get_clusters(means)
+    clusters = Array.new(means.count) { Array.new }
+    each { |item|
+      cluster  = false
+      distance = false
+      (0...means.count).each { |i|
+        diff = (means[i] - item).abs
+        if distance == false || diff < distance
+          cluster  = i
+          distance = diff
+        end
+      }
+      clusters[cluster][clusters[cluster].count] = item
+    }
+    clusters
+  end
+end

data/lib/everyday-cli-utils/maputil.rb

@@ -0,0 +1,48 @@
+module Enumerable
+  def removefalse
+    select { |i| i }
+  end
+
+  def filtermap(&block)
+    map(&block).removefalse
+  end
+
+  def sum
+    reduce(:+)
+  end
+
+  def prod
+    reduce(:*)
+  end
+
+  def average
+    sum.to_f / count.to_f
+  end
+
+  def std_dev
+    avg = average
+    cnt = count.to_f
+    su  = summap { |v| (v.to_f - avg.to_f) ** 2 }
+    Math.sqrt(su / cnt)
+  end
+
+  def floats
+    map(&:to_f)
+  end
+
+  def summap(&block)
+    map(&block).sum
+  end
+
+  def productmap(&block)
+    map(&block).prod
+  end
+
+  def chompall
+    map(&:chomp)
+  end
+
+  def join(join_str)
+    map(&:to_s).reduce { |a, b| a << join_str << b }
+  end
+end

data/lib/everyday-cli-utils/mycurses.rb

@@ -0,0 +1,199 @@
+require 'curses'
+require_relative 'format'
+require_relative 'curses_utils'
+
+module EverydayCliUtils
+  class MyCurses
+    include CursesUtils
+    #region External
+    def initialize(use_curses, linesh, linesf)
+      @use_curses = use_curses
+      @linesh     = linesh
+      @linesf     = linesf
+      @colors     = []
+      @headers    = []
+      @bodies     = []
+      @footers    = []
+      @cur_l      = 0
+      @max_l      = 0
+      @ch         = nil
+      setup_curses(linesf, linesh) if @use_curses
+    end
+
+    def setup_curses(linesf, linesh)
+      Curses::noecho
+      Curses::init_screen
+      @subpad_start = linesh
+      update_subpad_size
+      @padh = Curses::Pad.new(linesh, Curses::cols)
+      @padb = Curses::Pad.new(Curses::lines - linesh - linesf, Curses::cols)
+      @padf = Curses::Pad.new(linesf, Curses::cols)
+      configure_curses
+    end
+
+    def configure_curses
+      @padh.keypad(true)
+      @padh.clear
+      @padh.nodelay = true
+      @padb.keypad(true)
+      @padb.clear
+      @padb.nodelay = true
+      @padf.keypad(true)
+      @padf.clear
+      @padf.nodelay = true
+      Curses::cbreak
+      Curses::start_color
+      Curses::use_default_colors
+    end
+
+    def clear
+      @headers = []
+      @bodies  = []
+      @footers = []
+    end
+
+    def myprints
+      @use_curses ? print_curses : print_normal
+    end
+
+    def print_normal
+      @headers.each { |v| puts v }
+      @bodies.each { |v| puts v }
+      @footers.each { |v| puts v }
+    end
+
+    def print_curses
+      resize_curses
+      myprint(@headers.join("\n"), @padh)
+      myprint(@bodies.join("\n"), @padb)
+      myprint(@footers.join("\n"), @padf)
+      update_max_l
+      @cur_l = [@cur_l, @max_l].min
+      padh_refresh
+      padb_refresh
+      padf_refresh
+    end
+
+    def resize_curses
+      @padh.resize(@headers.count, Curses::cols)
+      @padb.resize(@bodies.count, Curses::cols)
+      @padf.resize(@footers.count, Curses::cols)
+      @padh.clear
+      @padb.clear
+      @padf.clear
+      @padh.setpos(0, 0)
+      @padb.setpos(0, 0)
+      @padf.setpos(0, 0)
+    end
+
+    def read_ch
+      @ch = @padf.getch
+    end
+
+    def clear_ch
+      read_ch
+      while @ch == 10 || @ch == Curses::Key::ENTER || @ch == Curses::Key::UP || @ch == Curses::Key::DOWN
+        read_ch
+      end
+    end
+
+    def scroll_iteration
+      old_subpad_size = @subpad_size
+      update_subpad_size
+      update_max_l
+      update_scroll(@subpad_size != old_subpad_size)
+      sleep(0.05)
+      read_ch
+    end
+
+    def header_live_append(str)
+      @padh << str
+      padh_refresh
+    end
+
+    def body_live_append(str)
+      @padb << str
+      padb_refresh
+    end
+
+    def footer_live_append(str)
+      @padf << str
+      padf_refresh
+    end
+
+    def dispose
+      Curses::close_screen if @use_curses
+    end
+
+    #endregion
+
+    #region Internal
+    def myputs(text, pad)
+      myprint("#{text}\n", pad)
+    end
+
+    def myprint(text, pad)
+      if @use_curses
+        if text.include?("\e")
+          pieces = text.scan(/#{"\e"}\[(.+?)m([^#{"\e"}]+?)#{"\e"}\[0m|([^#{"\e"}]+)/)
+          pieces.each { |v|
+            if v[2].nil?
+              pad.attron(get_format(v[0])) {
+                pad << v[1]
+              }
+            else
+              pad << v[2]
+            end
+          }
+        else
+          pad << text
+        end
+      else
+        print text
+      end
+    end
+
+    def update_max_l
+      @max_l = [0, @bodies.count - @subpad_size].max
+    end
+
+    def update_subpad_size
+      Curses::refresh
+      @subpad_size = Curses::lines - @linesh - @linesf
+    end
+
+    def padh_refresh
+      @padh.refresh(0, 0, 0, 0, @subpad_start - 1, Curses::cols - 1)
+    end
+
+    def padb_refresh
+      @padb.refresh(@cur_l, 0, @subpad_start, 0, @subpad_start + @subpad_size - 1, Curses::cols - 1)
+    end
+
+    def padf_refresh
+      @padf.refresh(0, 0, @subpad_start + [@subpad_size, @bodies.count].min, 0, @subpad_start + [@subpad_size, @bodies.count].min + @footers.count, Curses::cols - 1)
+    end
+
+    def update_scroll(force_refresh = false)
+      if @ch == Curses::Key::UP
+        @cur_l = [0, @cur_l - 1].max
+      elsif @ch == Curses::Key::DOWN
+        @cur_l = [@max_l, @cur_l + 1].min
+      end
+      @cur_l = [@cur_l, @max_l].min
+      if @ch == Curses::Key::UP || @ch == Curses::Key::DOWN || force_refresh
+        Curses::refresh
+        padh_refresh
+        padb_refresh
+        padf_refresh
+      end
+      @cur_l
+    end
+
+    #endregion
+
+    attr_reader :ch
+    attr_accessor :bodies, :headers, :footers
+    private :myputs, :myprint, :update_max_l, :update_subpad_size, :padh_refresh, :padb_refresh, :padf_refresh, :update_scroll
+  end
+end

data/lib/everyday-cli-utils/option.rb

@@ -0,0 +1,21 @@
+module EverydayCliUtils
+  class Option
+    def self.add_option(options, opts, names, opt_name, settings = {})
+      opts.on(*names) {
+        options[opt_name] = !settings[:toggle] || !options[opt_name]
+        yield if block_given?
+      }
+    end
+
+    def self.add_option_with_param(options, opts, names, opt_name, settings = {})
+      opts.on(*names, settings[:type] || String) { |param|
+        if settings[:append]
+          options[opt_name] << param
+        else
+          options[opt_name] = param
+        end
+        yield if block_given?
+      }
+    end
+  end
+end

data/lib/everyday-cli-utils/version.rb

@@ -0,0 +1,3 @@
+module EverydayCliUtils
+  VERSION = '0.0.2'
+end

data/lib/everyday-cli-utils.rb

@@ -0,0 +1,5 @@
+require_relative 'everyday-cli-utils/version'
+
+module EverydayCliUtils
+  # Your code goes here...
+end

data/spec/everyday-cli-utils/format_spec.rb

@@ -0,0 +1,62 @@
+require_relative '../../lib/everyday-cli-utils/format'
+
+def extract_format(text)
+  (text.scan(/#{"\e"}\[(.+?)m([^#{"\e"}]+?)#{"\e"}\[0m|([^#{"\e"}]+)/))[0][0]
+end
+
+describe EverydayCliUtils::Format do
+  it 'adds formatting methods to String' do
+    str = 'hi'
+    str.respond_to?(:format_bold_underline_fg_yellow_bg_green).should be_true
+    str.respond_to?(:format_underline_bg_green).should be_true
+  end
+
+  it 'does the same formatting in the String methods and the Format methods' do
+    str        = 'hi'
+    format_str = EverydayCliUtils::Format.boldunderline(str, :yellow, :green)
+    string_str = str.format_bold_underline_fg_yellow_bg_green
+    format_str.should eq string_str
+  end
+
+  it 'can parse a format it creates' do
+    str                               = 'hi'
+    format_str                        = EverydayCliUtils::Format.bold(str, :yellow, :green)
+    piece                             = extract_format(format_str)
+    bold, underline, fgcolor, bgcolor = EverydayCliUtils::Format.parse_format(piece)
+    bold.should be_true
+    underline.should be_false
+    fgcolor.should eq :yellow
+    bgcolor.should eq :green
+
+    format_str                        = EverydayCliUtils::Format.underline(str, :yellow, :green)
+    piece                             = extract_format(format_str)
+    bold, underline, fgcolor, bgcolor = EverydayCliUtils::Format.parse_format(piece)
+    bold.should be_false
+    underline.should be_true
+    fgcolor.should eq :yellow
+    bgcolor.should eq :green
+
+    format_str                        = EverydayCliUtils::Format.colorize(str, :yellow, :green)
+    piece                             = extract_format(format_str)
+    bold, underline, fgcolor, bgcolor = EverydayCliUtils::Format.parse_format(piece)
+    bold.should be_false
+    underline.should be_false
+    fgcolor.should eq :yellow
+    bgcolor.should eq :green
+
+    format_str                        = EverydayCliUtils::Format.boldunderline(str, :yellow, :green)
+    piece                             = extract_format(format_str)
+    bold, underline, fgcolor, bgcolor = EverydayCliUtils::Format.parse_format(piece)
+    bold.should be_true
+    underline.should be_true
+    fgcolor.should eq :yellow
+    bgcolor.should eq :green
+  end
+
+  it 'still works with the default String method_missing and respond_to?' do
+    str = 'hi'
+    str.respond_to?(:split).should be_true
+    str.respond_to?(:hi).should be_false
+    expect { str.hi }.to raise_error(NameError)
+  end
+end

data/spec/everyday-cli-utils/kmeans_spec.rb

@@ -0,0 +1,24 @@
+require_relative '../../lib/everyday-cli-utils/kmeans'
+
+describe EverydayCliUtils::Kmeans do
+  it 'finds the right clusters in simple data' do
+    arr    = [100, 200, 99, 400, 98, 201, 101, 405, 102]
+    nmeans = arr.nmeans
+    nmeans.count.should eq 3
+    nmeans.should eq [100, 200.5, 402.5]
+  end
+
+  it 'limits number of clusters found' do
+    arr    = (1..50).to_a.map { |v| (v * (101-v)) ** 2 }
+    nmeans = arr.nmeans(5)
+    nmeans.count.should eq 5
+    nmeans = arr.nmeans(3)
+    nmeans.count.should eq 3
+  end
+
+  it 'finds outliers in simple data' do
+    arr      = [100, 200, 99, 400, 98, 201, 101, 405, 102]
+    outliers = arr.outliers
+    outliers.should eq [400.0, 405.0]
+  end
+end

data/spec/everyday-cli-utils/maputil_spec.rb

@@ -0,0 +1,62 @@
+require_relative '../../lib/everyday-cli-utils/maputil'
+
+describe 'maputil' do
+  it 'provides a shortcut for removing false values from a list' do
+    arr = [0, false, false, 3, 4, false, 6, false, 8, 9]
+    arr.removefalse.should eq [0, 3, 4, 6, 8, 9]
+  end
+
+  it 'allows a filtered mapping' do
+    arr  = (0..9).to_a
+    arr2 = arr.filtermap { |v| v % 3 == 0 ? false : v ** 2 }
+    arr2.should eq [1, 4, 16, 25, 49, 64]
+  end
+
+  it 'provides a shortcut for summing the values of an list' do
+    arr = (0..9).to_a
+    sum = arr.sum
+    sum.should eq 45
+  end
+
+  it 'provides a shortcut for calculating the product of the values of an list' do
+    arr  = (1..4).to_a
+    prod = arr.prod
+    prod.should eq 24
+  end
+
+  it 'provides a shortcut for calculating the average of the values of an list' do
+    arr = (0..9).to_a
+    avg = arr.floats.average
+    avg.should eq 4.5
+  end
+
+  it 'provides a shortcut for calculating the standard deviation of the values of an list' do
+    arr     = (0..9).to_a.floats
+    std_dev = arr.std_dev
+    std_dev.should eq Math.sqrt(8.25)
+  end
+
+  it 'provides a shortcut for calculating the sum of a mapped list' do
+    arr    = (0..9).to_a
+    summap = arr.summap { |v| v ** 2 }
+    summap.should eq 285
+  end
+
+  it 'provides a shortcut for calculating the product of a mapped list' do
+    arr     = (1..4).to_a
+    prodmap = arr.productmap { |v| v + 1 }
+    prodmap.should eq 120
+  end
+
+  it 'provides a shortcut to remove newlines from all strings in a list' do
+    arr = (0..9).to_a.map { |v| "#{v}\n" }
+    arr.should eq %W(0\n 1\n 2\n 3\n 4\n 5\n 6\n 7\n 8\n 9\n)
+    arr.chompall.should eq %w(0 1 2 3 4 5 6 7 8 9)
+  end
+
+  it 'provides a shortcut to join elements in a list' do
+    list   = ('a'..'f')
+    joined = list.join('-')
+    joined.should eq 'a-b-c-d-e-f'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'coveralls'
+Coveralls.wear!

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: everyday-cli-utils
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Eric Henderson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-23 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: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: curses
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- henderea@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".coveralls.yml"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.ci
+- LICENSE.txt
+- README.md
+- Rakefile
+- everyday-cli-utils.gemspec
+- lib/everyday-cli-utils.rb
+- lib/everyday-cli-utils/ask.rb
+- lib/everyday-cli-utils/curses_utils.rb
+- lib/everyday-cli-utils/format.rb
+- lib/everyday-cli-utils/histogram.rb
+- lib/everyday-cli-utils/kmeans.rb
+- lib/everyday-cli-utils/maputil.rb
+- lib/everyday-cli-utils/mycurses.rb
+- lib/everyday-cli-utils/option.rb
+- lib/everyday-cli-utils/version.rb
+- spec/everyday-cli-utils/format_spec.rb
+- spec/everyday-cli-utils/kmeans_spec.rb
+- spec/everyday-cli-utils/maputil_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/henderea/everyday-cli-utils
+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: A few CLI utils
+test_files:
+- spec/everyday-cli-utils/format_spec.rb
+- spec/everyday-cli-utils/kmeans_spec.rb
+- spec/everyday-cli-utils/maputil_spec.rb
+- spec/spec_helper.rb
+has_rdoc: