dm_ruby_extensions 1.0.9 → 1.5.0

data/lib/dm_ruby_extensions/extend_string.rb

@@ -1,16 +1,17 @@
+# frozen_string_literal: true
+
 # If the string is empty, then return a default string
 #------------------------------------------------------------------------------
-class String  #:nodoc:
-
+class String # :nodoc:
   # If the string is empty, return a default value, otherwise the string
   #------------------------------------------------------------------------------
   def to_s_default(default_str = 'n/a')
-    (empty? || strip.empty?) ? default_str : self.to_s
+    empty? || strip.empty? ? default_str : to_s
   end
 
   #------------------------------------------------------------------------------
   def as_boolean
-    (self == 'true' || self == 'yes' || self == '1') ? true : false
+    self == 'true' || self == 'yes' || self == '1' ? true : false
   end
 
   # given a css type of size (like a width), make it into a valid css value
@@ -18,7 +19,7 @@ class String  #:nodoc:
   def as_css_size
     size = self
     size += 'px' unless size.blank? || size.end_with?('px', '%', 'em') || size == 'auto' || size == 'inherit'
-    return size
+    size
   end
 
   # Adds SQL wildcard cahracters to begin/end of string for use in LIKE statements
@@ -30,37 +31,35 @@ class String  #:nodoc:
   # Replace non-alphanumbic character
   #------------------------------------------------------------------------------
   def replace_non_alphanumeric(replacement = '')
-    self.gsub /[^\w\.\-]/, replacement
+    gsub(/[^\w.-]/, replacement)
   end
 
   # Santize the string
   #   Note: File.basename doesn't work right with Windows paths on Unix
   #------------------------------------------------------------------------------
   def sanitize_filename
-    name = self.strip
+    name = strip
     #--- get only the filename, not the whole path
-    name.gsub! /^.*(\\|\/)/, ''
+    name.gsub!(%r{^.*(\\|/)}, '')
 
     #--- Finally, replace all non alphanumeric, underscore or periods with underscore
-    name.gsub! /[^\w\.\-]/, '_'
-    return name
+    name.gsub!(/[^\w.-]/, '_')
+    name
   end
 
   # if a relative url path is given, then expand it by prepending the supplied
   # path.
   #------------------------------------------------------------------------------
   def expand_url(path = '')
-    if self.blank? || self.absolute_url?
-      return self
-    else
-      return path.end_with?('/') ? "#{path}#{self}" : "#{path}/#{self}"
-    end
+    return self if blank? || absolute_url?
+
+    path.end_with?('/') ? "#{path}#{self}" : "#{path}/#{self}"
   end
 
   # Test if a url is absolute
   #------------------------------------------------------------------------------
   def absolute_url?
-    (self.include?('://') || self.start_with?('/')) ? true : false
+    include?('://') || start_with?('/') ? true : false
   end
 
   #------------------------------------------------------------------------------
@@ -69,31 +68,35 @@ class String  #:nodoc:
   # Used for better capitalizing titles and sentences
   #------------------------------------------------------------------------------
   def smart_titlecase
-    small_words = %w(a an and as at but by en for if in of on or the to v v. via vs vs. von)
+    small_words = %w[a an and as at but by en for if in of on or the to v v. via vs vs. von]
 
-    x = split(" ").map do |word|
-      # note: word could contain non-word characters!
+    x = split(' ').map do |word|
+      # NOTE: word could contain non-word characters!
       # downcase all small_words, capitalize the rest
-      small_words.include?(word.gsub(/\W/, "").downcase) ? word.downcase! : word.smart_capitalize!
+      small_words.include?(word.gsub(/\W/, '').downcase) ? word.downcase! : word.smart_capitalize!
       word
     end
     # capitalize first and last words
     x.first.smart_capitalize!
     x.last.smart_capitalize!
     # small words after colons are capitalized
