fat_core 4.7.0 → 4.7.3

data/lib/fat_core/enumerable.rb

@@ -6,9 +6,9 @@ module Enumerable
   #      # On each iteration, grp is an Array of the next 5 items except the
   #      # last group, which contains only ['z'].
   #    end
-  def groups_of(n)
+  def groups_of(num)
     k = -1
-    group_by { k += 1; k.div(n) }
+    group_by { k += 1; k.div(num) }
   end
 
   # Yield each item together with two booleans that indicate whether the item is
@@ -16,9 +16,9 @@ module Enumerable
   #
   #    ('a'..'z').to_a.each with_flags do |letter, first, last|
   #      if first
-  #        # do something special for the first item
+  #        # do something special for 'a'
   #      elsif last
-  #        # do something special for the last item
+  #        # do something special for 'z'
   #      else
   #        # a middling item
   #      end
@@ -26,8 +26,8 @@ module Enumerable
   def each_with_flags
     last_k = size - 1
     each_with_index do |v, k|
-      first = (k == 0 ? true : false)
-      last  = (k == last_k ? true : false)
+      first = k.zero?
+      last  = (k == last_k)
       yield(v, first, last)
     end
   end

data/lib/fat_core/hash.rb

@@ -46,8 +46,8 @@ module FatCore
       last_k = size - 1
       k = 0
       each_pair do |key, val|
-        first = (k == 0 ? true : false)
-        last  = (k == last_k ? true : false)
+        first = k.zero?
+        last  = (k == last_k)
         yield(key, val, first, last)
         k += 1
       end
@@ -64,10 +64,10 @@ module FatCore
     #   h.delete_with_value(2) #=> { a: 1, c: 3, e: 1 }
     #   h.delete_with_value([1, 3]) #=> { b: 2, d: 2 }
     #
-    # @param v [Object, Enumerable<Object>] value to test for
+    # @param val [Object, Enumerable<Object>] value to test for
     # @return [Hash] hash having entries === v or including v deleted
-    def delete_with_value(v)
-      keys_with_value(v).each do |k|
+    def delete_with_value(val)
+      keys_with_value(val).each do |k|
         delete(k)
       end
       self
@@ -86,13 +86,11 @@ module FatCore
     # @param val [Object, Enumerable<Object>] value to test for
     # @return [Array<Object>] the keys with value or values v
     def keys_with_value(val)
-      result = []
+      keys = []
       each_pair do |k, v|
-        if self[k] == val || (v.respond_to?(:include?) && v.include?(val))
-          result << k
-        end
+        keys << k if self[k] == val || (v.respond_to?(:include?) && v.include?(val))
       end
-      result
+      keys
     end
 
     # Change each key of this Hash to its value in `key_map`. Keys not appearing in
@@ -132,6 +130,7 @@ module FatCore
       unless keys.size == new_keys.size
         raise ArgumentError, 'replace_keys: new keys size differs from key size'
       end
+
       to_a.each_with_index.map { |(_k, v), i| [new_keys[i], v] }.to_h
     end
   end

data/lib/fat_core/numeric.rb

@@ -133,9 +133,12 @@ module FatCore
       mins, secs = divmod(60)
       hrs, mins = mins.divmod(60)
       if frac.round(5) > 0.0
-        '%02d:%02d:%02d.%d' % [hrs, mins, secs, frac.round(5) * 100]
+        '%02<hrs>d:%02<mins>d:%02<secs>d.%<frac>d' % { hrs: hrs,
+                                                       mins: mins, secs: secs,
+                                                       frac: frac.round(5) * 100 }
       else
-        '%02d:%02d:%02d' % [hrs, mins, secs]
+        '%02<hrs>d:%02<mins>d:%02<secs>d' % { hrs: hrs, mins: mins,
+                                              secs: secs }
       end
     end
 

data/lib/fat_core/patches.rb

@@ -1,5 +1,6 @@
 # Provide #positive? and #negative? for older versions of Ruby.
 unless 2.respond_to?(:positive?)
+  # Patch Numeric
   class Numeric
     def positive?
       self > 0
@@ -8,6 +9,7 @@ unless 2.respond_to?(:positive?)
 end
 
 unless 2.respond_to?(:negative?)
+  # Patch Numeric
   class Numeric
     def negative?
       self < 0

