theusual 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4d35f965de136645227b101c3dbc948e09f69704
+  data.tar.gz: 24cfeec64ea6e738575d21ca496d07c4619e224d
+SHA512:
+  metadata.gz: ccebdfa7247d0e2ff714f7762bc9f1bc9d7f1c6c26d0ca380edc3a1e1c269cd1bd47b5b82cb0e7aa4d301c354900225bfbd0d7b5e9b52642d5442e4b482d202f
+  data.tar.gz: 11881d146b47a2d59814c0ee5e967159487a7ebc73865e920f8c38814d85035ad9747e2eabd16527e94e56f97c632f5ce27dfbfe80052242643ea371ec4a20db

data/lib/theusual.rb

@@ -0,0 +1,41 @@
+module TheUsual
+  VERSION = '0.0.1'
+
+  MODULES = [
+    'array',
+    'hash',
+    'ipaddr',
+    'mongoid',
+    'net/ssh',
+    'time',
+  ]
+
+  def self.load *modules
+    # some modules need to be explicitly required
+    needs_load = [
+      'ipaddr',
+      'mongoid',
+      'net/ssh',
+    ]
+
+    # some of our filenames need to be remapped
+    paths = {
+      'net/ssh' => 'ssh',
+    }
+
+    raise ArgumentError if modules.empty?
+
+    modules = MODULES if [:all, 'all', '*'].include? modules.first
+
+    modules.flatten.map(&:to_s).each do |_module|
+      raise ArgumentError unless MODULES.include? _module
+
+      # load standard lib
+      require _module if needs_load.include? _module
+
+      # monkey patch
+      name = paths[_module] || _module
+      require_relative "theusual/#{name}.rb"
+    end
+  end
+end

data/lib/theusual/array.rb

@@ -0,0 +1,80 @@
+class Array
+  #####  Numerical Operations  #####
+  def sum
+    numerics?
+    inject 0, &:+
+  end
+  alias_method :total, :sum
+
+
+  def avg
+    numerics?
+    return Float::NAN if empty?
+
+    map(&:to_f).sum / count
+  end
+  alias_method :average, :avg
+  alias_method :mean, :avg
+
+
+  def std
+    numerics?
+    return Float::NAN if empty?
+
+    mean = avg
+
+    Math.sqrt(
+        map { |sample| (mean - sample.to_f) ** 2 }.reduce(:+) / count.to_f
+    )
+  end
+  alias_method :standard_deviation, :std
+
+
+  #####  String Operations  #####
+  def grepv regex
+    reject { |elem| elem =~ regex }
+  end
+
+
+  def gsub(regex, replacement)
+    map { |string| string.gsub(regex, replacement) }
+  end
+
+  def gsub!(regex, replacement)
+    map! { |string| string.gsub(regex, replacement) }
+  end
+
+
+  #####  Misc Operations  #####
+  def compact(modifier = nil)
+    falsy = modifier == :falsy
+    blanks = falsy || modifier == :blanks
+
+    reject do |v|
+      isblank = blanks && v.respond_to?(:empty?) && v.empty?
+      isfalsy = falsy && (v == 0)
+
+      !v || isblank || isfalsy
+    end
+  end
+
+  def compact!(modifier = nil)
+    res = compact(modifier)
+    clear
+
+    # TODO: is there a better way than shift/reverse?
+    res.each {|x| unshift x}
+    reverse!
+  end
+
+
+  private
+
+  def numerics?
+    # make sure values are all Numeric or numbers within strings
+    map do |x|
+      Float(x)
+    end
+  end
+
+end

data/lib/theusual/hash.rb