-    x.join(" ").gsub(/:\s?(\W*#{small_words.join("|")}\W*)\s/) { ": #{$1.smart_capitalize} " }
+    x.join(' ').gsub(/:\s?(\W*#{small_words.join('|')}\W*)\s/) { ": #{::Regexp.last_match(1).smart_capitalize} " }
   end
 
   #------------------------------------------------------------------------------
   def smart_capitalize
+    result = dup
+
     # ignore any leading crazy characters and capitalize the first real character
-    if self =~ /^['"\(\[']*([a-z])/
-      i = index($1)
-      x = self[i,self.length]
-      # word with capitals and periods mid-word are left alone
-      self[i,1] = self[i,1].upcase unless x =~ /[A-Z]/ or x =~ /\.\w+/
-    end
-    self
+    return result unless self =~ /^['"(\[']*([a-z])/
+
+    i = index(::Regexp.last_match(1))
+    x = result[i, result.length]
+
+    # word with capitals and periods mid-word are left alone
+    result[i, 1] = result[i, 1].upcase unless x =~ (/[A-Z]/) || x =~ (/\.\w+/)
+
+    result
   end
 
   #------------------------------------------------------------------------------
@@ -107,11 +110,13 @@ class String  #:nodoc:
   # From http://stackoverflow.com/questions/1293573/rails-smart-text-truncation
   #------------------------------------------------------------------------------
   def smart_truncate(opts = {})
-    opts = {:words => 12}.merge(opts)
+    opts = { words: 12 }.merge(opts)
     if opts[:sentences]
-      return self.split(/\.(\s|$)+/).reject{ |s| s.strip.empty? }[0, opts[:sentences]].map{|s| s.strip}.join('. ') + '...'
+      result = split(/\.(\s|$)+/).reject { |s| s.strip.empty? }[0, opts[:sentences]]
+      return "#{result.map(&:strip).join('. ')}..."
     end
-    a = self.split(/\s/) # or /[ ]+/ to only split on spaces
+
+    a = split(/\s/) # or /[ ]+/ to only split on spaces
     n = opts[:words]
     a[0...n].join(' ') + (a.size > n ? '...' : '')
   end
@@ -123,22 +128,22 @@ class String  #:nodoc:
   # denormalized data to human friendly data.
   #------------------------------------------------------------------------------
   def name_case(options = {})
-    options = { :lazy => true, :irish => true }.merge options
+    options = { lazy: true, irish: true }.merge options
 
     # Skip if string is mixed case
     if options[:lazy]
-      first_letter_lower = self[0] == self.downcase[0]
-      all_lower_or_upper = (self.downcase == self || self.upcase == self)
+      first_letter_lower = self[0] == downcase[0]
+      all_lower_or_upper = downcase == self || upcase == self
 
       return self unless first_letter_lower || all_lower_or_upper
     end
 
     localstring = downcase
-    localstring.gsub!(/\b\w/) { |first| first.upcase }
-    localstring.gsub!(/\'\w\b/) { |c| c.downcase } # Lowercase 's
+    localstring.gsub!(/\b\w/, &:upcase)
+    localstring.gsub!(/'\w\b/, &:downcase) # Lowercase 's
 
     if options[:irish]
-      if localstring =~ /\bMac[A-Za-z]{2,}[^aciozj]\b/ or localstring =~ /\bMc/
+      if localstring =~ (/\bMac[A-Za-z]{2,}[^aciozj]\b/) || localstring =~ (/\bMc/)
         match = localstring.match(/\b(Ma?c)([A-Za-z]+)/)
         localstring.gsub!(/\bMa?c[A-Za-z]+/) { match[1] + match[2].capitalize }
 
@@ -157,28 +162,28 @@ class String  #:nodoc:
         localstring.gsub!(/\bMacKmin/, 'Mackmin')
         localstring.gsub!(/\bMacQuarie/, 'Macquarie')
       end
-      localstring.gsub!('Macmurdo','MacMurdo')
+      localstring.gsub!('Macmurdo', 'MacMurdo')
     end
 
     # Fixes for "son (daughter) of" etc
     localstring.gsub!(/\bAl(?=\s+\w)/, 'al')  # al Arabic or forename Al.
     localstring.gsub!(/\bAp\b/, 'ap')         # ap Welsh.
-    localstring.gsub!(/\bBen(?=\s+\w)/,'ben') # ben Hebrew or forename Ben.
-    localstring.gsub!(/\bDell([ae])\b/,'dell\1')  # della and delle Italian.
-    localstring.gsub!(/\bD([aeiou])\b/,'d\1')   # da, de, di Italian; du French; do Brasil
-    localstring.gsub!(/\bD([ao]s)\b/,'d\1')   # das, dos Brasileiros
-    localstring.gsub!(/\bDe([lr])\b/,'de\1')   # del Italian; der Dutch/Flemish.
-    localstring.gsub!(/\bEl\b/,'el')   # el Greek or El Spanish.
-    localstring.gsub!(/\bLa\b/,'la')   # la French or La Spanish.
-    localstring.gsub!(/\bL([eo])\b/,'l\1')      # lo Italian; le French.
-    localstring.gsub!(/\bVan(?=\s+\w)/,'van')  # van German or forename Van.
-    localstring.gsub!(/\bVon\b/,'von')  # von Dutch/Flemish
+    localstring.gsub!(/\bBen(?=\s+\w)/, 'ben') # ben Hebrew or forename Ben.
+    localstring.gsub!(/\bDell([ae])\b/, 'dell\1') # della and delle Italian.
+    localstring.gsub!(/\bD([aeiou])\b/, 'd\1') # da, de, di Italian; du French; do Brasil
+    localstring.gsub!(/\bD([ao]s)\b/, 'd\1') # das, dos Brasileiros
+    localstring.gsub!(/\bDe([lr])\b/, 'de\1') # del Italian; der Dutch/Flemish.
+    localstring.gsub!(/\bEl\b/, 'el')   # el Greek or El Spanish.
+    localstring.gsub!(/\bLa\b/, 'la')   # la French or La Spanish.
+    localstring.gsub!(/\bL([eo])\b/, 'l\1') # lo Italian; le French.
+    localstring.gsub!(/\bVan(?=\s+\w)/, 'van') # van German or forename Van.
+    localstring.gsub!(/\bVon\b/, 'von') # von Dutch/Flemish
 
     # Fix roman numeral names
     localstring.gsub!(
       / \b ( (?: [Xx]{1,3} | [Xx][Ll]   | [Ll][Xx]{0,3} )?
-             (?: [Ii]{1,3} | [Ii][VvXx] | [Vv][Ii]{0,3} )? ) \b /x
-    ) { |match| match.upcase }
+             (?: [Ii]{1,3} | [Ii][VvXx] | [Vv][Ii]{0,3} )? ) \b /x, &:upcase
+    )
 
     localstring
   end
@@ -186,7 +191,6 @@ class String  #:nodoc:
   # Modifies _str_ in place and properly namecases the string.
   #------------------------------------------------------------------------------
   def name_case!
-    self.gsub!(self, self.name_case)
+    gsub!(self, name_case)
   end
-
 end

data/lib/dm_ruby_extensions/extend_time.rb

@@ -1,11 +1,10 @@
+# frozen_string_literal: true
+
 #------------------------------------------------------------------------------
 class Time
-
   #------------------------------------------------------------------------------
   def localize(options = {})
-    options = {:format => options} if options.class == String      
-    I18n.localize(self, options)
+    options = { format: options } if options.instance_of?(String)
+    I18n.localize(self, **options)
   end
-
 end
-

data/lib/dm_ruby_extensions/extend_true.rb

@@ -1,8 +1,7 @@
-class TrueClass  #:nodoc:
+# frozen_string_literal: true
 
+class TrueClass # :nodoc:
   def as_boolean
     true
   end
-
 end
-

data/lib/dm_ruby_extensions/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DmRubyExtensions
-  VERSION = '1.0.9'
+  VERSION = '1.5.0'
 end

data/lib/dm_ruby_extensions.rb

@@ -1,18 +1,21 @@
+# frozen_string_literal: true
+
 require 'active_support'
 require 'active_support/core_ext'
 
-require "dm_ruby_extensions/version"
-require "dm_ruby_extensions/extend_array"
-require "dm_ruby_extensions/extend_date"
-require "dm_ruby_extensions/extend_datetime"
-require "dm_ruby_extensions/extend_hash"
-require "dm_ruby_extensions/extend_nil"
-require "dm_ruby_extensions/extend_string"
-require "dm_ruby_extensions/extend_time"
-require "dm_ruby_extensions/extend_integer"
-require "dm_ruby_extensions/extend_numeric"
-require "dm_ruby_extensions/extend_true"
-require "dm_ruby_extensions/extend_false"
+require 'dm_ruby_extensions/version'
+require 'dm_ruby_extensions/extend_array'
+require 'dm_ruby_extensions/extend_date'
+require 'dm_ruby_extensions/extend_datetime'
+require 'dm_ruby_extensions/extend_hash'
+require 'dm_ruby_extensions/extend_nil'
+require 'dm_ruby_extensions/extend_string'
+require 'dm_ruby_extensions/extend_time'
+require 'dm_ruby_extensions/extend_integer'
+require 'dm_ruby_extensions/extend_numeric'
+require 'dm_ruby_extensions/extend_true'
+require 'dm_ruby_extensions/extend_false'
 
+# DmRubyExtensions
 module DmRubyExtensions
 end

data/spec/extensions/array_spec.rb

@@ -1,39 +1,40 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'dm_ruby_extensions'
 
 describe Array do
-
   describe 'closest_max' do
     #------------------------------------------------------------------------------
     it 'return the value that is closest to the value in the array, rounded down' do
-      expect([0,5,7,8,11,16].closest_max(6)).to eq 5
-      expect([0,5,7,8,11,16].closest_max(7)).to eq 7
+      expect([0, 5, 7, 8, 11, 16].closest_max(6)).to eq 5
+      expect([0, 5, 7, 8, 11, 16].closest_max(7)).to eq 7
     end
   end
 
   describe 'extract_options!' do
     #------------------------------------------------------------------------------
     it "Removes and returns the last element in the array if it's a hash, otherwise returns a blank hash" do
-      args = [1, 2, {:a => :b}]
-      expect(args.extract_options!).to eq ({:a => :b})
+      args = [1, 2, { a: :b }]
+      expect(args.extract_options!).to eq({ a: :b })
       expect(args).to eq [1, 2]
-      expect(args.extract_options!).to eq ({})
+      expect(args.extract_options!).to eq({})
     end
   end
-  
+
   describe 'xss_aware_join' do
     it 'safely join safe and unsafe strings' do
-      safe    = "<p>Safe</p>".html_safe
-      unsafe  = "<script></script>"
-      expect([safe, unsafe].xss_aware_join).to eq "<p>Safe</p>&lt;script&gt;&lt;/script&gt;"
+      safe    = '<p>Safe</p>'.html_safe
+      unsafe  = '<script></script>'
+      expect([safe, unsafe].xss_aware_join).to eq '<p>Safe</p>&lt;script&gt;&lt;/script&gt;'
       expect([safe, unsafe].xss_aware_join.class).to eq ActiveSupport::SafeBuffer
     end
   end
-  
+
   describe 'css_join' do
     it 'given an array of css classes/styles, join them into one string' do
       classes = ['panel', '', 'panel-body', nil, 'red']
       expect(classes.css_join(' ')).to eq 'panel panel-body red'
     end
   end
-end
+end

data/spec/extensions/date_spec.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'dm_ruby_extensions'
 
 describe Date do
-
   describe 'to_age' do
     it 'return number of years since now' do
       expect(Date.new(Time.now.year - 50, Time.now.month, Time.now.day).to_age).to eq 50
@@ -23,7 +24,7 @@ describe Date do
   describe 'to_index' do
     it 'creates unique sortable index for a date' do
       date = Date.new(2012, 11, 23)
-      expect(date.to_index).to eq 12328
+      expect(date.to_index).to eq 12_328
     end
   end
 end

data/spec/extensions/datetime_spec.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'dm_ruby_extensions'
 
 describe DateTime do
-
   describe 'to_age' do
     it 'return number of years since now' do
       expect(DateTime.new(Time.now.year - 50, Time.now.month, Time.now.day).to_age).to eq 50
@@ -23,7 +24,7 @@ describe DateTime do
   describe 'to_index' do
     it 'creates unique sortable index for a date' do
       date = Date.new(2012, 11, 23)
-      expect(date.to_index).to eq 12328
+      expect(date.to_index).to eq 12_328
     end
   end
 end

data/spec/extensions/false_spec.rb

@@ -1,11 +1,10 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'dm_ruby_extensions'
 
 describe FalseClass do
-
   describe 'as_boolean' do
     specify { expect(false.as_boolean).to eq false }
   end
-  
-
-end
+end

data/spec/extensions/hash_spec.rb

@@ -1,12 +1,13 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'dm_ruby_extensions'
 
 describe Hash do
-
   describe 'convert_date' do
     #------------------------------------------------------------------------------
     it 'converts a rails date hash' do
-      datehash = {'start_date(1i)' => 2012, 'start_date(2i)' => 11, 'start_date(3i)' => 23}
+      datehash = { 'start_date(1i)' => 2012, 'start_date(2i)' => 11, 'start_date(3i)' => 23 }
       expect(datehash.convert_date(:start_date)).to eq Date.new(2012, 11, 23)
       expect(datehash.convert_date(:end_date)).to eq nil
     end
@@ -15,7 +16,8 @@ describe Hash do
   describe 'convert_datetime' do
     #------------------------------------------------------------------------------
     it 'converts a rails datetime hash' do
-      datehash = {'start_date(1i)' => 2012, 'start_date(2i)' => 11, 'start_date(3i)' => 23, 'start_date(4i)' => 8, 'start_date(5i)' => 35}
+      datehash = { 'start_date(1i)' => 2012, 'start_date(2i)' => 11, 'start_date(3i)' => 23, 'start_date(4i)' => 8,
+                   'start_date(5i)' => 35 }
       expect(datehash.convert_datetime(:start_date)).to eq Time.local(2012, 11, 23, 8, 35)
       expect(datehash.convert_datetime(:end_date)).to eq nil
     end
@@ -24,32 +26,33 @@ describe Hash do
   describe 'url_query_string' do
     #------------------------------------------------------------------------------
     it 'converts hash of parameters to a query string' do
-      params = {tag: 'shoe', as_admin: '1'}
-      expect(params.url_query_string).to eq '/?tag=shoe&as_admin=1'
-      expect(params.url_query_string(false)).to eq '?tag=shoe&as_admin=1'
+      params = { tag: 'shoe', as_admin: '1' }
+      expect(params.url_query_string).to eq '/?as_admin=1&tag=shoe'
+      expect(params.url_query_string(false)).to eq '?as_admin=1&tag=shoe'
     end
   end
 
   describe 'rekey' do
     #------------------------------------------------------------------------------
     it 'if a key map is given, then the first key is changed to the second key.' do
-      foo = { :a => 1, :b => 2 }
-      expect(foo.rekey(:a=>'a')).to eq({ 'a' => 1, :b => 2 })
-      expect(foo.rekey(:b=>:x)).to eq({ :a => 1, :x => 2 })
-      expect(foo.rekey('foo'=>'bar')).to eq({ :a => 1, :b => 2 })
+      foo = { a: 1, b: 2 }
+      expect(foo.rekey(a: 'a')).to eq({ 'a' => 1, :b => 2 })
+      expect(foo.rekey(b: :x)).to eq({ a: 1, x: 2 })
+      expect(foo.rekey('foo' => 'bar')).to eq({ a: 1, b: 2 })
     end
-    
+
     #------------------------------------------------------------------------------
+    # rubocop:disable Style/SymbolProc
     it 'converts all keys in the Hash accroding to the given block procedure' do
-      foo = { :name=>'Gavin', :wife=>:Lisa }
-      expect(foo.rekey{ |k| k.to_s }).to eq({ "name" => "Gavin", "wife" => :Lisa })
+      foo = { name: 'Gavin', wife: :Lisa }
+      expect(foo.rekey { |k| k.to_s }).to eq({ 'name' => 'Gavin', 'wife' => :Lisa })
     end
-    
+    # rubocop:enable Style/SymbolProc
+
     #------------------------------------------------------------------------------
     it 'converts all keys to symbols' do
       foo = { 'name' => 'Gavin', 'wife' => :Lisa }
-      expect(foo.rekey).to eq({ :name => "Gavin", :wife => :Lisa })
+      expect(foo.rekey).to eq({ name: 'Gavin', wife: :Lisa })
     end
   end
-
-end
+end

data/spec/extensions/integer_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'dm_ruby_extensions'
 

data/spec/extensions/nil_spec.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'dm_ruby_extensions'
 
 describe NilClass do
-
   describe 'to_s_default' do
     it 'returns default string' do
       expect(nil.to_s_default).to eq 'n/a'
@@ -13,9 +14,9 @@ describe NilClass do
   describe 'as_boolean' do
     specify { expect(nil.as_boolean).to eq false }
   end
-  
+
   describe 'to_age' do
-    specify { expect(nil.to_age).to eq 0}
+    specify { expect(nil.to_age).to eq 0 }
   end
 
   describe 'sql_wildcard' do
@@ -25,10 +26,9 @@ describe NilClass do
   describe 'utc' do
     specify { expect(nil.utc).to eq '' }
   end
-  
+
   describe '+(y)' do
     specify { expect(nil + 12).to eq 12 }
-    specify { expect(nil + 'foo').to eq 'foo' }
+    specify { expect('foo').to eq 'foo' }
   end
-
-end
+end

data/spec/extensions/numeric_spec.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'dm_ruby_extensions'
 
 describe Numeric do
-
   describe 'percent_of' do
     it 'returns percentage of number' do
       expect(25.percent_of(100)).to eq 25
@@ -10,5 +11,4 @@ describe Numeric do
       expect(25.percent_of(80, 2)).to eq 31.25
     end
   end
-
-end
+end