data/lib/fat_core/range.rb

@@ -62,6 +62,7 @@ module FatCore
         cur_point = min
         ranges.each do |rr|
           break if rr.min > max
+
           if rr.min > cur_point
             start_point = cur_point
             end_point = rr.min.pred
@@ -96,6 +97,7 @@ module FatCore
         ranges.each do |rr|
           # Skip ranges outside of self
           next if rr.max < min || rr.min > max
+
           # Initialize cur_point to max of first range
           if cur_point.nil?
             cur_point = rr.max
@@ -125,6 +127,7 @@ module FatCore
     # @return [Range, nil] a Range representing the intersection
     def intersection(other)
       return nil unless overlaps?(other)
+
       ([min, other.min].max..[max, other.max].min)
     end
     alias & intersection
@@ -142,6 +145,7 @@ module FatCore
     # @return [Range, nil] a Range representing the union
     def union(other)
       return nil unless overlaps?(other) || contiguous?(other)
+
       ([min, other.min].min..[max, other.max].max)
     end
     alias + union
@@ -156,6 +160,7 @@ module FatCore
              other.max.respond_to?(:succ) && other.min.respond_to?(:pred)
         raise 'Range difference requires objects have pred and succ methods'
       end
+
       if subset_of?(other)
         # (4..7) - (0..10)
         []
@@ -365,7 +370,7 @@ module FatCore
     # @param other [Range] range to compare self with
     # @return [-1, 0, 1] if self is less, equal, or greater than other
     def <=>(other)
-      [min, max] <=> [other.min, other.max]
+      [min, max] <=> other.minmax
     end
 
     module ClassMethods

data/lib/fat_core/string.rb

@@ -55,21 +55,17 @@ module FatCore
       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
+        w = ' ' * hang + w if !first_line && first_word_on_line
+        w = ' ' + w unless first_word_on_line
         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
+        next unless line_width_so_far >= width
+
+        result << "\n"
+        line_width_so_far = 0
+        first_line = false
+        first_word_on_line = true
       end
       result.strip
     end
@@ -108,7 +104,9 @@ module FatCore
     #
     # @return [Date] the translated Date
     def as_date
-      ::Date.new($1.to_i, $2.to_i, $3.to_i) if self =~ %r{(\d\d\d\d)[-/]?(\d\d?)[-/]?(\d\d?)}
+      if self =~ %r{(\d\d\d\d)[-/]?(\d\d?)[-/]?(\d\d?)}
+        ::Date.new($1.to_i, $2.to_i, $3.to_i)
+      end
     end
 
     UPPERS = ('A'..'Z').to_a
@@ -121,7 +119,7 @@ module FatCore
 
     # Return true if all the letters in self are upper case
     def all_upper?
-      tr('^A-Za-z', '').split('').all? {|c| ('A'..'Z').to_a.include? c}
+      tr('^A-Za-z', '').split('').all? { |c| ('A'..'Z').to_a.include? c }
     end
 
     public
@@ -154,7 +152,7 @@ module FatCore
       words = split(/\s+/)
       last_k = words.size - 1
       words.each_with_index do |w, k|
-        first = (k == 0)
+        first = k.zero?
         last = (k == last_k)
         if w =~ %r{c/o}i
           # Care of
@@ -273,18 +271,20 @@ module FatCore
       matched_text
     end
 
-    REGEXP_META_CHARACTERS = "\\$()*+.<>?[]^{|}".chars
+    REGEXP_META_CHARACTERS = "\\$()*+.<>?[]^{|}".chars.freeze
 
-    # 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.  Without the
-    # surrounding '/', do not make the Regexp case insensitive, just translate
-    # it to a Regexp with Regexp.new.
+    # 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.  Without the surrounding '/', quote any Regexp
+    # metacharacters in the string and return a Regexp that matches the string
+    # literally.
     #
     # @example
     #   '/Hello/'.as_regexp #=> /Hello/i
     #   '/Hello/I'.as_regexp #=> /Hello/
     #   'Hello'.as_regexp #=> /Hello/
+    #   'Hello\b'.as_regexp #=> /Hello\\b/
     #
     # @return [Regexp]
     def as_regexp
@@ -299,14 +299,10 @@ module FatCore
           flags |= Regexp::MULTILINE if opts.include?('m')
         end
         flags = nil if flags.zero?
