finishing_moves 0.2.0 → 0.3.0

data/Rakefile

@@ -0,0 +1,10 @@
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -I lib -r finishing_moves.rb"
+end
+task :c => :console
+
+desc "Build the gem according to gemspec"
+task :buildgem do
+  sh "gem build finishing_moves.gemspec"
+end

data/finishing_moves.gemspec

@@ -26,4 +26,19 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'fuubar', '>= 0'
 
   s.required_ruby_version = '>= 2.0'
+
+  s.post_install_message = <<EOS
+********************************************************************************
+
+  Thank you for installing Finishing Moves!
+
+  Built and maintained by Forge Software
+  www.forgecrafted.com
+
+  Does your project or organization use this gem? Add it to the showcase page.
+  https://github.com/forgecrafted/finishing_moves/wiki/showcase
+
+********************************************************************************
+EOS
+
 end

data/lib/finishing_moves/array.rb

@@ -0,0 +1,30 @@
+class Array
+
+  def to_hash_values(starting_key = 0, &block)
+    key = starting_key
+    block = proc { |key| key + 1 } unless block_given?
+    t = {}
+    each do |entry|
+      t[key] = entry
+      key = block.call key
+    end
+    t
+  end
+  alias_method :to_hash_as_values, :to_hash_values
+
+  def to_indexed_hash(starting_key = 0)
+    raise ArgumentError, "#{starting_key.inspect} is not an integer" unless starting_key.is_a? Integer
+    to_hash_values(starting_key) { |i| i + 1 }
+  end
+
+  def to_hash_keys(starting_value = 0, &block)
+    t = {}
+    block = proc { default_value } unless block_given?
+    each do |entry|
+      t[entry] = block.call entry
+    end
+    t
+  end
+  alias_method :to_hash_as_keys, :to_hash_keys
+
+end

data/lib/finishing_moves/date_and_time.rb

@@ -0,0 +1,25 @@
+module FinishingMovesFiscalLogic
+
+  def fiscal_quarter
+    ((self.month - 1) / 3) + 1
+  end
+
+  # return array of month integers correspond to appropriate quarter interger
+  def quarter_months
+    quarters = [[1,2,3], [4,5,6], [7,8,9], [10,11,12]]
+    quarters[self.month - 1]
+  end
+
+end
+
+class Time
+  include FinishingMovesFiscalLogic
+end
+
+class Date
+  include FinishingMovesFiscalLogic
+end
+
+class DateTime
+  include FinishingMovesFiscalLogic
+end

data/lib/finishing_moves/enumerable.rb

@@ -0,0 +1,18 @@
+module Enumerable
+
+  def key_map(key)
+    map { |h| h[key] }
+  end
+
+  def key_map_reduce(key, arg = :+, &block)
+    if block_given?
+      # arg is the initial value of memo
+      key_map(key).reduce(arg, &block)
+    else
+      # arg is a named method
+      raise ArgumentError.new "arg must be a method symbol" unless arg.is_a? Symbol
+      key_map(key).reduce(arg)
+    end
+  end
+
+end

data/lib/finishing_moves/fixnum.rb

@@ -1,23 +1,20 @@
-class Fixnum
-  def length
-    Math.log10(self.abs).to_i + 1
-  end
-end
-
-class Bignum
+class Integer
   def length
     Math.log10(self.abs).to_i + 1
   end
+  alias_method :digits, :length
 end
 
 class Float
   def length
     raise ArgumentError.new("Cannot get length: \"#{self}\" is not an integer")
   end
+  alias_method :digits, :length
 end
 
 class BigDecimal
   def length
     raise ArgumentError.new("Cannot get length: \"#{self}\" is not an integer")
   end
+  alias_method :digits, :length
 end

data/lib/finishing_moves/kernel.rb

@@ -0,0 +1,35 @@
+module Kernel
+
+  def nil_chain(ret_val = nil, &block)
+    begin
+      result = yield
+      return ret_val if result.nil?
+      result
+    rescue NoMethodError
+    rescue NameError
+      return ret_val
+    end
+  end
+  alias_method :method_chain, :nil_chain
+
+  def bool_chain(&block)
+    result = nil_chain(&block)
+    return false if result.nil?
+    result
+  end
+
+  def class_exists?(class_name)
+    klass = Module.const_get(class_name.to_s)
+    return klass.is_a?(Class)
+  rescue NameError
+    return false
+  end
+
+  def cascade(&block)
+    loop do
+      yield
+      break
+    end
+  end
+
+end