@@ -0,0 +1,136 @@
+class Hash
+
+  class << self
+
+    # map any Enumerable into a Hash, like Hash[obj.map ... ]
+    def map(obj, &block)
+      Hash[
+        obj.map do |*args|
+          block.call *args
+        end.compact
+      ]
+    end
+
+  end # class << self
+
+
+  def select_keys(*keys)
+    if keys.length == 1 and keys.first.class < Enumerable
+      keys = keys.first
+    end
+
+    Hash.map keys do |k|
+      [ k, self[k] ]
+    end
+  end
+
+  def select_keys!(*keys)
+    replace select_keys *keys
+  end
+
+
+  def compact(modifier = nil)
+    falsy = modifier == :falsy
+    blanks = falsy || modifier == :blanks
+
+    reject do |k, v|
+      isblank = blanks && v.respond_to?(:empty?) && v.empty?
+      isfalsy = falsy && (v == 0)
+
+      !v || isblank || isfalsy
+    end
+  end
+
+  def compact!(modifier = nil)
+    replace compact(modifier)
+  end
+
+
+  # map the block's results back to a hash
+  def hmap(&block)
+    Hash[ map {|k, v| block.call(k, v) }.compact ]
+  end
+
+  def hmap!(&block)
+    replace hmap &block
+  end
+
+
+  # map keys, but preserve associated values
+  # ie. http://apidock.com/rails/v4.2.7/Hash/transform_keys
+  def kmap(&block)
+    Hash[map do |k, v|
+      [ block.arity == 1 ? block.call(k) : block.call(k, v), v ]
+    end]
+
+  end
+
+  def kmap!(&block)
+    replace kmap &block
+  end
+
+
+  # map values, but preserve associated keys
+  # ie. http://apidock.com/rails/v4.2.7/Hash/transform_values
+  def vmap(&block)
+    Hash[map do |k, v|
+      [ k, block.arity == 1 ? block.call(v) : block.call(k, v) ]
+    end]
+  end
+
+  def vmap!(&block)
+    replace vmap &block
+  end
+
+
+  # sort by key values, for pretty printing
+  def ksort(&block)
+    Hash[
+      sort_by do |k, v|
+        if block
+          yield k
+        else
+          k
+        end
+      end
+    ]
+  end
+
+  def ksort!(&block)
+    replace ksort &block
+  end
+
+
+  def vsort(&block)
+    Hash[
+      sort_by do |k, v|
+        if block
+          yield v
+        else
+          v
+        end
+      end
+    ]
+  end
+
+  def vsort!(&block)
+    replace vsort &block
+  end
+
+
+  # set like operator
+  def -(other)
+    raise TypeError unless other.class <= Hash
+    select {|k,v| !other.has_key? k}
+  end
+
+
+  private
+
+  # replace contents of hash with new stuff
+  def replace(hash)
+    clear
+    merge! hash
+  end
+
+end

data/lib/theusual/ipaddr.rb

@@ -0,0 +1,54 @@
+class IPAddr
+  class << self
+    # eg. 8.8.8 => 8.8.8.0/24
+    def new(addr = '::', family = Socket::AF_UNSPEC)
+      # already an IPAddr, so simply return a clone
+      return addr.clone if addr.is_a? IPAddr
+
+      addr ||= '::'
+      if addr == '::'
+        family = Socket::AF_INET6
+      elsif !addr.inspect.include? '/'
+        addr = addr.to_s
+        count = addr.split('.').count
+        if (1..3).include? count
+          # given a shortened addr...kindly reformat
+          addr = case count
+          when 3
+            addr + '.0/24'
+          when 2
+            addr + '.0.0/16'
+          when 1
+            addr + '.0.0.0/8'
+          end
+        end
+      end
+
+      super addr, family
+    end
+  end
+
+
+  # eg. 8.8.8.8/24 => 8.8.8
+  def short(size = nil)
+    if ipv4?
+      unless size
+        mask = inspect.split('/')[1].chomp('>')
+        size = 8 * mask.split('.').select {|x| x == '255'}.count
+      end
+
+      case size
+      when 32
+        to_s
+      when 24
+        to_s.split('.').first(3).join('.')
+      when 16
+        to_s.split('.').first(2).join('.')
+      when 8
+        to_s.split('.').first
+      else
+        to_s
+      end
+    end
+  end
+end