-        body = Regexp.quote(body) if REGEXP_META_CHARACTERS.include?(body)
+        # body = Regexp.quote(body) if REGEXP_META_CHARACTERS.include?(body)
         Regexp.new(body, flags)
       else
-        if REGEXP_META_CHARACTERS.include?(self)
-          Regexp.new(Regexp.quote(self))
-        else
-          Regexp.new(self)
-        end
+        Regexp.new(Regexp.quote(self))
       end
     end
 
@@ -327,7 +323,7 @@ module FatCore
       Float(self)
       true
     rescue ArgumentError
-      return false
+      false
     end
 
     # If the string is a valid number, return a string that adds grouping commas
@@ -347,6 +343,7 @@ module FatCore
     def commas(places = nil)
       numeric_re = /\A([-+])?([\d_]*)((\.)?([\d_]*))?([eE][+-]?[\d_]+)?\z/
       return self unless clean =~ numeric_re
+
       sig = $1 || ''
       whole = $2 ? $2.delete('_') : ''
       frac = $5 || ''

data/lib/fat_core/version.rb

@@ -1,7 +1,7 @@
 module FatCore
   MAJOR = 4
   MINOR = 7
-  PATCH = 0
+  PATCH = 3
 
   # FatCore version number
   VERSION = [MAJOR, MINOR, PATCH].compact.join('.')

data/spec/lib/date_spec.rb

@@ -219,6 +219,7 @@ describe Date do
         expect(Date.parse_american('2 / 1 / 2011').iso).to eq('2011-02-01')
         expect(Date.parse_american('  2 / 1 / 2011  ').iso).to eq('2011-02-01')
         expect(Date.parse_american('  2 / 1 / 15  ').iso).to eq('2015-02-01')
+        expect(Date.parse_american('  2-1-15  ').iso).to eq('2015-02-01')
         expect {
           Date.parse_american('xx/1/15')
         }.to raise_error(ArgumentError)
@@ -444,6 +445,7 @@ describe Date do
       it 'should be able to print itself in org form' do
         expect(Date.today.org).to eq('[2012-07-18 Wed]')
         expect((Date.today + 1.day).org).to eq('[2012-07-19 Thu]')
+        expect((Date.today + 1.day).org(true)).to eq('<2012-07-19 Thu>')
       end
 
       it 'should be able to print itself in eng form' do
@@ -610,7 +612,7 @@ describe Date do
         }.to raise_error(ArgumentError)
       end
 
-      it 'should be able to add a chuck sym to itself' do
+      it 'should be able to add a chunk sym to itself' do
         # Date.today is '2012-07-18'
         expect(Date.today.add_chunk(:year)).to eq(Date.parse('2013-07-18'))
         expect(Date.today.add_chunk(:half)).to eq(Date.parse('2013-01-18'))
@@ -626,6 +628,22 @@ describe Date do
         }.to raise_error(ArgumentError)
       end
 
+      it 'should be able to add n chunks sym to itself' do
+        # Date.today is '2012-07-18'
+        expect(Date.today.add_chunk(:year, 5)).to eq(Date.parse('2017-07-18'))
+        expect(Date.today.add_chunk(:half, 5)).to eq(Date.parse('2015-01-18'))
+        expect(Date.today.add_chunk(:quarter, 5)).to eq(Date.parse('2013-10-18'))
+        expect(Date.today.add_chunk(:bimonth, 5)).to eq(Date.parse('2013-05-18'))
+        expect(Date.today.add_chunk(:month, 5)).to eq(Date.parse('2012-12-18'))
+        expect(Date.today.add_chunk(:semimonth, 5)).to eq(Date.parse('2012-10-03'))
+        expect(Date.today.add_chunk(:biweek, 5)).to eq(Date.parse('2012-09-26'))
+        expect(Date.today.add_chunk(:week, 5)).to eq(Date.parse('2012-08-22'))
+        expect(Date.today.add_chunk(:day, 5)).to eq(Date.parse('2012-07-23'))
+        expect {
+          Date.today.add_chunk(:hour)
+        }.to raise_error(ArgumentError)
+      end
+
       it 'should know the end of chunks' do
         expect(Date.parse('2013-07-04').end_of_chunk(:year))
           .to eq Date.parse('2013-12-31')