data/lib/finishing_moves/object.rb

@@ -1,34 +1,11 @@
 class Object
 
-  def nil_chain(ret_val = nil, &block)
-    begin
-      result = yield
-      return ret_val if result.nil?
-      result
-    rescue NoMethodError
-    rescue NameError
-      return ret_val
-    end
-  end
-  alias_method :method_chain, :nil_chain
-
-  def bool_chain(&block)
-    result = nil_chain(&block)
-    return false if result.nil?
-    result
-  end
-
-  def class_exists?(class_name)
-    klass = Module.const_get(class_name.to_s)
-    return klass.is_a?(Class)
-  rescue NameError
-    return false
-  end
-
   def not_nil?
     !self.nil?
   end
 
+  alias_method :is_an?, :is_a?
+
   def same_as(compare)
     if compare.respond_to? :to_s
       self.to_s == compare.to_s
@@ -36,12 +13,12 @@ class Object
       raise ArgumentError.new("Cannot compare \"#{self.class.name}\" to \"#{compare.class.name}\", no string conversion")
     end
   end
+  alias_method :same_as?, :same_as
 
-  def cascade(&block)
-    loop do
-      yield
-      break
-    end
+  # Allows us to call keyify directly on a class name.
+  # See keyify() in string.rb for details.
+  def self.keyify
+    name.keyify
   end
 
 end

data/lib/finishing_moves/string.rb

