bblib 0.3.0 → 0.4.1

data/lib/string/cases.rb

@@ -1,27 +1,24 @@
 module BBLib
-
-  def self.title_case str, first_only: true
-    ignoreables = ['a', 'an', 'the', 'on', 'upon', 'and', 'but', 'or', 'in', 'with', 'to']
+  def self.title_case(str, first_only: true)
+    str = str.to_s unless str.is_a?(String)
+    ignoreables = %w(a an the on upon and but or in with to)
     regx = /[[:space:]]+|\-|\_|\"|\'|\(|\)|\[|\]|\{|\}|\#/
     spacing = str.scan(regx).to_a
     words = str.split(regx).map do |word|
       if ignoreables.include?(word.downcase)
         word.downcase
+      elsif first_only
+        word.to_s.slice(0,1).to_s.upcase + word.to_s[1..-1].to_s
       else
-        if first_only
-          word[0] = word[0].upcase
-          word
-        else
-          word.capitalize
-        end
+        word.capitalize
       end
     end
     # Always cap the first word
-    words.first.capitalize
+    words[0] = words.first.to_s.slice(0,1).to_s.upcase + words.first.to_s[1..-1].to_s
     words.interleave(spacing).join
   end
 
-  def self.start_case str, first_only: false
+  def self.start_case(str, first_only: false)
     regx = /[[:space:]]+|\-|\_|\"|\'|\(|\)|\[|\]|\{|\}|\#/
     spacing = str.scan(regx).to_a
     words = str.split(regx).map do |word|
@@ -35,49 +32,53 @@ module BBLib
     words.interleave(spacing).join
   end
 
-  def self.camel_case str, style = :lower
+  def self.camel_case(str, style = :lower)
     regx = /[[:space:]]+|[^[[:alnum:]]]+/
-    words = str.split(regx).map do |word|
-      word.capitalize
-    end
+    words = str.split(regx).map(&:capitalize)
     words[0].downcase! if style == :lower
     words.join
   end
 
-  def self.delimited_case str, delimiter = '_'
+  def self.delimited_case(str, delimiter = '_')
     regx = /[[:space:]]+|[^[[:alnum:]]]+|\#{delimiter}+/
-    words = str.split(regx).join(delimiter)
+    str.split(regx).join(delimiter)
   end
 
-  def self.snake_case str
+  def self.snake_case(str)
     BBLib.delimited_case str, '_'
   end
 
-  def self.spinal_case str
+  def self.method_case(str)
+    str.gsub(/(?<=[^^])([A-Z])/, '_\1').gsub(/\s+/, ' ').snake_case.downcase
+  end
+
+  def self.class_case(str)
+    str.gsub(/(?<=[^^])([A-Z])/, ' \1').gsub(/\s+/, ' ').title_case.gsub(/\s+|\_/, '')
+  end
+
+  def self.spinal_case(str)
     BBLib.delimited_case str, '-'
   end
 
-  def self.train_case str
+  def self.train_case(str)
     BBLib.spinal_case(BBLib.start_case(str))
   end
-
 end
 
 class String
-
-  def title_case first_only: false
-    BBLib.title_case self, first_only:first_only
+  def title_case(first_only: false)
+    BBLib.title_case self, first_only: first_only
   end
 
-  def start_case first_only: false
-    BBLib.start_case self, first_only:first_only
+  def start_case(first_only: false)
+    BBLib.start_case self, first_only: first_only
   end
 
-  def camel_case style = :lower
+  def camel_case(style = :lower)
     BBLib.camel_case self, style
   end
 
-  def delimited_case delimiter = '_'
+  def delimited_case(delimiter = '_')
     BBLib.delimited_case self, delimiter
   end
 
@@ -85,6 +86,14 @@ class String
     BBLib.snake_case self
   end
 
+  def method_case
+    BBLib.method_case(self)
+  end
+
+  def class_case
+    BBLib.class_case(self)
+  end
+
   def spinal_case
     BBLib.spinal_case self
   end
@@ -92,5 +101,4 @@ class String
   def train_case
     BBLib.train_case self
   end
-
 end

data/lib/string/fuzzy_matcher.rb

@@ -1,73 +1,71 @@
-
 module BBLib
-
-  class FuzzyMatcher < LazyClass
-    attr_float_between 0, 100, :threshold, default: 75
-    attr_bool :case_sensitive, default: true
-    attr_bool :remove_symbols, :move_articles, :convert_roman, default: false
+  # Used to apply multiple string comparison algorithms to strings and
+  # normalize them to determine similarity for words or phrases.
+  class FuzzyMatcher
+    include Effortless
+    attr_float_between 0, 100, :threshold, default: 75, serialize: true
+    attr_bool :case_sensitive, default: true, serialize: true
+    attr_bool :remove_symbols, :move_articles, :convert_roman, default: false, serialize: true
+    attr_hash :algorithms, keys: [Symbol], values: [Float, Integer]
 
     # Calculates a percentage match between string a and string b.