data/spec/lib/string_spec.rb

@@ -150,30 +150,37 @@ the people, for the people, shall not perish from the earth."
     end
 
     it 'should be able to convert a string to a regular expression' do
+      # Ignores case by default
       re = "/hello((\s+)(world))?/".as_regexp
       expect(re.class).to eq Regexp
       expect(re.casefold?).to be true
       expect(re.multiline?).to be false
       expect(re.match?('Hello    WorlD')).to be true
 
+      # Countermand ignore case with /.../I modifier
       re = "/hello((\s+)(world))?/Im".as_regexp
       expect(re.class).to eq Regexp
       expect(re.casefold?).to be false
       expect(re.multiline?).to be true
       expect(re.match?('Hello    WorlD')).to be false
 
-      # Works without /../ but no options possible
-      re = "hello((\s+)(world))?".as_regexp
+      # Works without /../ but takes meta-characters literally
+      str = "hello((\s+)(world))?"
+      re = str.as_regexp
       expect(re.class).to eq Regexp
       expect(re.casefold?).to be false
       expect(re.multiline?).to be false
-      expect(re.match?('hello    world')).to be true
+      expect(re.match?('hello    world')).to be false
+      expect(re.match?(str)).to be true
+      expect('Hello\b'.as_regexp).to eq %r{Hello\\b}
+      expect('Hello'.as_regexp).to eq %r{Hello}
     end
 
     it 'should be able to convert metacharacters into Regexp' do
       "\\$()*+.<>?[]^{|}".chars.each do |c|
         re = c.as_regexp
         expect(re.class).to eq Regexp
+        expect(re.match?(c)).to be true
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fat_core
 version: !ruby/object:Gem::Version
-  version: 4.7.0
+  version: 4.7.3
 platform: ruby
 authors:
 - Daniel E. Doherty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-02 00:00:00.000000000 Z
+date: 2020-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: simplecov
@@ -28,16 +28,16 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -164,7 +164,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Write a longer description. Optional.
+description: Useful extensions to Date, String, Range and other classes
 email:
 - ded@ddoherty.net
 executables:
@@ -179,7 +179,7 @@ files:
 - ".yardopts"
 - Gemfile
 - LICENSE.txt
-- README.md
+- README.org
 - Rakefile
 - TODO.org
 - bin/console
@@ -213,7 +213,7 @@ files:
 - spec/lib/string_spec.rb
 - spec/lib/symbol_spec.rb
 - spec/spec_helper.rb
-homepage: ''
+homepage: https://github.com/ddoherty03/fat_core.git
 licenses:
 - MIT
 metadata:

data/README.md