data/lib/theusual/mongoid.rb

@@ -0,0 +1,37 @@
+if defined? Mongoid
+
+  module Mongoid::Document
+    alias :as_doc :as_document
+  end
+
+  class Mongoid::Criteria
+    def as_doc
+      to_a.map &:as_doc
+    end
+    alias_method :as_docs, :as_doc
+
+    # can't seem to override Mongoid::Document::last, so put this
+    # functionality here
+    def last(n = 1)
+      order(_id: -1).limit(n)
+    end
+
+    # see http://apidock.com/rails/ActiveRecord/Batches/find_in_batches
+    def find_in_batches(opts = {}, &block)
+      batch_size = opts[:batch_size] || 1000
+      offset = opts[:start] || 0
+
+      loop do
+        docs = skip(offset).limit(batch_size).to_a
+
+        if docs.empty?
+          break
+        else
+          yield docs
+          offset += batch_size
+        end
+      end
+    end
+  end
+
+end

data/lib/theusual/ssh.rb

@@ -0,0 +1,53 @@
+# Most of this code was copied from:
+# http://www.rubydoc.info/github/net-ssh/net-ssh/Net/SSH/Connection/Session
+
+if defined? Net::SSH
+
+  class Net::SSH::Connection::Session
+
+      # use a psuedo TTY so we can run sudo commands on more secured cloud instances
+      def suexec(command, &block)
+        open_channel do |channel|
+          channel.request_pty
+
+          # add sudo prefix if need be
+          command = "sudo #{command}" unless /^sudo /.match command
+
+          channel.exec(command) do |ch, success|
+            raise "could not execute command: #{command.inspect}" unless success
+
+            channel.on_data do |ch2, data|
+              if block
+                block.call(ch2, :stdout, data)
+              else
+                $stdout.print(data)
+              end
+            end
+
+            channel.on_extended_data do |ch2, type, data|
+              if block
+                block.call(ch2, :stderr, data)
+              else
+                $stderr.print(data)
+              end
+            end
+          end
+        end
+      end
+
+
+      def suexec!(command, &block)
+        block ||= Proc.new do |ch, type, data|
+          ch[:result] ||= ""
+          ch[:result] << data
+        end
+
+        channel = suexec(command, &block)
+        channel.wait
+
+        return channel[:result]
+      end
+
+  end
+
+end

data/lib/theusual/time.rb

@@ -0,0 +1,19 @@
+class Time
+  def humanize
+    a = (Time.now.utc - self.utc).to_i
+
+    case a
+      when 0 then 'just now'
+      when 1 then 'a second ago'
+      when 2..59 then a.to_s + ' seconds ago'
+      when 60..119 then 'a minute ago' #120 = 2 minutes
+      when 120..3540 then (a / 60).to_i.to_s + ' minutes ago'
+      when 3541..7100 then 'an hour ago' # 3600 = 1 hour
+      when 7101..82800 then ((a + 99) / 3600).to_i.to_s + ' hours ago'
+      when 82801..172000 then 'a day ago' # 86400 = 1 day
+      when 172001..518400 then ((a + 800) / (60 * 60 * 24)).to_i.to_s + ' days ago'
+      when 518400..1036800 then 'a week ago'
+      else ((a+180000)/(60*60*24*7)).to_i.to_s + ' weeks ago'
+    end
+  end
+end

data/test/test_array.rb

