Run this block before all others to ensure that we are reading the libraries from the source directory.

puts "Current directory: #{Dir.pwd}"
puts "Ruby LOADPATH:"
$:.unshift("./lib") unless $:[0] == './lib'
$:[0..10].each { |d| puts d }
puts "..."
require 'fat_core/all'  # => true

• README Setup Do First for Code Blocks
• FatCore
  • Installation
  • Usage
    • Array
      • Method =#last_i=
      • Method =#intersect_with_dups=
      • Method =diff_with_dups=
      • Method =comma_join(sep: nil, last_sep: nil, two_sep: nil)=
    • Range
    • Enumerable
    • Hash
    • String
    • TeX Quoting
    • Numbers
  • Contributing

fat-core is a simple gem to collect core extensions and a few new classes that I find useful in multiple projects.

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

You can extend classes individually by requiring the corresponding file:

require 'fat_core/array'
require 'fat_core/bigdecimal'
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.

Return the index of the last element of the Array.

Return a new Array that is the intersection of this Array with all others, but without removing duplicates as the Array#& method does. All items of this Array are included in the result but only if they also appear in all of the other Arrays.

Return an Array that is the difference between this Array and other, but without removing duplicates as the Array#- method does. All items of this Array are included in the result unless they also appear in any of the other Arrays.

Convert this array into a single string by (1) applying #to_s to each element and (2) joining the elements with the string given by the sep: parameter. By default the sep parameter is ‘, ‘. You may use a different separation string in the case when there are only two items in the list by supplying a two_sep parameter. You may also supply a difference separation string to separate the second-last and last items in the array by supplying a last_sep: parameter. By default, the sep parameter is the string ‘, ‘, the two_sep is ’ and ‘, and the last_sep is ‘, and ‘, all of which makes for a well-punctuated English clause. If sep is given, the other two parameters are set to its value by default. If last_sep is given, two_sep takes its value by default. If the input array is empty, #comma_join returns an empty string.

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)]

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.

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.

It also provides the shovel operator as a convenient alias for Hash#merge, so that

{a: 'A', b: 'B', c: 'C'} << {c: 'CC', d: 'DD'} << {e: 'EEE'} => {a: 'A', b: 'B', c: 'CC', d: 'DD', e: 'EEE'}

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_str also Symbol#as_str), 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.

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.

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).

1. Fork it (http://github.com/ddoherty03/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