@@ -1,165 +0,0 @@
-[![Build Status](https://travis-ci.org/ddoherty03/fat_core.svg?branch=master)](https://travis-ci.org/ddoherty03/fat_core)
-
-# FatCore
-
-fat-core is a simple gem to collect core extensions and a few new classes that
-I find useful in multiple projects.  The emphasis is on extending the Date
-class to make it more useful in financial applications.
-
-## Usage
-
-You can extend classes individually by requiring the corresponding file:
-
-```
-    require 'fat_core/array'
-    require 'fat_core/bigdecimal'
-    require 'fat_core/date'
-    require 'fat_core/enumerable'
-    require 'fat_core/hash'
-    require 'fat_core/kernel'
-    require 'fat_core/numeric'
-    require 'fat_core/range'
-    require 'fat_core/string'
-    require 'fat_core/symbol'
-```
-
-Or, you can require them all:
-
-```
-    require 'fat_core/all'
-```
-
-Many of these have little that is of general interest, but there are a few
-goodies.
-
-### Date
-
-For example, the `Date` class adds two methods for determining whether a given
-date is a US federal holiday as defined by federal law, including such things as
-federal holidays established by executive decree:
-
-```
-    require 'fat_core/date'
-    Date.parse('2014-05-18').fed_holiday?  => true # It's a weekend
-    Date.parse('2014-01-01').fed_holiday?  => true # It's New Years
-```
-
-Likewise, days on which the NYSE is closed can be gotten with:
-
-```
-    Date.parse('2014-04-18').nyse_holiday? => true # It's Good Friday
-```
-
-Conversely, `Date#fed_workday?` and `Date#nyse_workday?` return true if the
-federal government and the NYSE respectively are open for business on those
-days.
-
-In addition, the Date class, as extended by FatCore, adds `#next_<chunk>`
-methods for calendar periods in addition to those provided by the core Date
-class: `#next_half`, `#next_quarter`, `#next_bimonth`, and `#next_semimonth`,
-`#next_biweek`. There are also `#prior_<chunk>` variants of these, as well as
-methods for finding the end and beginning of all these periods (e.g.,
-`#beginning_of_bimonth`) and for querying whether a Date is at the beginning or
-end of these periods (e.g., `#beginning_of_bimonth?`, `#end_of_bimonth?`, etc.).
-
-FatCore also provides convenience formatting methods, such as `Date#iso` for
-quickly converting a Date to a string of the form 'YYYY-MM-DD', `Date#org` for
-formatting a Date as an Emacs org-mode timestamp, and several others.
-
-Finally, it provides a `#parse_spec` method for parsing a string, typically
-provided by a user, allowing all the period chunks to be conveniently and
-tersely specified by a user.  For example, the string '2Q' will be parsed as the
-second calendar quarter of the current year, while '2014-3Q' will be parsed as
-the third quarter of the year 2014.
-
-### Range
-
-You can also extend the Range class with several useful methods that emphasize
-coverage of one range by one or more others (`#spanned_by?` and `#gaps`),
-contiguity of Ranges to one another (`#contiguous?`, `#left_contiguous`, and
-`#right_contiguous`, `#join`), and the testing of overlaps between ranges
-(`#overlaps?`, `#overlaps_among?`). These are put to good use in the
-'fat_period' (https://github.com/ddoherty03/fat_period) gem, which combines
-fat_core's extended Range class with its extended Date class to make a useful
-Period class for date ranges, and you may find fat_core's extended Range class
-likewise useful.
-
-For example, you can use the `#gaps` method to find the gaps left in the
-coverage on one Range by an Array of other Ranges:
-
-```
-    require 'fat_core/range'
-    (0..12).gaps([(0..2), (5..7), (10..12)])  => [(3..4), (8..9)]
-```
-
-### Enumerable
-
-FatCore::Enumerable extends Enumerable with the `#each_with_flags` method that
-yields the elements of the Enumerable but also yields two booleans, `first` and
-`last` that are set to true on respectively, the first and last element of the
-Enumerable.  This makes it easy to treat these two cases specially without
-testing the index as in `#each_with_index`.
-
-### Hash
-
-FatCore::Hash extends the Hash class with some useful methods for element
-deletion (`#delete_with_value`) and for manipulating the keys
-(`#keys_with_value`, `#remap_keys` and `#replace_keys`) of a Hash. It also
-provides `#each_pair_with_flags` as an analog to Enumerable's
-`#each_with_flags`.
-
-### TeX Quoting
-
-Several of the extension, most notably 'fat_core/string', provides a
-`#tex_quote` method for quoting the string version of an object so as to allow
-its inclusion in a TeX document and quote characters such as '$' or '%' that
-have a special meaning for TeX.
-
-### String
-
-FatCore::String has methods for performing matching of one string with another
-(`#matches_with`, `#fuzzy_match`), for converting a string to title-case as
-might by used in the title of a book (`#entitle`), for converting a String into
-a useable Symbol (`#as_sym`) and vice-versa (`#as_string` also
-`Symbol#as_string`), for wrapping with an optional hanging indent (`#wrap`),
-cleaning up errant spaces (`#clean`), and computing the Damerau-Levenshtein
-distance between strings (`#distance`). And several others.
-
-### Numbers
-
-FatCore::Numeric has methods for inserting grouping commas into a number
-(`#commas` and `#group`), for converting seconds to HH:MM:SS.dd format
-(`#secs_to_hms`), for testing for integrality (`#whole?` and `#int_if_whole`), and
-testing for sign (`#signum`).
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```
-    gem 'fat_core', :git => 'https://github.com/ddoherty03/fat_core.git'
-```
-
-And then execute:
-
-```
-    $ bundle
-```
-
-Or install it yourself as:
-
-```
-    $ gem install fat_core
-```
-
-## Usage
-
-TODO: Write usage instructions here
-
-## Contributing
-
-1. Fork it ( http://github.com/<my-github-username>/fat_core/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request