@@ -0,0 +1,121 @@
+require 'minitest/autorun'
+require 'theusual'
+TheUsual::load 'array'
+
+
+class ArrayTest < Minitest::Test
+
+  def test_sum
+    assert_equal(
+      6,
+      [1,2,3].sum
+    )
+  end
+
+  def test_avg
+    assert_equal(
+      2,
+      [1,2,3].avg
+    )
+
+    assert_equal(
+      2.5,
+      [1,2,3,4].avg
+    )
+  end
+
+  def test_std
+    # TODO
+  end
+
+  def test_grepv
+    data = ['a', 'ab', 'bab', 'bbb', 'ccc'].sort
+
+    assert_equal(
+      ['a', 'ab', 'bab'].sort,
+      data.grep(/a/).sort
+    )
+
+    assert_equal(
+      ['bbb', 'ccc'],
+      data.grepv(/a/).sort
+    )
+  end
+
+  def test_gsub
+    assert_equal(
+      ['a_a', '_a_'],
+      ['aba', 'bab'].gsub(/b/, '_')
+    )
+
+    assert_equal(
+      ['a__A'],
+      ['abBA'].gsub(/b/i, '_')
+    )
+
+    res = ['aba']
+    assert_equal(
+      ['a_a'],
+      res.gsub!(/b/, '_')
+    )
+    assert_equal(
+      ['a_a'],
+      res
+    )
+  end
+
+  def test_compact
+    assert_equal(
+      [0, true, 'hi'],
+      [0, true, 'hi'].compact
+    )
+
+    assert_equal(
+      [0, ''],
+      [nil, 0, false, ''].compact
+    )
+
+    assert_equal(
+      [0],
+      [nil, 0, false, ''].compact(:blanks)
+    )
+
+    assert_equal(
+      [],
+      [nil, 0, false, ''].compact(:falsy)
+    )
+
+    assert_equal(
+      [1, 'a'],
+      [nil, 0, false, '', 1, 'a'].compact(:falsy)
+    )
+
+    data = [nil, 0, false, '', 1, 'a']
+    assert_equal(
+      [1, 'a'],
+      data.compact!(:falsy)
+    )
+    assert_equal(
+      [1, 'a'],
+      data.compact!(:falsy)
+    )
+  end
+
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/test/test_hash.rb