-    def similarity a, b
-      prep_strings a, b
-      return 100.0 if @a == @b
-      score, total_weight = 0, @algorithms.map{|alg, v| v[:weight] }.inject{ |sum, w| sum+=w }
-      @algorithms.each do |algo, vals|
-        next unless vals[:weight] > 0
-        score+= @a.send(vals[:signature], @b) * vals[:weight]
+    def similarity(string_a, string_b)
+      string_a, string_b = prep_strings(string_a, string_b)
+      return 100.0 if string_a == string_b
+      score = 0
+      total_weight = algorithms.values.inject { |sum, weight| sum + weight }
+      algorithms.each do |algorithm, weight|
+        next unless weight.positive?
+        score+= string_a.send("#{algorithm}_similarity", string_b) * weight
       end
       score / total_weight
     end
 
     # Checks to see if the match percentage between Strings a and b are equal to or greater than the threshold.
-    def match? a, b
-      similarity(a, b) >= @threshold.to_f
+    def match?(string_a, string_b)
+      similarity(string_a, string_b) >= threshold.to_f
     end
 
     # Returns the best match from array b to string a based on percent.
-    def best_match a, b
-      similarities(a, b).max_by{ |k, v| v}[0]
+    def best_match(string_a, *string_b)
+      similarities(string_a, *string_b).max_by { |_k, v| v }[0]
     end
 
-    # Returns a hash of array 'b' with the percentage match to a. If sort is true, the hash is sorted desc by match percent.
-    def similarities a, b, sort: false
-      matches = Hash.new
-      [b].flatten.each{ |m| matches[m] = self.similarity(a, m) }
-      sort ? matches.sort_by{ |k, v| v }.reverse.to_h : matches
+    # Returns a hash of array 'b' with the percentage match to a. If sort is true,
+    # the hash is sorted desc by match percent.
+    def similarities(string_a, *string_b)
+      [*string_b].map { |word| [word, matches[word] = similarity(string_a, word)] }
     end
 
-    def set_weight algorithm, weight
-      return nil unless @algorithms.include? algorithm
-      @algorithms[algorithm][:weight] = BBLib.keep_between(weight, 0, nil)
-    end
-
-    def algorithms
-      @algorithms.keys
+    def set_weight(algorithm, weight)
+      return nil unless algorithms.include? algorithm
+      algorithms[algorithm] = BBLib.keep_between(weight, 0, nil)
     end
 
     private
 
-      def lazy_setup
-        @algorithms = {
-          levenshtein: {weight: 10, signature: :levenshtein_similarity},
-          composition: {weight: 5, signature: :composition_similarity},
-          numeric: {weight: 0, signature: :numeric_similarity},
-          phrase: {weight: 0, signature: :phrase_similarity}
-          # FUTURE qwerty: {weight: 0, signature: :qwerty_similarity}
-        }
-      end
+    def simple_setup
+      self.algorithms = {
+        levenshtein: 10,
+        composition: 5,
+        numeric:     0,
+        phrase:      0
+      }
+    end
 
-      def prep_strings a, b
-        @a, @b = a.to_s.dup, b.to_s.dup
-        methods = [
-          @case_sensitive ? nil : :downcase,
-          @remove_symbols ? :drop_symbols : nil,
-          @convert_roman ? :from_roman : nil,
-          @move_articles ? :move_articles : nil
-        ].reject(&:nil?).each do |method|
-          @a, @b = @a.send(method), @b.send(method)
-        end
+    def prep_strings(string_a, string_b)
+      string_a = string_a.to_s.dup
+      string_b = string_b.to_s.dup
+      [
+        case_sensitive? ? nil : :downcase,
+        remove_symbols? ? :drop_symbols : nil,
+        convert_roman? ? :from_roman : nil,
+        move_articles? ? :move_articles : nil
+      ].compact.each do |method|
+        string_a = string_a.send(method)
+        string_b = string_b.send(method)
       end
-
+      [string_a, string_b]
+    end
   end
-
 end

data/lib/string/matching.rb

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
 ##############################################
 # String Comparison Algorithms
 ##############################################
 
 module BBLib
-
   # A simple rendition of the levenshtein distance algorithm
-  def self.levenshtein_distance a, b
+  def self.levenshtein_distance(a, b)
     costs = (0..b.length).to_a
     (1..a.length).each do |i|
-      costs[0], nw = i, i - 1
+      costs[0] = i
+      nw = i - 1
       (1..b.length).each do |j|
         costs[j], nw = [costs[j] + 1, costs[j-1] + 1, a[i-1] == b[j-1] ? nw : nw + 1].min, costs[j]
       end
