fat_core 2.0.1 → 3.0.0

data/lib/fat_core/string.rb

@@ -1,284 +1,289 @@
 require 'damerau-levenshtein'
+require 'active_support/core_ext/regexp'
 
-class String
-  # Remove leading and trailing white space and compress internal runs of
-  # white space to a single space.
-  def clean
-    strip.squeeze(' ')
-  end
+module FatCore
+  module String
+    # Remove leading and trailing white space and compress internal runs of
+    # white space to a single space.
+    def clean
+      strip.squeeze(' ')
+    end
 
-  def distance(other, block_size: 1, max_distance: 10)
-    dl = DamerauLevenshtein
-    # NOTE: DL 'gives up after' max_distance, so the distance function
-    # will return max_distance+1 if the distance is bigger than that.
-    # Here we subtract 1 so the max_distance also becomes the max
-    # return value.
-    dl.distance(self, other, block_size, max_distance - 1)
-  end
+    def distance(other, block_size: 1, max_distance: 10)
+      dl = DamerauLevenshtein
+      # NOTE: DL 'gives up after' max_distance, so the distance function
+      # will return max_distance+1 if the distance is bigger than that.
+      # Here we subtract 1 so the max_distance also becomes the max
+      # return value.
+      dl.distance(self, other, block_size, max_distance - 1)
+    end
 