@@ -0,0 +1,350 @@
+require 'minitest/autorun'
+require 'theusual'
+TheUsual::load 'hash'
+
+
+class HashTest < Minitest::Test
+
+  def test_Hash
+    data = {
+      c: 2,
+      b: 3,
+      a: 1,
+    }
+
+    assert_equal(
+      data,
+      Hash.map(data.keys) {|x| [x, data[x]]}
+    )
+
+    assert_equal(
+      {},
+      Hash.map([]) {|x| nil}
+    )
+
+    assert_equal(
+      {},
+      Hash.map([1,2,3]) {|x| nil}
+    )
+
+    assert_equal(
+      {nil => 3},
+      Hash.map([1,2,3]) {|x| [nil, x]}
+    )
+  end
+
+
+  def test_select_keys
+    data = {
+      c: 2,
+      b: 3,
+      a: 1,
+    }
+
+    assert_equal(
+      {c: 2, a: 1},
+      data.select_keys(:c, :a)
+    )
+
+    assert_equal(
+      {c: 2, a: 1},
+      data.select_keys([:c, :a])
+    )
+
+    assert_equal(
+      {c: 2, z: nil},
+      data.select_keys(:c, :z)
+    )
+
+
+    assert_equal(
+      {c: 2, a: 1},
+      data.select_keys!(:c, :a)
+    )
+    assert_equal(
+      {c: 2, a: 1},
+      data
+    )
+  end
+
+
+  def test_compact
+    data = {
+      a: nil,
+      b: 'b',
+      c: false,
+      d: '',
+      e: 0,
+    }
+
+    assert_equal(
+      {
+        b: 'b',
+        d: '',
+        e: 0,
+      },
+      data.compact
+    )
+
+    assert_equal(
+      {
+        b: 'b',
+        e: 0,
+      },
+      data.compact(:blanks)
+    )
+
+    assert_equal(
+      {b: 'b'},
+      data.compact(:falsy)
+    )
+
+    assert_equal(
+      {b: 'b'},
+      data.compact!(:falsy)
+    )
+    assert_equal(
+      {b: 'b'},
+      data
+    )
+  end
+
+
+  def test_hmap
+    data = {
+      c: 2,
+      b: 3,
+      a: 1,
+    }
+
+    assert_equal(
+      {
+        c: 4,
+        b: 6,
+        a: 2,
+      },
+      data.hmap {|k,v| [k, v * 2]}
+    )
+
+    assert_equal(
+      {
+        cc: 4,
+        bb: 6,
+        aa: 2,
+      },
+      data.hmap {|k,v| [(k.to_s * 2).to_sym, v * 2]}
+    )
+
+    assert_equal(
+      {},
+      {}.hmap {|k,v| [k, v * 2]}
+    )
+
+    assert_equal(
+      {},
+      {a: 1}.hmap {|k,v| nil}
+    )
+
+
+    assert_equal(
+      {
+        c: 4,
+        b: 6,
+        a: 2,
+      },
+      data.hmap! {|k,v| [k, v * 2]}
+    )
+    assert_equal(
+      {
+        c: 4,
+        b: 6,
+        a: 2,
+      },
+      data
+    )
+  end
+
+
+  def test_kmap
+    data = {
+      'a' => 1,
+      'b' => 2,
+      'c' => 3,
+    }
+
+    assert_equal(
+      {
+        'aa' => 1,
+        'bb' => 2,
+        'cc' => 3,
+      },
+      data.kmap {|k| k * 2}
+    )
+
+    assert_equal(
+      {
+        'aa' => 1,
+        'bb' => 2,
+        'cc' => 3,
+      },
+      data.kmap {|k,v| k * 2}
+    )
+
+    assert_equal(
+      {
+        'aa' => 1,
+        'bb' => 2,
+        'cc' => 3,
+      },
+      data.kmap! {|k,v| k * 2}
+    )
+    assert_equal(
+      {
+        'aa' => 1,
+        'bb' => 2,
+        'cc' => 3,
+      },
+      data
+    )
+  end
+
+
+  def test_vmap
+    data = {
+      a: 1,
+      b: 2,
+      c: 3,
+    }
+
+    assert_equal(
+      {
+        a: 2,
+        b: 4,
+        c: 6,
+      },
+      data.vmap {|v| v * 2}
+    )
+
+    assert_equal(
+      {
+        a: 2,
+        b: 4,
+        c: 6,
+      },
+      data.vmap {|k,v| v * 2}
+    )
+
+    assert_equal(
+      {
+        a: :a,
+        b: :b,
+        c: :c,
+      },
+      data.vmap {|k,v| k}
+    )
+
+
+    assert_equal(
+      {
+        a: 2,
+        b: 4,
+        c: 6,
+      },
+      data.vmap! {|v| v * 2}
+    )
+    assert_equal(
+      {
+        a: 2,
+        b: 4,
+        c: 6,
+      },
+      data
+    )
+  end
+
+
+  def test_ksort
+    data = {
+      cx: 2,
+      by: 3,
+      az: 1,
+    }
+
+    assert_equal(
+      {
+        az: 1,
+        by: 3,
+        cx: 2,
+      }.to_a,
+      data.ksort.to_a
+    )
+
+    assert_equal(
+      {
+        cx: 2,
+        by: 3,
+        az: 1,
+      }.to_a,
+      data.ksort {|k| k.to_s.reverse }.to_a
+    )
+
+    assert_equal(
+      {
+        az: 1,
+        by: 3,
+        cx: 2,
+      },
+      data.ksort!
+    )
+    assert_equal(
+      {
+        az: 1,
+        by: 3,
+        cx: 2,
+      },
+      data
+    )
+  end
+
+
+  def test_vsort
+    data = {
+      c: 2,
+      b: 3,
+      a: 1,
+    }
+
+    assert_equal(
+      {a: 1, c: 2, b: 3}.to_a,
+      data.vsort.to_a
+    )
+
+    assert_equal(
+      {b: 3, c: 2, a: 1}.to_a,
+      data.vsort {|v| -v}.to_a
+    )
+
+    assert_equal(
+      {a: 1, c: 2, b: 3}.to_a,
+      data.vsort!.to_a
+    )
+    assert_equal(
+      {a: 1, c: 2, b: 3}.to_a,
+      data.to_a
+    )
+  end
+
+
+  def test_diff
+    assert_equal(
+      {a: 1, b: 2, c: 3},
+      {a: 1, b: 2, c: 3} - {}
+    )
+
+    assert_equal(
+      {a: 1, c: 3},
+      {a: 1, b: 2, c: 3} - {b: 1}
+    )
+  end
+
+end