@@ -17,27 +18,32 @@ module BBLib
   end
 
   # Calculates a percentage based match using the levenshtein distance algorithm
-  def self.levenshtein_similarity a, b
+  def self.levenshtein_similarity(a, b)
     distance = BBLib.levenshtein_distance a, b
     max = [a.length, b.length].max.to_f
-    return ((max - distance.to_f) / max) * 100.0
+    ((max - distance.to_f) / max) * 100.0
   end
 
   # Calculates a percentage based match of two strings based on their character composition.
-  def self.composition_similarity a, b
-    if a.length <= b.length then t = a; a = b; b = t; end
-    matches, temp = 0, b.dup
+  def self.composition_similarity(a, b)
+    if a.length <= b.length
+      t = a
+      a = b
+      b = t
+    end
+    matches = 0
+    temp = b.dup
     a.chars.each do |c|
       if temp.chars.include? c
         matches+=1
         temp = temp.sub(c, '')
       end
     end
-    (matches / [a.length, b.length].max.to_f )* 100.0
+    (matches / [a.length, b.length].max.to_f)* 100.0
   end
 
   # Calculates a percentage based match between two strings based on the similarity of word matches.
-  def self.phrase_similarity a, b
+  def self.phrase_similarity(a, b)
     temp = b.drop_symbols.split ' '
     matches = 0
     a.drop_symbols.split(' ').each do |w|
@@ -51,34 +57,41 @@ module BBLib
 
   # Extracts all numbers from two strings and compares them and generates a percentage of match.
   # Percentage calculations here need to be weighted better...TODO
-  def self.numeric_similarity a, b
-    a, b = a.extract_numbers, b.extract_numbers
+  def self.numeric_similarity(a, b)
+    a = a.extract_numbers
+    b = b.extract_numbers
     return 100.0 if a.empty? && b.empty? || a == b
     matches = []
-    for i in 0..[a.size, b.size].max-1
+    (0..[a.size, b.size].max-1).each do |i|
       matches << 1.0 / ([a[i].to_f, b[i].to_f].max - [a[i].to_f, b[i].to_f].min + 1.0)
     end
-    (matches.inject{ |sum, m| sum + m } / matches.size.to_f) * 100.0
+    (matches.inject { |sum, m| sum + m } / matches.size.to_f) * 100.0
   end
 
   # A simple character distance calculator that uses qwerty key positions to determine how similar two strings are.
   # May be useful for typo detection.
-  def self.qwerty_distance a, b
-    a, b = a.downcase.strip, b.downcase.strip
-    if a.length <= b.length then t = a; a = b; b = t; end
+  def self.qwerty_distance(a, b)
+    a = a.downcase.strip
+    b = b.downcase.strip
+    if a.length <= b.length
+      t = a
+      a = b
+      b = t
+    end
     qwerty = {
-      1 => ['1','2','3','4','5','6','7','8','9','0'],
-      2 => ['q','w','e','r','t','y','u','i','o','p'],
-      3 => ['a','s','d','f','g','h','j','k','l'],
-      4 => ['z','x','c','v','b','n','m']
+      1 => %w(1 2 3 4 5 6 7 8 9 0),
+      2 => %w(q w e r t y u i o p),
+      3 => %w(a s d f g h j k l),
+      4 => %w(z x c v b n m)
     }
-    count, offset = 0, 0
+    count = 0
+    offset = 0
     a.chars.each do |c|
       if b.length <= count
         offset+=10
       else
-        ai = qwerty.keys.find{ |f| qwerty[f].include? c }.to_i
-        bi = qwerty.keys.find{ |f| qwerty[f].include? b.chars[count] }.to_i
+        ai = qwerty.keys.find { |f| qwerty[f].include? c }.to_i
+        bi = qwerty.keys.find { |f| qwerty[f].include? b.chars[count] }.to_i
         offset+= (ai - bi).abs
         offset+= (qwerty[ai].index(c) - qwerty[bi].index(b.chars[count])).abs
       end
@@ -89,27 +102,27 @@ module BBLib
 end
 
 class String
-  def levenshtein_distance str
+  def levenshtein_distance(str)
     BBLib.levenshtein_distance self, str
   end
 
-  def levenshtein_similarity str
+  def levenshtein_similarity(str)
     BBLib.levenshtein_similarity self, str
   end
 
-  def composition_similarity str
+  def composition_similarity(str)
     BBLib.composition_similarity self, str
   end
 
-  def phrase_similarity str
+  def phrase_similarity(str)
     BBLib.phrase_similarity self, str
   end
 
-  def numeric_similarity str
+  def numeric_similarity(str)
     BBLib.numeric_similarity self, str
   end
 
-  def qwerty_distance str
+  def qwerty_distance(str)
     BBLib.qwerty_distance self, str
   end
 end