@@ -0,0 +1,127 @@
+class String
+
+  def nl2br
+    self.gsub(/(?:\n\r?|\r\n?)/, "<br />\n")
+  end
+
+  def keyify
+    result = nil_chain do
+      the_key = self.clone
+
+      # strip all non-alphanumerics
+      the_key.gsub!(/[^0-9a-z]+/i, '_')
+
+      # borrowing some logic from Rails method underscore
+      # http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-underscore
+      if the_key =~ /[A-Z-]|::/
+        the_key.gsub!(/::/, '_')
+        the_key.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+        the_key.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      end
+
+      # Strip any leading numbers and underscores
+      the_key.lstrip_all!('0-9_')
+      # Strip trailing underscores
+      the_key.rstrip_all!('_')
+      # Combine multiple concurrent underscores
+      the_key.dedupe!('_')
+      # lowercase
+      the_key.downcase!
+      next the_key
+    end
+    return nil if result.nil? || result == ''
+    result.to_sym
+  end
+
+  def keyify!
+    result = self.keyify
+    raise ArgumentError, "#{self.inspect} cannot be keyified, no valid characters" if result.nil?
+    result
+  end
+
+  def strip_all(chars = nil)
+    expr = _strip_all_prep(chars)
+    gsub Regexp.union(_lstrip_all_regex(expr), _rstrip_all_regex(expr)), ''
+  end
+
+  def strip_all!(chars = nil)
+    expr = _strip_all_prep(chars)
+    gsub! Regexp.union(_lstrip_all_regex(expr), _rstrip_all_regex(expr)), ''
+  end
+
+  def lstrip_all(chars = nil)
+    gsub _lstrip_all_regex(_strip_all_prep(chars)), ''
+  end
+
+  def lstrip_all!(chars = nil)
+    gsub! _lstrip_all_regex(_strip_all_prep(chars)), ''
+  end
+
+  def rstrip_all(chars = nil)
+    gsub _rstrip_all_regex(_strip_all_prep(chars)), ''
+  end
+
+  def rstrip_all!(chars = nil)
+    gsub! _rstrip_all_regex(_strip_all_prep(chars)), ''
+  end
+
+  # strip multiple concurrent characters
+  def dedupe(str)
+    raise ArgumentError, "#{str.inspect} is not a string" unless str.is_a? String
+    # Yes, this is inefficient. We welcome optimizations from the regex ninjas out there.
+    ret = String.new self
+    str.each_char { |c| ret.gsub! /#{Regexp.escape c}{2,}/, c }
+    ret
+  end
+
+  def dedupe!(str)
+    raise ArgumentError, "#{str.inspect} is not a string" unless str.is_a? String
+    # Yes, this is inefficient. We welcome optimizations from the regex ninjas out there.
+    str.each_char { |c| gsub! /#{Regexp.escape c}{2,}/, c }
+  end
+
+  def remove_whitespace(replace = '')
+    gsub /[ ]/, replace
+  end
+
+  def remove_whitespace!(replace = '')
+    gsub! /[ ]/, replace
+  end
+
+  # return true/false on regex match
+  def match?(pattern, pos = 0)
+    match(pattern, pos).not_nil?
+  end
+
+  protected
+
+    def _lstrip_all_regex(expr)
+      /\A[#{expr}]+/
+    end
+
+    def _rstrip_all_regex(expr)
+      /[#{expr}]+\Z/
+    end
+
+    def _strip_all_prep(chars)
+      chars = '-_' if chars.nil?
+      raise ArgumentError, "#{chars.inspect} is not a string" unless chars.is_a? String
+
+      expr = Regexp.escape( chars.gsub(/(0-9)+|(a-z)+|(A-Z)+|\s+/, '').strip )
+      ['0-9', 'a-z', 'A-Z'].each do |range|
+        expr << range if chars.include? range
+      end
+      expr << ' '
+    end
+
+end
+
+# We aren't reopening Symbol class for anything else yet, so we'll just define
+# it in this file.
+class Symbol
+
+  def keyify
+    to_s.keyify
+  end
+
+end

data/lib/finishing_moves/version.rb

@@ -1,3 +1,3 @@
 module FinishingMoves
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/provision.sh

@@ -18,7 +18,6 @@ as_user() {
 install_ruby() {
   as_user "rbenv install -s $1"
   as_user "RBENV_VERSION=$1 gem install bundler"
-  as_user "rbenv rehash"
 }
 
 ###############################################################################
@@ -47,7 +46,6 @@ apt-get install -yfV         \
   libyaml-dev                \
   python-software-properties \
   sqlite3                    \
-  wget                       \
   zlib1g-dev                 \
 
 # Install rbenv and ruby-build.
@@ -55,6 +53,7 @@ as_user "git clone https://github.com/sstephenson/rbenv.git $USER_HOME/.rbenv"
 as_user "git clone https://github.com/sstephenson/ruby-build.git $USER_HOME/.rbenv/plugins/ruby-build"
 
 # Setup bash to use rbenv for $USER_NAME.
+truncate -s 0 $USER_HOME/.bashrc
 echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> $USER_HOME/.bashrc
 echo 'eval "$(rbenv init -)"'               >> $USER_HOME/.bashrc
 echo 'cd /vagrant'                          >> $USER_HOME/.bashrc

data/spec/array_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe Array do
+
+  let :sages do
+    ['Rauru', 'Saria', 'Darunia', 'Princess Ruto', 'Impa', 'Nabooru', 'Zelda']
+  end
+
+  it '#to_indexed_hash' do
+    expect { sages.to_indexed_hash("e") }.to raise_error(ArgumentError)
+    sages_hash = sages.to_indexed_hash
+    i = 0
+    sages.each do |sage|
+      expect(sages_hash[i]).to eq sage
+      i += 1
+    end
+
+    sages_hash = sages.to_indexed_hash(22)
+    i = 22
+    sages.each do |sage|
+      expect(sages_hash[i]).to eq sage
+      i += 1
+    end
+  end
+
+  it '#to_hash_values <#to_indexed_hash behaviour>' do
+    sages_hash = sages.to_hash_values
+    i = 0
+    sages.each do |sage|
+      expect(sages_hash[i]).to eq sage
+      i += 1
+    end
+
+    block = proc { |key| key + 1 }
+    sages_hash = sages.to_hash_values 0, &block
+    i = 0
+    sages.each do |sage|
+      expect(sages_hash[i]).to eq sage
+      i += 1
+    end
+
+    sages_hash = sages.to_hash_values(22)
+    i = 22
+    sages.each do |sage|
+      expect(sages_hash[i]).to eq sage
+      i += 1
+    end
+  end
+
+  it '#to_hash_values' do
+    block = proc { |key| key + 3 }
+    sages_hash = sages.to_hash_values 0, &block
+    i = 0
+    sages.each do |sage|
+      expect(sages_hash[i]).to eq sage
+      i += 3
+    end
+
+    sages_hash = sages.to_hash_values 22, &block
+    i = 22
+    sages.each do |sage|
+      expect(sages_hash[i]).to eq sage
+      i += 3
+    end
+
+    # alias check
+    expect(sages.to_hash_as_values(22, &block)).to eq sages_hash
+
+    elements = SageElements.new
+    sages_hash = sages.to_hash_values(elements.first_key) do |key|
+      elements.next_key(key)
+    end
+    expect(sages_hash[:light]).to eq sages[0]
+    expect(sages_hash[:forest]).to eq sages[1]
+    expect(sages_hash[:fire]).to eq sages[2]
+    expect(sages_hash[:water]).to eq sages[3]
+    expect(sages_hash[:shadow]).to eq sages[4]
+    expect(sages_hash[:spirit]).to eq sages[5]
+    expect(sages_hash[:time]).to eq sages[6]
+  end
+
+  it '#to_hash_keys' do
+    sages_hash = sages.to_hash_keys
+    # alias check
+    expect(sages.to_hash_as_keys).to eq sages_hash
+
+    sages.each do |sage|
+      expect(sages_hash[sage]).to eq 0
+    end
+
+    sages_hash = sages.to_hash_keys('foobar')
+    sages.each do |sage|
+      expect(sages_hash[sage]).to eq 'foobar'
+    end
+
+    sages_hash = sages.to_hash_keys { |key| key + "1" }
+    sages.each do |sage|
+      expect(sages_hash[sage]).to eq sage + "1"
+    end
+  end
+
+end
+
+class SageElements
+
+  def initialize
+    @keys = {
+      :first  => :light,
+      :light  => :forest,
+      :forest => :fire,
+      :fire   => :water,
+      :water  => :shadow,
+      :shadow => :spirit,
+      :spirit => :time,
+      :time   => :first,
+    }
+  end
+
+  def first_key
+    @keys[:first]
+  end
+
+  def next_key(pointer)
+    @keys[pointer]
+  end
+
+end

data/spec/enumerable_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Enumerable do
+
+  let :test_array do
+    [
+      {:foo => 1, :bar => 5, :baz =>  9},
+      {:foo => 2, :bar => 6, :baz => 10},
+      {:foo => 3, :bar => 7, :baz => 11},
+      {:foo => 4, :bar => 8, :baz => 12},
+    ]
+  end
+
+  it "#key_map" do
+    expect(test_array.key_map :foo).to eq([1, 2, 3, 4])
+    expect(test_array.key_map :bar).to eq([5, 6, 7, 8])
+    expect(test_array.key_map :baz).to eq([9, 10, 11, 12])
+  end
+
+  context "#key_map_reduce" do
+    it "default behavior" do
+      expect(test_array.key_map_reduce :foo).to eq(10)
+      expect(test_array.key_map_reduce :bar).to eq(26)
+      expect(test_array.key_map_reduce :baz).to eq(42)
+    end
+    it "with method override" do
+      expect(test_array.key_map_reduce :foo, :*).to eq(24)
+      expect(test_array.key_map_reduce :bar, :*).to eq(1680)
+      expect(test_array.key_map_reduce :baz, :*).to eq(11880)
+    end
+    it "with block" do
+      actual = test_array.key_map_reduce(:bar, "") { |memo,x| memo + "#{x**2}," }
+      expect(actual).to eq("25,36,49,64,")
+    end
+  end
+
+end

data/spec/fixnum_spec.rb

@@ -10,11 +10,15 @@ describe "Count number length" do
     expect(900.length).to eq 3
     expect(9000.length).to eq 4
     expect(-9000.length).to eq 4
+    # alias
+    expect(-9000.digits).to eq 4
   end
 
   it "Bignum#length" do
     expect(12356469787881584554556.length).to eq 23
     expect(-12356469787881584554556.length).to eq 23
+    # alias
+    expect(-12356469787881584554556.digits).to eq 23
   end
 
   it "Float#length" do
@@ -23,6 +27,8 @@ describe "Count number length" do
     expect{ -1.0.length }.to raise_error(ArgumentError)
     expect{ 3.14.length }.to raise_error(ArgumentError)
     expect{ 12356469.987.length }.to raise_error(ArgumentError)
+    # alias
+    expect{ 12356469.987.digits }.to raise_error(ArgumentError)
   end
 
   it "BigDecimal#length" do
@@ -30,6 +36,8 @@ describe "Count number length" do
     expect{ -1265437718438866624512.123.length }.to raise_error(ArgumentError)
     expect{ 0.9999999999999062.length }.to raise_error(ArgumentError)
     expect{ -0.9999999999999062.length }.to raise_error(ArgumentError)
+    # alias
+    expect{ -0.9999999999999062.digits }.to raise_error(ArgumentError)
   end
 
 end

data/spec/kernel_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe Kernel do
+
+  it "#nil_chain" do
+    expect(nil_chain{bogus_variable}).to eq nil
+    expect(nil_chain{bogus_hash[:foo]}).to eq nil
+    params = { :foo => 'bar' }
+    expect(nil_chain{ params[:bogus_key] }).to eq nil
+    expect(nil_chain{ params[:foo] }).to eq 'bar'
+    var = 'a simple string'
+    expect(nil_chain{ var.transmogrify }).to eq nil
+
+    c = C.new
+    b = B.new c
+    a = A.new b
+    expect(a.b.c.hello).to eq "Hello, world!"
+    b.c = nil
+    expect(nil_chain{a.b.c.hello}).to eq nil
+    a = nil
+    expect(nil_chain{a.b.c.hello}).to eq nil
+
+    expect( nil_chain(true) { bogus_variable } ).to equal true
+    expect( nil_chain(false) { bogus_variable } ).to equal false
+    expect( nil_chain('gotcha!') { bogus_variable } ).to eq 'gotcha!'
+    expect( nil_chain('gotcha!') { params[:bogus_key] } ).to eq 'gotcha!'
+    expect( nil_chain('gotcha!') { params[:foo] } ).to eq 'bar'
+
+    # alias
+    expect(method_chain{bogus_variable}).to eq nil
+  end
+
+  it "#bool_chain" do
+    expect(bool_chain{bogus_variable}).to equal false
+    var = true
+    expect(bool_chain{var}).to equal true
+    var = 'foo'
+    expect(bool_chain{var}).to eq 'foo'
+    result = bool_chain{ var.transmogrify }
+    expect(result).to equal false
+  end
+
+  it "#class_exists?" do
+    expect(class_exists? :Symbol).to eq true
+    expect(class_exists? :Symbology).to eq false
+    expect(class_exists? 'Symbol').to eq true
+    expect(class_exists? 'Symbology').to eq false
+    expect(class_exists? :Array).to eq true
+    expect(class_exists? :aRRay).to eq false
+    expect(class_exists? :ARRAY).to eq false
+    expect(class_exists? 'SomeModule::ClassInModule').to eq true
+  end
+
+  it "#cascade" do
+    expect(test_cascade).to be_nil
+    expect(test_cascade('step1')).to eq 1
+    expect(test_cascade('step2')).to eq 2
+    expect(test_cascade('step3')).to eq 3
+    expect(test_cascade('foobar')).to eq 4
+  end
+
+end
+
+# some small test fixtures
+
+class A
+  attr_accessor :b
+  def initialize(b)
+    @b = b
+  end
+end
+
+class B
+  attr_accessor :c
+  def initialize(c)
+    @c = c
+  end
+end
+
+class C
+  def hello
+    "Hello, world!"
+  end
+end
+
+class User
+  attr_writer :handle
+
+  def handle
+    @handle || "faceless_one"
+  end
+
+  def to_s
+    handle.to_s
+  end
+end
+
+def test_cascade(trigger = nil)
+  ultimate_value = nil
+  cascade do
+    break if trigger.nil?
+    ultimate_value = 1
+    break if trigger == 'step1'
+    ultimate_value = 2
+    break if trigger == 'step2'
+    ultimate_value = 3
+    break if trigger == 'step3'
+    ultimate_value = 4
+  end
+  return ultimate_value
+end
+
+module SomeModule
+  class ClassInModule
+  end
+end
+