data/test/test_ip_addr.rb

@@ -0,0 +1,49 @@
+require 'minitest/autorun'
+require 'theusual'
+TheUsual::load 'ipaddr'
+
+
+class IPAddrTest < Minitest::Test
+
+  def test_all
+    assert_equal(
+      '8.8.8.8',
+      IPAddr.new('8.8.8.8').to_s
+    )
+
+    assert_equal(
+      '8.8.8.0',
+      IPAddr.new('8.8.8.0/24').to_s
+    )
+
+    assert_equal(
+      '8.8.8.0',
+      IPAddr.new('8.8.8').to_s
+    )
+
+    assert_equal(
+      '8.8.8',
+      IPAddr.new('8.8.8.0/24').short
+    )
+
+    assert_equal(
+      '8.8.8',
+      IPAddr.new('8.8.8').short
+    )
+
+    assert_equal(
+      '8.8.8.0',
+      IPAddr.new('8.8.8.0').short
+    )
+
+    assert_equal(
+      '8.8',
+      IPAddr.new('8.8.8.8/16').short
+    )
+
+    # make sure this doesn't explode
+    addr = IPAddr.new('8.8.8.8')
+    IPAddr.new addr
+  end
+
+end

data/test/test_time.rb

@@ -0,0 +1,30 @@
+require 'minitest/autorun'
+require 'theusual'
+TheUsual::load 'time'
+
+
+class TimeTest < Minitest::Test
+
+  def test_all
+    assert_equal(
+      'just now',
+      Time.new.humanize
+    )
+
+    assert_equal(
+      'a second ago',
+      (Time.new - 1).humanize
+    )
+
+    assert_equal(
+      '2 seconds ago',
+      (Time.new - 2).humanize
+    )
+
+    assert_equal(
+      'a minute ago',
+      (Time.new - 60).humanize
+    )
+  end
+
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: theusual
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Daniel Pepper
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10'
+description: |
+  TheUsual
+  ======
+
+  A handful of useful hacks...good for any project
+
+
+  #### Install
+  ```gem install theusual```
+
+
+  #### Usage
+  ```
+  require 'theusual'
+  TheUsual::load :all
+
+  Hash.map [:a, :b, :c] do |v|
+    [ v, v ]
+  end
+  => { a: :a, b: :b, c: :c }
+
+
+  [:a, nil, '', :b].compact :blanks
+  => [ :a, :b ]
+  ```
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/theusual.rb
+- lib/theusual/array.rb
+- lib/theusual/hash.rb
+- lib/theusual/ipaddr.rb
+- lib/theusual/mongoid.rb
+- lib/theusual/ssh.rb
+- lib/theusual/time.rb
+- test/test_array.rb
+- test/test_hash.rb
+- test/test_ip_addr.rb
+- test/test_time.rb
+homepage: https://github.com/d1hotpep/theusualrb
+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.5.1
+signing_key: 
+specification_version: 4
+summary: TheUsual
+test_files:
+- test/test_array.rb
+- test/test_hash.rb
+- test/test_ip_addr.rb
+- test/test_time.rb