-  # See if self contains colon- or space-separated words that include
-  # the colon- or space-separated words of other.  Return the matched
-  # portion of self.  Other cannot be a regex embedded in a string.
-  def fuzzy_match(other)
-    # Remove periods, commas, and apostrophes
-    other = other.gsub(/[\*.,']/, '')
-    target = gsub(/[\*.,']/, '')
-    matchers = other.split(/[: ]+/)
-    regexp_string = matchers.map { |m| ".*?#{Regexp.escape(m)}.*?" }.join('[: ]')
-    regexp_string.sub!(/^\.\*\?/, '')
-    regexp_string.sub!(/\.\*\?$/, '')
-    regexp = /#{regexp_string}/i
-    matched_text =
-      if (match = regexp.match(target))
-        match[0]
+    # See if self contains colon- or space-separated words that include
+    # the colon- or space-separated words of other.  Return the matched
+    # portion of self.  Other cannot be a regex embedded in a string.
+    def fuzzy_match(other)
+      # Remove periods, commas, and apostrophes
+      other = other.gsub(/[\*.,']/, '')
+      target = gsub(/[\*.,']/, '')
+      matchers = other.split(/[: ]+/)
+      regexp_string = matchers.map { |m| ".*?#{Regexp.escape(m)}.*?" }.join('[: ]')
+      regexp_string.sub!(/^\.\*\?/, '')
+      regexp_string.sub!(/\.\*\?$/, '')
+      regexp = /#{regexp_string}/i
+      matched_text =
+        if (match = regexp.match(target))
+          match[0]
+        end
+      matched_text
+    end
+
+    # Here are instance methods for the class that includes Matchable
+    # This tries to convert the receiver object into a string, then
+    # matches against the given matcher, either via regex or a fuzzy
+    # string matcher.
+    def matches_with(str)
+      if str.nil?
+        nil
+      elsif str =~ %r{^\s*/}
+        re = str.to_regexp
+        $& if to_s =~ re
+      else
+        to_s.fuzzy_match(str)
       end
-    matched_text
-  end
+    end
 
-  # Here are instance methods for the class that includes Matchable
-  # This tries to convert the receiver object into a string, then
-  # matches against the given matcher, either via regex or a fuzzy
-  # string matcher.
-  def matches_with(str)
-    if str.nil?
-      nil
-    elsif str =~ %r{^\s*/}
-      re = str.to_regexp
-      $& if to_s =~ re
-    else
-      to_s.fuzzy_match(str)
+    def blank?
+      !!self =~ /\A\s*\z/
     end
-  end
 
-  # Convert a string of the form '/.../Iixm' to a regular expression. However,
-  # make the regular expression case-insensitive by default and extend the
-  # modifier syntax to allow '/I' to indicate case-sensitive.
-  def to_regexp
-    if self =~ %r{^\s*/([^/]*)/([Iixm]*)\s*$}
-      body = $1
-      opts = $2
-      flags = Regexp::IGNORECASE
-      unless opts.blank?
-        flags = 0 if opts.include?('I')
-        flags |= Regexp::IGNORECASE if opts.include?('i')
-        flags |= Regexp::EXTENDED if opts.include?('x')
-        flags |= Regexp::MULTILINE if opts.include?('m')
+    # Convert a string of the form '/.../Iixm' to a regular expression. However,
+    # make the regular expression case-insensitive by default and extend the
+    # modifier syntax to allow '/I' to indicate case-sensitive.
+    def to_regexp
+      if self =~ %r{^\s*/([^/]*)/([Iixm]*)\s*$}
+        body = $1
+        opts = $2
+        flags = Regexp::IGNORECASE
+        unless opts.blank?
+          flags = 0 if opts.include?('I')
+          flags |= Regexp::IGNORECASE if opts.include?('i')
+          flags |= Regexp::EXTENDED if opts.include?('x')
+          flags |= Regexp::MULTILINE if opts.include?('m')
+        end
+        flags = nil if flags.zero?
+        Regexp.new(body, flags)
+      else
+        Regexp.new(self)
       end
-      flags = nil if flags.zero?
-      Regexp.new(body, flags)
-    else
-      Regexp.new(self)
     end
-  end
-
-  # Convert to symbol "Hello World" -> :hello_world
-  def as_sym
-    strip.squeeze(' ').gsub(/\s+/, '_')
-      .gsub(/[^_A-Za-z0-9]/, '').downcase.to_sym
-  end
 
-  def as_string
-    self
-  end
+    # Convert to symbol "Hello World" -> :hello_world
+    def as_sym
+      strip.squeeze(' ').gsub(/\s+/, '_')
+        .gsub(/[^_A-Za-z0-9]/, '').downcase.to_sym
+    end
 
-  def number?
-    Float(self)
-    true
-  rescue ArgumentError
-    return false
-  end
+    def as_string
+      self
+    end
 
-  # If the string is a number, add grouping commas to the whole number part.
-  def commify
-    # Break the number into parts
-    return self unless clean =~ /\A(-)?(\d*)((\.)?(\d*))?\z/
-    neg = $1 || ''
-    whole = $2
-    frac = $5
-    # Place the commas in the whole part only
-    whole = whole.reverse
-    whole.gsub!(/([0-9]{3})/, '\\1,')
-    whole.gsub!(/,$/, '')
-    whole.reverse!
-    # Reassemble
-    if frac.blank?
-      neg + whole
-    else
-      neg + whole + '.' + frac
+    def number?
+      Float(self)
+      true
+    rescue ArgumentError
+      return false
     end
-  end
 
-  def wrap(width = 70, hang = 0)
-    result = ''
-    first_line = true
-    first_word_on_line = true
-    line_width_so_far = 0
-    words = split(' ')
-    words.each do |w|
-      if !first_line && first_word_on_line
-        w = ' ' * hang + w
-      end
-      unless first_word_on_line
-        w = ' ' + w
-      end
-      result << w
-      first_word_on_line = false
-      line_width_so_far += 1 + w.length
-      if line_width_so_far >= width
-        result << "\n"
-        line_width_so_far = 0
-        first_line = false
-        first_word_on_line = true
+    # If the string is a number, add grouping commas to the whole number part.
+    def commify
+      # Break the number into parts
+      return self unless clean =~ /\A(-)?(\d*)((\.)?(\d*))?\z/
+      neg = $1 || ''
+      whole = $2
+      frac = $5
+      # Place the commas in the whole part only
+      whole = whole.reverse
+      whole.gsub!(/([0-9]{3})/, '\\1,')
+      whole.gsub!(/,$/, '')
+      whole.reverse!
+      # Reassemble
+      if frac.blank?
+        neg + whole
+      else
+        neg + whole + '.' + frac
       end
     end
-    result.strip
-  end
 
-  def tex_quote
-    r = dup
-    r = r.gsub(/[{]/, 'XzXzXobXzXzX')
-    r = r.gsub(/[}]/, 'XzXzXcbXzXzX')
-    r = r.gsub(/\\/, '\textbackslash{}')
-    r = r.gsub(/\^/, '\textasciicircum{}')
-    r = r.gsub(/~/, '\textasciitilde{}')
-    r = r.gsub(/\|/, '\textbar{}')
-    r = r.gsub(/\</, '\textless{}')
-    r = r.gsub(/\>/, '\textgreater{}')
-    r = r.gsub(/([_$&%#])/) { |m| '\\' + m }
-    r = r.gsub('XzXzXobXzXzX', '\\{')
-    r.gsub('XzXzXcbXzXzX', '\\}')
-  end
+    def wrap(width = 70, hang = 0)
+      result = ''
+      first_line = true
+      first_word_on_line = true
+      line_width_so_far = 0
+      words = split(' ')
+      words.each do |w|
+        if !first_line && first_word_on_line
+          w = ' ' * hang + w
+        end
+        unless first_word_on_line
+          w = ' ' + w
+        end
+        result << w
+        first_word_on_line = false
+        line_width_so_far += 1 + w.length
+        if line_width_so_far >= width
+          result << "\n"
+          line_width_so_far = 0
+          first_line = false
+          first_word_on_line = true
+        end
+      end
+      result.strip
+    end
 
-  def self.random(size = 8)
-    ('a'..'z').cycle.take(size).shuffle.join
-  end
+    def tex_quote
+      r = dup
+      r = r.gsub(/[{]/, 'XzXzXobXzXzX')
+      r = r.gsub(/[}]/, 'XzXzXcbXzXzX')
+      r = r.gsub(/\\/, '\textbackslash{}')
+      r = r.gsub(/\^/, '\textasciicircum{}')
+      r = r.gsub(/~/, '\textasciitilde{}')
+      r = r.gsub(/\|/, '\textbar{}')
+      r = r.gsub(/\</, '\textless{}')
+      r = r.gsub(/\>/, '\textgreater{}')
+      r = r.gsub(/([_$&%#])/) { |m| '\\' + m }
+      r = r.gsub('XzXzXobXzXzX', '\\{')
+      r.gsub('XzXzXcbXzXzX', '\\}')
+    end
 
-  # Convert a string with an all-digit date to an iso string
-  # E.g., "20090923" -> "2009-09-23"
-  def digdate2iso
-    sub(/(\d\d\d\d)(\d\d)(\d\d)/, '\1-\2-\3')
-  end
+    # Convert a string with an all-digit date to an iso string
+    # E.g., "20090923" -> "2009-09-23"
+    def digdate2iso
+      sub(/(\d\d\d\d)(\d\d)(\d\d)/, '\1-\2-\3')
+    end
 
-  def entitle!
-    little_words = %w(a an the and or in on under of from as by to)
-    newwords = []
-    words = split(/\s+/)
-    first_word = true
-    num_words = words.length
-    words.each_with_index do |w, k|
-      last_word = (k + 1 == num_words)
-      if w =~ %r{c/o}i
-        # Care of
-        newwords.push('c/o')
-      elsif w =~ /^p\.?o\.?$/i
-        # Post office
-        newwords.push('P.O.')
-      elsif w =~ /^[0-9]+(st|nd|rd|th)$/i
-        # Ordinals
-        newwords.push(w.downcase)
-      elsif w =~ /^(cr|dr|st|rd|ave|pk|cir)$/i
-        # Common abbrs to capitalize
-        newwords.push(w.capitalize)
-      elsif w =~ /^(us|ne|se|rr)$/i
-        # Common 2-letter abbrs to upcase
-        newwords.push(w.upcase)
-      elsif w =~ /^[0-9].*$/i
-        # Other runs starting with numbers,
-        # like 3-A
-        newwords.push(w.upcase)
-      elsif w =~ /^(N|S|E|W|NE|NW|SE|SW)$/i
-        # Compass directions all caps
-        newwords.push(w.upcase)
-      elsif w =~ /^[^aeiouy]*$/i && w.size > 2
-        # All consonants and at least 3 chars, probably abbr
-        newwords.push(w.upcase)
-      elsif w =~ /^(\w+)-(\w+)$/i
-        # Hyphenated double word
-        newwords.push($1.capitalize + '-' + $2.capitalize)
-      elsif little_words.include?(w.downcase)
-        # Only capitalize at beginning or end
-        newwords.push(first_word || last_word ? w.capitalize : w.downcase)
-      else
-        # All else
-        newwords.push(w.capitalize)
+    def entitle!
+      little_words = %w(a an the and or in on under of from as by to)
+      newwords = []
+      words = split(/\s+/)
+      first_word = true
+      num_words = words.length
+      words.each_with_index do |w, k|
+        last_word = (k + 1 == num_words)
+        if w =~ %r{c/o}i
+          # Care of
+          newwords.push('c/o')
+        elsif w =~ /^p\.?o\.?$/i
+          # Post office
+          newwords.push('P.O.')
+        elsif w =~ /^[0-9]+(st|nd|rd|th)$/i
+          # Ordinals
+          newwords.push(w.downcase)
+        elsif w =~ /^(cr|dr|st|rd|ave|pk|cir)$/i
+          # Common abbrs to capitalize
+          newwords.push(w.capitalize)
+        elsif w =~ /^(us|ne|se|rr)$/i
+          # Common 2-letter abbrs to upcase
+          newwords.push(w.upcase)
+        elsif w =~ /^[0-9].*$/i
+          # Other runs starting with numbers,
+          # like 3-A
+          newwords.push(w.upcase)
+        elsif w =~ /^(N|S|E|W|NE|NW|SE|SW)$/i
+          # Compass directions all caps
+          newwords.push(w.upcase)
+        elsif w =~ /^[^aeiouy]*$/i && w.size > 2
+          # All consonants and at least 3 chars, probably abbr
+          newwords.push(w.upcase)
+        elsif w =~ /^(\w+)-(\w+)$/i
+          # Hyphenated double word
+          newwords.push($1.capitalize + '-' + $2.capitalize)
+        elsif little_words.include?(w.downcase)
+          # Only capitalize at beginning or end
+          newwords.push(first_word || last_word ? w.capitalize : w.downcase)
+        else
+          # All else
+          newwords.push(w.capitalize)
+        end
+        first_word = false
       end
-      first_word = false
+      self[0..-1] = newwords.join(' ')
     end
-    self[0..-1] = newwords.join(' ')
-  end
 
-  def entitle
-    dup.entitle!
-  end
+    def entitle
+      dup.entitle!
+    end
 
-  # Format the string according to the given sprintf format.
-  def format_by(fmt)
-    return self unless fmt
-    begin
-      format fmt, self
-    rescue ArgumentError
-      return self
+    # Thanks to Eugene at stackoverflow for the following.
+    # http://stackoverflow.com/questions/8806643/
+    #   colorized-output-breaks-linewrapping-with-readline
+    # These color strings without confusing readline about the length of
+    # the prompt string in the shell. (Unlike the rainbow routines)
+    def console_red
+      colorize(self, "\001\e[1m\e[31m\002")
     end
-  end
 
-  # Thanks to Eugene at stackoverflow for the following.
-  # http://stackoverflow.com/questions/8806643/
-  #   colorized-output-breaks-linewrapping-with-readline
-  # These color strings without confusing readline about the length of
-  # the prompt string in the shell. (Unlike the rainbow routines)
-  def console_red
-    colorize(self, "\001\e[1m\e[31m\002")
-  end
+    def console_dark_red
+      colorize(self, "\001\e[31m\002")
+    end
 
-  def console_dark_red
-    colorize(self, "\001\e[31m\002")
-  end
+    def console_green
+      colorize(self, "\001\e[1m\e[32m\002")
+    end
 
-  def console_green
-    colorize(self, "\001\e[1m\e[32m\002")
-  end
+    def console_dark_green
+      colorize(self, "\001\e[32m\002")
+    end
 
-  def console_dark_green
-    colorize(self, "\001\e[32m\002")
-  end
+    def console_yellow
+      colorize(self, "\001\e[1m\e[33m\002")
+    end
 
-  def console_yellow
-    colorize(self, "\001\e[1m\e[33m\002")
-  end
+    def console_dark_yellow
+      colorize(self, "\001\e[33m\002")
+    end
 
-  def console_dark_yellow
-    colorize(self, "\001\e[33m\002")
-  end
+    def console_blue
+      colorize(self, "\001\e[1m\e[34m\002")
+    end
 
-  def console_blue
-    colorize(self, "\001\e[1m\e[34m\002")
-  end
+    def console_dark_blue
+      colorize(self, "\001\e[34m\002")
+    end
 
-  def console_dark_blue
-    colorize(self, "\001\e[34m\002")
-  end
+    def console_purple
+      colorize(self, "\001\e[1m\e[35m\002")
+    end
 
-  def console_purple
-    colorize(self, "\001\e[1m\e[35m\002")
-  end
+    def console_cyan
+      colorize(self, "\001\e[1m\e[36m\002")
+    end
 
-  def console_cyan
-    colorize(self, "\001\e[1m\e[36m\002")
-  end
+    def console_def
+      colorize(self, "\001\e[1m\002")
+    end
 
-  def console_def
-    colorize(self, "\001\e[1m\002")
-  end
+    def console_bold
+      colorize(self, "\001\e[1m\002")
+    end
 
-  def console_bold
-    colorize(self, "\001\e[1m\002")
-  end
+    def console_blink
+      colorize(self, "\001\e[5m\002")
+    end
 
-  def console_blink
-    colorize(self, "\001\e[5m\002")
-  end
+    def colorize(text, color_code)
+      "#{color_code}#{text}\001\e[0m\002"
+    end
+
+    module ClassMethods
+      def random(size = 8)
+        ('a'..'z').cycle.take(size).shuffle.join
+      end
+    end
 
-  def colorize(text, color_code)
-    "#{color_code}#{text}\001\e[0m\002"
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
   end
 end
+
+String.include FatCore::String

data/lib/fat_core/symbol.rb

@@ -1,15 +1,21 @@
-class Symbol
-  # Convert to capitalized string: :hello_world -> "Hello World"
-  def entitle
-    to_s.tr('_', ' ').split(' ').join(' ').entitle
-  end
-  alias as_string entitle
+require 'fat_core/string'
 
-  def as_sym
-    self
-  end
+module FatCore
+  module Symbol
+    # Convert to capitalized string: :hello_world -> "Hello World"
+    def entitle
+      to_s.tr('_', ' ').split(' ').join(' ').entitle
+    end
+    alias as_string entitle
 
-  def tex_quote
-    to_s.tex_quote
+    def as_sym
+      self
+    end
+
+    def tex_quote
+      to_s.tex_quote
+    end
   end
 end
+
+Symbol.include(FatCore::Symbol)

data/lib/fat_core/version.rb

@@ -1,7 +1,7 @@
 module FatCore
-  MAJOR = 2
+  MAJOR = 3
   MINOR = 0
-  PATCH = 1
+  PATCH = 0
 
   VERSION = [MAJOR, MINOR, PATCH].compact.join('.')
 end

data/lib/fat_core.rb

@@ -1,22 +1 @@
-
-require 'date'
-require 'active_support'
-require 'active_support/core_ext'
-require 'active_support/number_helper'
-require 'csv'
-
 require 'fat_core/version'
-
-require 'fat_core/array'
-require 'fat_core/date'
-require 'fat_core/boolean'
-require 'fat_core/enumerable'
-require 'fat_core/hash'
-require 'fat_core/kernel'
-require 'fat_core/latex_eruby'
-require 'fat_core/nil'
-require 'fat_core/numeric'
-require 'fat_core/period'
-require 'fat_core/range'
-require 'fat_core/string'
-require 'fat_core/symbol'

data/spec/lib/array_spec.rb

@@ -1,5 +1,7 @@
 require 'spec_helper'
 
+require 'fat_core/array'
+
 describe Array do
   it 'should be able to report its last index' do
     letters = ('a'..'z').to_a

data/spec/lib/big_decimal_spec.rb

@@ -0,0 +1,7 @@
+require 'fat_core/big_decimal'
+
+describe BigDecimal do
+  it 'should provide a human-readable inspect for BigDecimal' do
+    expect(BigDecimal.new('33.45').inspect).to eq '33.45'
+  end
+end