data/lib/string/pluralization.rb

@@ -0,0 +1,156 @@
+
+
+module BBLib
+
+  SPECIAL_PLURALS = {
+    addendum: :addenda,
+    alga: :algae,
+    alumnus: :alumni,
+    amoeba: :amoebae,
+    analysis: :analyses,
+    antenna: :antennae,
+    appendix: :appendices,
+    auto: :autos,
+    axis: :axes,
+    bacterium: :bacteria,
+    barracks: :barracks,
+    basis: :bases,
+    cactus: :cacti,
+    calf: :calves,
+    crisis: :crises,
+    curriculum: :curricula,
+    datum: :data,
+    deer: :deer,
+    diagnosis: :diagnoses,
+    echo: :echoes,
+    elf: :elves,
+    ellipsis: :ellipses,
+    embargo: :embargoes,
+    emphasis: :emphases,
+    fish: :fish,
+    foot: :feet,
+    fungus: :fungi,
+    gallows: :gallows,
+    genus: :genera,
+    goose: :geese,
+    half: :halves,
+    hero: :heroes,
+    hoof: :hooves,
+    hypothesis: :hypotheses,
+    index: :indices,
+    kangaroo: :kangaroos,
+    kilo: :kilos,
+    knife: :knives,
+    larva: :larvae,
+    leaf: :leaves,
+    life: :lives,
+    loaf: :loaves,
+    louse: :lice,
+    man: :men,
+    matrix: :matrices,
+    means: :means,
+    memo: :memos,
+    memorandum: :memoranda,
+    mouse: :mice,
+    neurosis: :neuroses,
+    oasis: :oases,
+    offspring: :offspring,
+    paralysis: :paralyses,
+    parenthesis: :parentheses,
+    person: :people,
+    photo: :photos,
+    piano: :pianos,
+    pimento: :pimentos,
+    potato: :potatoes,
+    pro: :pros,
+    self: :selves,
+    series: :series,
+    sheep: :sheep,
+    shelf: :shelves,
+    solo: :solos,
+    soprano: :sopranos,
+    species: :species,
+    stimulus: :stimuli,
+    studio: :studios,
+    syllabus: :syllabi,
+    tattoo: :tattoos,
+    thesis: :theses,
+    thief: :thieves,
+    tomato: :tomatoes,
+    tooth: :teeth,
+    torpedo: :torpedoes,
+    vertebra: :vertebrae,
+    veto: :vetoes,
+    video: :videos,
+    wife: :wives,
+    wolf: :wolves,
+    woman: :women,
+    zoo: :zoos
+  }
+
+  def self.pluralize(string, num = 2)
+    full_string = string.to_s
+    string = string.split(/\s+/).last
+    sym = string.to_s.downcase.to_sym
+    if plural = SPECIAL_PLURALS[sym]
+      result = num == 1 ? string : plural
+    else
+      if string.end_with?(*%w{ch z s x o})
+        result = num == 1 ? string : (string + 'es')
+      elsif string =~ /[^aeiou]y$/i
+        result = num == 1 ? string : string.sub(/y$/i, 'ies')
+      else
+        result = num == 1 ? string : (string + 's')
+      end
+    end
+    full_string.sub(/#{Regexp.escape(string)}$/, copy_capitalization(string, result).to_s)
+  end
+
+  def self.singularize(string)
+    full_string = string.to_s
+    string = string.split(/\s+/).last
+    sym = string.to_s.downcase.to_sym
+    sym = string.to_s.downcase.to_sym
+    if singular = SPECIAL_PLURALS.find { |k, v| v == sym }
+      result = singular.first
+    elsif string.downcase.end_with?(*%w{oes ches zes ses xes})
+      result = string.sub(/es$/i, '')
+    elsif string =~ /ies$/i
+      result = string.sub(/ies$/i, 'y')
+    elsif string =~ /s$/i && !(string =~ /s{2}$/i)
+      result = string.sub(/s$/i, '')
+    else
+      result = string
+    end
+    full_string.sub(/#{Regexp.escape(string)}$/, copy_capitalization(string, result).to_s)
+  end
+
+  def self.custom_pluralize(num, base, plural = 's', singular = nil)
+    num == 1 ? "#{base}#{singular}" : "#{base}#{plural}"
+  end
+
+  def self.plural_string(num, string)
+    "#{num} #{pluralize(string, num)}"
+  end
+
+end
+
+class String
+  def pluralize(num = 2)
+    BBLib.pluralize(self, num)
+  end
+
+  def singularize
+    BBLib.singularize(self)
+  end
+end
+
+class Symbol
+  def pluralize(num = 2)
+    BBLib.pluralize(self.to_s, num).to_sym
+  end
+
+  def singularize
+    BBLib.singularize(self.to_s).to_sym
+  end
+end