bblib 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 46227889fa2341b852f07f10dd28892a0770b759
-  data.tar.gz: f7e8f2dae0ba5148cb77d0ec7086c87806dce3c7
+  metadata.gz: d6ed599d59ab2bd4d0a8cdae4cd61383e23d4e64
+  data.tar.gz: 2a528e9bcdb00c34514420da98cb1f990996f9d6
 SHA512:
-  metadata.gz: 45f56290f00c86f5ead9f13746fe76104d87698bfd8b99a89abc2fc1660b4dc4137fb0bb85d50ed9dc8bfcfb0e987b1bef83e41e40c9599eb2205b2809a0cc7a
-  data.tar.gz: 50f0e4937c9857b0f66c14b748a74fec84bd835da790e01c64774005e7d9f9f24a58e0e96f2204cfcaf65a690e1ae5ce0d3eec40c0b76e9a25623f1824f6fd60
+  metadata.gz: e0db224a5d5c9c8b430066ab093af08e510958b7a6aaa0f530f9a1d9e8e63f2bd9768586bf96643b2935d4f5ca68022c57f9db69067181400557cc6177e4775f
+  data.tar.gz: eab50c5ad0d2cf24e7f83b07d86a969a0c6a8fbe660b3db1c57098c00dc6e5fac480f824c7546fcae5b7eef5377623402d86dc8e366d546d2872ca48d4297e0c

data/README.md

@@ -1,10 +1,41 @@
 # BBLib
 
-BBLib (Brandon-Black-Lib) is a collection of various reusable methods and classes to extend the Ruby language. Currently the library is in an early state and is being written generally for education purposes. As such, large changes will likely occur and some functions may be incomplete or inaccurate until 1.0.
+BBLib (Brandon-Black-Lib) is a collection of various reusable methods and classes to extend the Ruby language.
 
-One of my primary goals with the core BBLib code is to keep it as lightweight as possible. This means you will not find dependencies outside of the Ruby core libraries in this code. Further modules that do have larger dependencies will be released in separate gems.
+One of the primary goals with the BBLib is to keep it as lightweight as possible. This means you will not find dependencies outside of the Ruby core libraries.
 
-For a full breakdown of what is currently in this library, scroll down.
+For a full breakdown of what is currently in this library, scroll down. For a quick overview of key features, read the following list.
+
+* __BBLib HashPath:__ Hash path is an XPath or JSONPath like navigation library for native Ruby hashes. It uses dot ('.') delimited path strings to navigate hash AND array objects. What makes hash path stand out is that it can navigate recursively within hashes, arrays, nested hashes, nested arrays, nested hashes within nested arrays within nested arrays with...well, you get the picture. Not only does it support navigation of hashes, it also comes with many functions to easily manipulate hashes by moving paths, copying paths, deleting paths or processing paths (see below for a few examples).
+
+```ruby
+myhash = {a:1, b:2, c:{d:[3,4,{e:5},6]}, f:7}
+p myhash.hash_path('c.d..e')
+#=> [5]
+p myhash.hash_path('..d')
+#=> [3, 4, {:e=>5}, 6]
+p myhash.hash_path('c.d[1]')
+#=> [4]
+p myhash.hash_path('c.d[0..1]')
+#=> [3, 4]
+
+# Move key/values
+p myhash.hash_path_move('a' => 'c.g.h')
+#=> {:b=>2, :c=>{:d=>[3, 4, {:e=>5}, 6], :g=>{:h=>1}}, :f=>7}
+
+# Copy key/values
+p myhash.hash_path_copy('b' => 'z')
+#=> {:a=>1, :b=>2, :c=>{:d=>[3, 4, {:e=>5}, 6]}, :f=>7, :z=>2}
+```
+* __Deep Merge:__ A deep merge algorithm is included that can merge hashes with nested hashes or nested arrays or nested hashes with nested arrays with nested hashes and so on... It can also combine colliding values into arrays rather than overwriting using a toggle-able overwrite flag.
+* __File & Time Parsing From Strings:__ Have a string such as '1MB 15KB' and want to make it numeric? Look no further. BBLib has methods to parse files size expressions and duration expressions from strings (like '1min 10sec'). Nearly any variant of size or duration expression is supported. For instance, '1sec', '1s', '1 s', '1 second', '1secs' are all properly parsed as 1 second.
+* __Fuzzy String Matching:__ The BBLib has implementations of a few string comparison algorithms. Most noteworthy, it features a simple implementation of the Levenshtein distance algorithm. A class, FuzzyMatcher, is also included to perform weight comparisons of strings using any of the included algorithms.
+* __Convert Roman Numerals__ within strings to Integers and Integers to Roman Numerals.
+* __Normalize articles__ such as 'the', 'an' and 'a' within titles to be displayed in the front, back or be stripped entirely. Helpful for sorting titles or for string comparisons.
+* __Object to Hash:__ Turn any object and its instance variables as well as nested objects and their instance variables into a hash. Handy to have alongside hash path.
+* __TaskTimer:__ A simple and easy to use timer class to compliment benchmarking in code by timing various tasks or groups of tasks. History is kept so that averages, sums, mins and maxes can be checked per task.
+* __Recursive File Scanners:__ A few file and directory scanners are implemented that recursively (by toggle) scan directories looking for files matching given filters.
+* __Plus more...__
 
 ## Installation
 
@@ -24,16 +55,6 @@ Or install it yourself as:
 
 ## Usage
 
-BBLib is currently broken up into the following categories:
-* File
-* Hash
-* Math
-* Net
-* String
-* Time
-
-
-
 ### File
 #### File Scanners
 
@@ -75,7 +96,7 @@ BBLib.scan_dir 'C:/path/to/files', recursive: true, filter: ['*.jpg', '*.txt']
 #=> 'C:/path/to/files/folder/another_folder/text.txt'
 ```
 
-In addition, both _scan_files_ and _scan_dirs_ also support a **mode** named argument. By default, this argument is set to :path. In _scan_files_ if :file is passed to :mode, a ruby File object will be returned rather than a String representation of the path. Similarily, if :dir is passed to _scan_dirs_ a ruby Dir object is returned.
+In addition, both _scan_files_ and _scan_dirs_ also support a **mode** named argument. By default, this argument is set to :path. In _scan_files_ if :file is passed to :mode, a ruby File object will be returned rather than a String representation of the path. Similarly, if :dir is passed to _scan_dirs_ a ruby Dir object is returned, rather than just a string.
 
 #### File Size Parsing
 
@@ -159,11 +180,11 @@ h1.deep_merge h2, merge_arrays: false
 #=> {:value=>5, :array=>[6, 7], :hash=>{:a=>1, :b_hash=>{:c=>9, :d=>10, :y=>10}, :z=>nil}}
 ```
 
-A **!** version of _deep_merge_ is also available to modify the hash in place rather than returning a new hash.
+A ! version of _deep_merge_ is also available to modify the hash in place rather than returning a new hash.
 
 #### Keys To Sym
 
-Convert all keys within a hash (including nested keys) to symbols. This is useful after parsing json if you prefer to work with symbols rather than strings. An inplace (**!**) version of the method is also available.
+Convert all keys within a hash (including nested keys) to symbols. This is useful after parsing json if you prefer to work with symbols rather than strings. An in-place (**!**) version of the method is also available.
 
 ```ruby
 h = {"author" => "Tom Clancy", "books" => ["Rainbow Six", "The Hunt for Red October"]}
@@ -171,6 +192,12 @@ h.keys_to_sym
 #=> {:author=>"Tom Clancy", :books=>["Rainbow Six", "The Hunt for Red October"]}
 ```
 
+_Note: This is similar to what Rails provides, except it even converts keys within nested hashes or nested arrays that contain nested hashes._
+
+#### Keys To Str
+
+The same as keys to sym, but it converts keys to strings rather than symbols.
+
 #### Reverse
 
 Similar to reverse for Array. Calling this will reverse the current order of the Hash's keys. An in place version is also available.
@@ -207,11 +234,6 @@ BBLib.keep_betwee number, nil, 100
 
 
 
-### Net
-Currently empty...
-
-
-
 ### String
 
 #### FuzzyMatcher
@@ -301,10 +323,29 @@ Checks to see how many words in a string match another. Words must match exactly
 #=> 66.66666666666666
 ```
 
-4 - Numeric Similarity (In Progress)
+4 - Numeric Similarity _(In Progress)_
 
 This algorithm is currently undergoing refactoring...
 
+This is primarily for comparing titles (such as movie or game titles). As an example, other algorithms would conclude that _'Terminator 2'_ is more similar to _'Terminator'_ than _'Terminator 2: Judgement Day'_, but the best match may really be _'Terminator 2: Judgement Day'_. To fix this, the numeric similarity would weight more towards the more appropriate title that contains the same number or numbers as itself. A string with no numbers is effectively considered to include a 1 for comparison's sake.
+
+```ruby
+a = 'Terminator 2'
+b = 'Terminator 2: Judgement Day'
+c = 'Terminator'
+
+puts a.levenshtein_similarity c
+#=> 83.33333333333334
+puts a.numeric_similarity c
+#=> 33.33333333333333
+
+puts a.levenshtein_similarity b
+#=> 44.44444444444444
+puts a.numeric_similarity b
+#=> 100.0
+```
+This algorithm is generally only useful when combined with another algorithm, which is exactly what the FuzzyMatcher class does.
+
 5 - QWERTY Similarity
 
 A basic method that compares two strings by measuring the physical difference from one char to another on a QWERTY keyboard (alpha-numeric only). May be useful for detecting typos in words, but becomes less useful depending on the length of the string. This method is still in development and not yet in a final state. Currently a total distance is returned. Eventually, a percentage based match will replace this.
@@ -371,15 +412,15 @@ BBLib.from_roman "Toy Story III"
 
 **msplit** _aka multi split_
 
-_msplit_ is similar to the String method split, except it can take an array of string delimiters rather than a single delim. The string is split be each delimiter in order and an Array is returned.
+_msplit_ is similar to the String method split, except it can take an array of string delimiters rather than a single delimiter. The string is split be each delimiter in order and an Array is returned. msplit may also be called on an array to split elements within it.
 
 ```ruby
-"This_is.a&&&&test".msplit ['_', '.', '&']
+"This_is.a&&&&test".msplit '_', '.', '&'
 
 #=> ['This', 'is', 'a', 'test']
 ```
 
-By default any empty items from the return Array are removed. This behavior can be changed using the _:keep_empty_ named param.
+By default any empty items from the returned Array are removed. This behavior can be changed using the _:keep_empty_ named param.
 
 ```ruby
 "This_is.a&&&&test".msplit ['_', '.', '&'], keep_empty: true
@@ -387,8 +428,6 @@ By default any empty items from the return Array are removed. This behavior can
 #=> ['This', 'is', 'a', '', '', '', 'test']
 ```
 
-_msplit is only available directly from an instantiated String object._
-
 **move_articles**
 
 This method is used to normalize strings that contain titles. It parses a string and checks to see if _the_, _an_ or _a_ are in the title, either preceding or trailing. If they are found they are moved to the front, back or removed depending on the argument passed to _position_.
@@ -398,38 +437,85 @@ The method is available via the BBLib module or any instance of String.
 ```ruby
 title = "The Simpsons"
 title.move_articles :back
-
 #=> "Simpons, The"
 
 title.move_articles :none
-
 #=> "Simpsons"
 
 title = "Day to Remember, A"
 title.move_articles :front
-
 #=> "A Day to Remember"
 ```
 
-**drop_symbols**
+**extract_integers**/**extract_floats**/**extract_numbers**
+
+Three methods to grab numbers from within strings. Integers only nabs numbers with no decimal places, floats gets only numbers with a decimal and numbers gets both integers and floats. The numbers must also be properly formatted, so something like the version number '2.1.1' below will not be extracted.
+
+```ruby
+s = 'Test 10 2.5 Number 100 aaaa 10.113 Version 2.1.1'
+
+p s.extract_integers
+#=> [10, 100]
+p s.extract_floats
+#=> [2.5, 10.113]
+p s.extract_numbers
+#=> [10, 2.5, 100, 10.113]
+```
+
+### Time
+
+#### Cron
+
+BBLib includes a lightweight cron syntax parser. It can be used to display the runtimes of a cron based on a cron string. Nearly every variant of cron syntax is supported with the ability to intermix ranges, divisors and explicit numbers in the same interval placing.
+
+```ruby
+
+cron = BBLib::Cron.new('* * * * * *')
+puts cron.next
+#=> 2016-04-03 22:01:00 -0600
 
-A simple method to remove all non-alpha, non-numeric and non-whitespace characters from a string. Extended to the String class.
+puts cron.previous
+#=> 2016-04-03 21:59:00 -0600
 
-**extract_integers**
+p cron.next(5)
+#=> [2016-04-03 22:01:00 -0600, 2016-04-03 22:02:00 -0600, 2016-04-03 22:03:00 -0600, 2016-04-03 22:04:00 -0600, 2016-04-03 22:05:00 -0600]
 
-Returns an array of all integers found within a string. The named param _:convert_ can be set to true to convert the extract numbers into Fixnums. If left false, strings are returned instead.
+# Set the time explicitly. The default is the current system time.
+puts cron.next(time: Time.now+30)
+#=> 2016-04-03 22:31:00 -0600
+```
 
-**extract_floats**
+An instantiated Cron object is not necessary to get the next and previous times.
 
-Performs the same action as _extract_integers_ except it can also pull floats from a string. The _:convert_ param is also available, but converts the strings into floats.
+```ruby
+puts BBLib::Cron.next('* * * * * *')
+#=> 2016-04-03 22:04:00 -0600
 
-**extract_numbers**
+puts BBLib::Cron.next('0-5 * * * * *')
+#=> 2016-04-03 22:04:00 -0600
 
-See above. Is an alias for _extract_floats_.
+puts BBLib::Cron.next('0 1 1 1 1 *')
+#=> 2018-01-01 01:00:00 -0700
 
+puts BBLib::Cron.next('1 1 1-5 * * 2020')
+#=> 2020-01-01 01:01:00 -0700
 
+puts BBLib::Cron.next('*/5 * * * * *')
+#=> 2016-04-03 22:05:00 -0600
 
-### Time
+puts BBLib::Cron.next('1-3,4,5,10-11 1-10 */5 * * *')
+#=> 2016-04-06 01:01:00 -0600
+```
+
+Common vixieisms are also supported:
+
+```ruby
+puts BBLib::Cron.next('@daily')
+#=> 2016-04-04 00:00:00 -0600
+
+puts BBLib::Cron.next('@weekly')
+#=> 2016-04-10 00:00:00 -0600
+```
 
 #### Duration parser
 
@@ -447,7 +533,14 @@ Similar to the file size parser under the files section, but instead can parse d
 #=> 1.1697222222222223
 ```
 Output options are:
-* :mili
+* :yocto
+* :zepto
+* :atto
+* :femto
+* :pico
+* :nano
+* :micro
+* :milli
 * :sec
 * :min
 * :hour
@@ -456,6 +549,20 @@ Output options are:
 * :month
 * :year
 
+__WARNING:__ _time intervals below microseconds are prone to heavy rounding errors in the current implementation. They are NOT EXACT._
+
+The colon separated duration pattern (eg. '02:30') can also be matched. The last set of digits is treated as seconds with each prior number being one interval greater. The default starting interval can be changed using the __min_interval__ named param. The available options are the same as the output options. This pattern type can even be intermixed with the types shown above and will be added to the total duration.
+
+```ruby
+duration = '04:35'
+
+puts duration.parse_duration
+#=> 275.0
+
+puts duration.parse_duration min_interval: :min
+#=> 16500.0
+```
+
 **Create a duration String from Numeric**
 
 There is also a method to turn a Numeric object into a string representation of a duration. This method is extended to the Numeric class. An input may be specified to tell the method what the input number represents. The options for this are the same as the output options listed above. A stop can be added using any of those same options. This will prevent the string from containing anything below the specified time type. For instance, specifying _stop: :sec_ will prevent milliseconds from being included if there are any. There are also three options that can be passed to the _:style_ argument to change the output (options are _:full_, _:medium_ and _:short:).

data/lib/array/bbarray.rb

@@ -1,4 +1,18 @@
 
+module BBLib
+
+  # Takes two arrays (can be of different length) and interleaves them like [a[0], b[0], a[1], b[1]...]
+  def self.interleave a, b, filler: nil
+    if a.size < b.size
+      a = a.dup
+      while a.size < b.size
+        a.push filler
+      end
+    end
+    a.zip(b).flatten(1)
+  end
+
+end
 
 class Array
   def msplit *delims, keep_empty: false
@@ -12,4 +26,16 @@ class Array
   def keys_to_s clean: false
     self.map{ |v| Hash === v || Array === v ? v.keys_to_s : v }
   end
+
+  def to_xml level: 0, key:nil
+    map do |v|
+      nested = v.respond_to?(:to_xml)
+      value = nested ? v.to_xml(level:level+1, key:key) : v
+      "\t"*level + "<#{key}>\n" + (nested ? '' : "\t"*(level+1)) + "#{value}\n" + "\t"*level + "</#{key}>\n"
+    end.join
+  end
+
+  def interleave b, filler: nil
+    BBLib.interleave self, b, filler: filler
+  end
 end

data/lib/bblib/version.rb

@@ -1,3 +1,3 @@
 module BBLib
-  VERSION = "0.2.0"
+  VERSION = "0.2.2"
 end

data/lib/file/bbfile.rb

@@ -7,7 +7,7 @@ module BBLib
     if !filter.nil?
       filter = [filter].flatten.map{ |f| path.to_s + (recursive ? '/**/' : '/') + f.to_s }
     else
-      filter = path.to_s + (recursive ? '/**/*' : '/*')
+      filter = (path.to_s + (recursive ? '/**/*' : '/*')).gsub('//', '/')
     end
     Dir.glob(filter)
   end
@@ -44,7 +44,29 @@ module BBLib
     return bytes / FILE_SIZES[output][:mult]
   end
 
-FILE_SIZES = {
+  # A mostly platform agnostic call to get root volumes
+  def self.root_dirs
+    begin # For windows
+      `wmic logicaldisk get name`.split("\n").map{ |m| m.strip }[1..-1].reject{ |r| r == '' }
+    rescue
+      begin # Windows attempt 2
+        `fsutil fsinfo drives`.scan(/(?<=\s)\w\:/)
+      rescue  # Linux
+        begin
+          `ls /`.split("\n").map{ |m| m.strip }.reject{ |r| r == '' }
+        rescue # All attempts failed
+          nil
+        end
+      end
+    end
+  end
+
+  # Windows only method to get the volume labels of disk drives
+  def self.root_volume_labels
+    `wmic logicaldisk get caption,volumename`.split("\n")[1..-1].map{ |m| [m.split("  ").first.to_s.strip, m.split("  ")[1..-1].to_a.join(' ').strip] }.reject{ |o,t| o == '' }.to_h
+  end
+
+  FILE_SIZES = {
     byte: { mult: 1, exp: ['b', 'byt', 'byte'] },
     kilobyte: { mult: 1024, exp: ['kb', 'kilo', 'k', 'kbyte', 'kilobyte'] },
     megabyte: { mult: 1048576, exp: ['mb', 'mega', 'm', 'mib', 'mbyte', 'megabyte'] },
@@ -73,6 +95,10 @@ class String
     self[(self.include?('/') ? self.rindex('/').to_i+1 : 0)..(with_extension ? -1 : self.rindex('.').to_i-1)]
   end
 
+  def dirname
+    self.scan(/.*(?=\/)/).first
+  end
+
   def parse_file_size output: :byte
     BBLib.parse_file_size(self, output:output)
   end

data/lib/hash/bbhash.rb

@@ -2,12 +2,10 @@ require_relative 'hash_path'
 
 class Hash
 
-
-
   # Merges with another hash but also merges all nested hashes and arrays/values.
   # Based on method found @ http://stackoverflow.com/questions/9381553/ruby-merge-nested-hash
   def deep_merge with, merge_arrays: true, overwrite_vals: true
-      merger = proc{ |k, v1, v2| v1.is_a?(Hash) && v2.is_a?(Hash) ? v1.merge(v2, &merger) : (merge_arrays && v1.is_a?(Array) && v2.is_a?(Array) ? (v1 + v2) : (overwrite_vals ? v2 : [v1, v2].flatten)) }
+      merger = proc{ |k, v1, v2| v1.is_a?(Hash) && v2.is_a?(Hash) ? v1.merge(v2, &merger) : (merge_arrays && v1.is_a?(Array) && v2.is_a?(Array) ? (v1 + v2) : (overwrite_vals || v1 == v2 ? v2 : [v1, v2].flatten)) }
       self.merge(with, &merger)
   end
 
@@ -50,4 +48,13 @@ class Hash
     replace hash.merge(self).merge(hash)
   end
 
+  def to_xml level: 0, key:nil
+    map do |k,v|
+      nested = v.respond_to?(:to_xml)
+      array = Array === v
+      value = nested ? v.to_xml(level:level+(array ? 0 : 1), key:k) : v
+      "\t" * level + (array ? '' : "<#{k}>\n") + (nested ? '' : "\t" * (level+1)) + "#{value}\n" + "\t" * level + (array ? '' : "</#{k}>\n")
+    end.join
+  end
+
 end

data/lib/hash/hash_path.rb

@@ -11,13 +11,13 @@ module BBLib
     hashes.each do |hash|
       if recursive
         patterns = Regexp === p[:key] ? p[:key] : p[:key].to_s == '*' ? /.*/ : (symbol_sensitive ? p[:key] : [p[:key].to_sym, p[:key].to_s])
-        matches.push hash.dig(patterns).flatten(1)[p[:slice]]
+        hash.dig(patterns)[p[:slice]].each{ |va| matches.push va }
       else
         if p[:key].nil?
-          if hash.is_a?(Array) then matches << hash[p[:slice]] end
+          if hash.is_a?(Array) then hash[p[:slice]].each{ |h| matches << h } end
         elsif Symbol === p[:key] || String === p[:key]
           if p[:key].to_s == '*'
-            matches.push hash.values.flatten(1)[p[:slice]]
+            hash.values[p[:slice]].each{ |va| matches.push va }
           else
             next unless symbol_sensitive ? hash.include?(p[:key]) : (hash.include?(p[:key].to_sym) || hash.include?(p[:key].to_s) )
             mat = (symbol_sensitive ? hash[p[:key]] : ( if hash.include?(p[:key].to_sym) then hash[p[:key].to_sym] else hash[p[:key].to_s] end ))
@@ -30,11 +30,9 @@ module BBLib
     end
     matches = BBLib.analyze_hash_path_formula p[:formula], matches
     if path.size > 1 && !matches.empty?
-      # p "MAT #{matches}"
-      # matches.map!{ |m| m.is_a?(Array) ? [m] : m }
       BBLib.hash_path(matches.reject{ |r| !(r.is_a?(Hash) || r.is_a?(Array)) }, path[1..-1], symbol_sensitive:symbol_sensitive)
     else
-      return matches.flatten(1)
+      return matches
     end
   end
 
@@ -44,10 +42,14 @@ module BBLib
     details[:paths].each do |path, d|
       d[:hashes].each do |h|
         count+=1
-        exists = (details[:symbol_sensitive] ? h.include?(d[:last][:key]) : (h.include?(d[:last][:key].to_sym) || h.include?(d[:last][:key].to_s) ))
+        if d[:last][:key].is_a?(Regexp)
+          exists = h.keys.any?{ |k| k.to_s =~ d[:last][:key] }
+        else
+          exists = (details[:symbol_sensitive] ? h.include?(d[:last][:key]) : (h.include?(d[:last][:key].to_sym) || h.include?(d[:last][:key].to_s) ))
+        end
         next unless details[:bridge] || exists
-        key = details[:symbol_sensitive] ? d[:last][:key] : (h.include?(d[:last][:key].to_sym) ? d[:last][:key].to_sym : d[:last][:key].to_s)
-        if details[:symbols] then key = key.to_sym elsif !exists then key = d[:last][:key] end
+        key = details[:symbol_sensitive] || d[:last][:key].is_a?(Regexp) ? d[:last][:key] : (h.include?(d[:last][:key].to_sym) ? d[:last][:key].to_sym : d[:last][:key].to_s)
+        # if details[:symbols] then key = key.to_sym elsif !exists then key = d[:last][:key] end
         if Fixnum === d[:last][:slice]
           h[key][d[:last][:slice]] = d[:value]
         else
@@ -158,27 +160,32 @@ module BBLib
   private
 
     def self.hash_path_analyze path
+      return {key: '', slice: (0..-1), formula: nil} if path == '' || path.nil?
       key = path.scan(/\A.*^[^\[\(\{]*/i).first.to_s
-      if key.encap_by?('/')
+      if key.encap_by?('/') || key.start_with?('/') && key.end_with?('i')
         key = eval(key)
       elsif key.start_with? ':'
         key = key[1..-1].to_sym
       end
       slice = eval(path.scan(/(?<=\[).*?(?=\])/).first.to_s)
-      if !slice.is_a?(Range) && !slice.is_a?(Fixnum) then slice = (0..-1) end
+      no_slice = false
+      formula = path.scan(/(?<=\().*(?=\))/).first
+      if !slice.is_a?(Range) && !slice.is_a?(Fixnum) then slice = (0..-1); no_slice = true end
+      if (key.nil? || key == '') && (!slice.nil? || !no_slice) then key = nil end
       if slice.nil? then slice = (0..-1) end
-      formula = path.scan(/(?<=\().*?(?=\))/).first
-      if key.empty? && slice != (0..-1) then key = nil end
       {key:key, slice:slice, formula:formula}
     end
 
     def self.split_hash_path path, delimiter = '.'
       if path.to_s.start_with?(delimiter) then path = path.to_s.sub(delimiter, '') end
-      paths, stop, open = [], 0, false
+      paths, stop, open, popen, ropen = [], 0, false, false, false
       path.chars.each do |t|
         if t == '[' then open = true end
         if t == ']' then open = false end
-        if t == delimiter && !open then paths << path[0..stop].reverse.sub(delimiter,'').reverse; path = path[stop+1..-1]; stop = -1 end
+        if t == '(' then popen = true end
+        if t == ')' then popen = false end
+        if t == '/' then ropen = !ropen end
+        if t == delimiter && !open && !popen && !ropen then paths << path[0..stop].reverse.sub(delimiter,'').reverse; path = path[stop+1..-1]; stop = -1 end
         stop += 1
       end
       paths << path
@@ -193,7 +200,7 @@ module BBLib
       temp = []
       hashes.flatten.each do |p|
         begin
-          if eval(formula.gsub('$', p.to_s))
+          if eval(p.is_a?(Hash) ? formula.gsub('$', "(#{p})") : formula.gsub('$', p.to_s))
             temp << p
           end
         rescue StandardError, SyntaxError => se
@@ -230,7 +237,7 @@ module BBLib
       symbol_sensitive: {default:false},
       stop_on_nil: {default:true},
       arrays: {default:[]},
-      keys_to_sym: {default:true}
+      keys_to_sym: {default:false}
     }
 
 end
@@ -380,6 +387,42 @@ end
 
 class Array
 
+  def hash_path path, delimiter: '.'
+    BBLib.hash_path self, path, delimiter:delimiter
+  end
+
+  def hash_path_set *args
+    BBLib.hash_path_set self, args
+  end
+
+  def hash_path_copy *args
+    BBLib.hash_path_copy self, args
+  end
+
+  def hash_path_copy_to hash, *args
+    BBLib.hash_path_copy_to self, hash, args
+  end
+
+  def hash_path_move_to hash, *args
+    BBLib.hash_path_move_to self, hash, args
+  end
+
+  def hash_path_move *args
+    BBLib.hash_path_move self, args
+  end
+
+  def hash_path_delete *args
+    BBLib.hash_path_delete self, args
+  end
+
+  def hash_path_keys
+    BBLib.hash_path_keys self
+  end
+
+  def hash_path_exists? path, delimiter: '.', symbol_sensitive: false
+    BBLib.hash_path_exists? self, path, delimiter:delimiter, symbol_sensitive:symbol_sensitive
+  end
+
   def dig keys
     matches = []
     self.each do |i|

data/lib/hash/hash_path_proc.rb

@@ -6,21 +6,28 @@ class Hash
   end
 end
 
+class Array
+  def hash_path_proc action, paths, *args, **params
+    BBLib.hash_path_proc self, action, paths, *args, **params
+  end
+end
+
 module BBLib
 
   def self.hash_path_proc hash, action, paths, *args, **params
     action = HASH_PATH_PROC_TYPES.keys.find{ |k| k == action || HASH_PATH_PROC_TYPES[k][:aliases].include?(action) }
     return nil unless action
     paths.to_a.each do |path|
-      value = hash.hash_path(path).first
-      if params.include?(:condition) && params[:condition]
-        begin
-          next unless eval(params[:condition].gsub('$', value.to_s))
-        rescue
-          next
+      hash.hash_path(path).each do |value|
+        if params.include?(:condition) && params[:condition]
+          begin
+            next unless eval(params[:condition].gsub('$', value.to_s))
+          rescue StandardError, SyntaxError => e
+            next
+          end
         end
+        HashPath.send(action, hash, path, value, *args, **params)
       end
-      HashPath.send(action, hash, path, value, *args, **params)
     end
     return hash
   end
@@ -35,22 +42,34 @@ module BBLib
     extract_first: {aliases: [:grab_first, :scan_first]},
     extract_last: {aliases: [:grab_last, :scan_last]},
     parse_date: { aliases: [:date, :parse_time, :time]},
+    parse_date_unix: { aliases: [:unix_time, :unix_date]},
     parse_duration: { aliases: [:duration]},
     parse_file_size: { aliases: [:file_size]},
     to_string: {aliases: [:to_s, :stringify]},
     downcase: { aliases: [:lower, :lowercase, :to_lower]},
     upcase: { aliases: [:upper, :uppercase, :to_upper]},
-    # titlecase: { aliases: [:title_case]},
     roman: { aliases: [:convert_roman, :roman_numeral, :parse_roman]},
     remove_symbols: { aliases: [:chop_symbols, :drop_symbols]},
     format_articles: { aliases: [:articles]},
     reverse: { aliases: [:invert]},
     delete: { aliases: [:del]},
     remove: { aliases: [:rem]},
-    custom: {aliases: [:send]}
+    custom: {aliases: [:send]},
+    # TODO
+    # titlecase: { aliases: [:title_case]},
+    encapsulate: {aliases: []},
+    uncapsulate: {aliases: []},
+    extract_integers: {aliases: [:extract_ints]},
+    extract_floats: {aliases: []},
+    extract_numbers: {aliases: []},
+    max_number: {aliases: [:max, :maximum, :maximum_number]},
+    min_number: {aliases: [:min, :minimum, :minimum_number]},
+    avg_number: {aliases: [:avg, :average, :average_number]},
+    sum_number: {aliases: [:sum]},
+    strip: {aliases: [:trim]},
     # rename: { aliases: [:rename_key]},
-    # concat: { aliases: [:join, :concat_with]},
-    # reverse_concat: { aliases: [:reverse_join, :reverse_concat_with]}
+    concat: { aliases: [:join, :concat_with]},
+    reverse_concat: { aliases: [:reverse_join, :reverse_concat_with]}
   }
 
   module HashPath
@@ -74,13 +93,13 @@ module BBLib
 
     def self.replace hash, path, value, args, params
       value = value.dup.to_s
-      args.each{ |k,v| value.gsub!(k.to_s, v.to_s) }
+      args.each{ |k,v| value.gsub!(k, v.to_s) }
       hash.hash_path_set path => value
     end
 
     def self.extract hash, path, value, *args, **params
       slice = (Array === args && args[1].nil? ? (0..-1) : args[1])
-      hash.hash_path_set path => value.scan(args.first)[slice]
+      hash.hash_path_set path => value.to_s.scan(args.first)[slice]
     end
 
     def self.extract_first hash, path, value, *args, **params
@@ -108,6 +127,23 @@ module BBLib
       hash.hash_path_set path => formatted
     end
 
+    def self.parse_date_unix hash, path, value, *args, **params
+      format = params.include?(:format) ? params[:format] : '%Y-%m-%d %H:%M:%S'
+      formatted = nil
+      args.each do |pattern|
+        next unless formatted.nil?
+        begin
+          formatted = Time.strptime(value.to_s, pattern.to_s).strftime(format)
+        rescue
+        end
+      end
+      begin
+        if formatted.nil? then formatted = Time.parse(value) end
+      rescue
+      end
+      hash.hash_path_set path => formatted.to_f
+    end
+
     def self.parse_duration hash, path, value, args, params
       hash.hash_path_set path => value.to_s.parse_duration(output: args.empty? ? :sec : args )
     end
@@ -155,7 +191,64 @@ module BBLib
     end
 
     def self.custom hash, path, value, *args, **params
-      hash.hash_path_set path => value.send(*args)
+      if params.nil? || params.empty?
+        hash.hash_path_set path => value.send(*args)
+      else
+        hash.hash_path_set path => value.send(*args, **params)
+      end
+    end
+
+    def self.encapsulate hash, path, value, args, **params
+      hash.hash_path_set path => "#{args}#{value}#{args}"
+    end
+
+    def self.uncapsulate hash, path, value, args, **params
+      value = value[args.size..-1] if value.start_with?(args)
+      value = value[0..-(args.size)-1] if value.end_with?(args)
+      hash.hash_path_set path => value
+    end
+
+    def self.max_number hash, path, value, *args, **params
+      hash.hash_path_set path => value.to_s.extract_numbers.max
+    end
+
+    def self.min_number hash, path, value, *args, **params
+      hash.hash_path_set path => value.to_s.extract_numbers.min
+    end
+
+    def self.avg_number hash, path, value, *args, **params
+      nums = value.to_s.extract_numbers
+      avg = nums.inject{ |s, x| s + x }.to_f / nums.size.to_f
+      hash.hash_path_set path => avg
+    end
+
+    def self.sum_number hash, path, value, *args, **params
+      hash.hash_path_set path => value.to_s.extract_numbers.inject{ |s,x| s + x }
+    end
+
+    def self.strip hash, path, value, args, **params
+      value.map!{ |m| m.respond_to?(:strip) ? m.strip : m } if value.is_a?(Array)
+      hash.hash_path_set path => (value.respond_to?(:strip) ? value.strip : value)
+    end
+
+    def self.extract_integers hash, path, value, args, **params
+      hash.hash_path_set path => (value.extract_integers)
+    end
+
+    def self.extract_floats hash, path, value, args, **params
+      hash.hash_path_set path => (value.extract_floats)
+    end
+
+    def self.extract_numbers hash, path, value, args, **params
+      hash.hash_path_set path => (value.extract_numbers)
+    end
+
+    def self.concat hash, path, value, *args, **params
+      hash.hash_path_set path => "#{value}#{params[:join]}#{hash.hash_path(args.first)[params[:range].nil? ? 0 : params[:range]]}"
+    end
+
+    def self.reverse_concat hash, path, value, *args, **params
+      hash.hash_path_set path => "#{hash.hash_path(args.first)[params[:range].nil? ? 0 : params[:range]]}#{params[:join]}#{value}"
     end
 
   end

data/lib/string/bbstring.rb

@@ -1,7 +1,8 @@
 
-require_relative 'matching.rb'
-require_relative 'roman.rb'
-require_relative 'fuzzy_matcher.rb'
+require_relative 'matching'
+require_relative 'roman'
+require_relative 'fuzzy_matcher'
+require_relative 'cases'
 
 module BBLib
 
@@ -9,11 +10,7 @@ module BBLib
   # General Functions
   ##############################################
 
-  # def self.title_case str
-    # TODO
-  # end
-
-  # Quickly remove any symbols from a string leaving onl alpha-numeric characters and white space.
+  # Quickly remove any symbols from a string leaving only alpha-numeric characters and white space.
   def self.drop_symbols str
     str.gsub(/[^\w\s\d]|_/, '')
   end
@@ -28,9 +25,9 @@ module BBLib
     BBLib.extract_numbers(str, convert:false).reject{ |r| !r.include?('.') }.map{ |m| convert ? m.to_f : m }
   end
 
-  # Alias for extract_floats
+  # Extracts any correctly formed integers or floats from a string
   def self.extract_numbers str, convert: true
-    str.scan(/\d+\.?\d+|\d+/).map{ |f| convert ? (f.include?('.') ? f.to_f : f.to_i) : f }
+    str.scan(/\d+\.\d+[^\.]|\d+[^\.]/).map{ |f| convert ? (f.include?('.') ? f.to_f : f.to_i) : f }
   end
 
   # Used to move the position of the articles 'the', 'a' and 'an' in strings for normalization.
@@ -109,12 +106,13 @@ class String
 
   # Simple method to convert a string into an array containing only itself
   def to_a
-    return [self]
+    [self]
   end
 
   def encap_by? str
-    return self.start_with?(str) && self.end_with?(str)
+    self.start_with?(str) && self.end_with?(str)
   end
+
 end
 
 class Symbol

data/lib/string/cases.rb

@@ -0,0 +1,96 @@
+module BBLib
+
+  def self.title_case str, first_only: true
+    ignoreables = ['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
+      else
+        if first_only
+          word[0] = word[0].upcase
+          word
+        else
+          word.capitalize
+        end
+      end
+    end
+    # Always cap the first word
+    words.first.capitalize
+    words.interleave(spacing).join
+  end
+
+  def self.start_case str, first_only: false
+    regx = /[[:space:]]+|\-|\_|\"|\'|\(|\)|\[|\]|\{|\}|\#/
+    spacing = str.scan(regx).to_a
+    words = str.split(regx).map do |word|
+      if first_only
+        word[0] = word[0].upcase
+        word
+      else
+        word.capitalize
+      end
+    end
+    words.interleave(spacing).join
+  end
+
+  def self.camel_case str, style = :lower
+    regx = /[[:space:]]+|[^[[:alnum:]]]+/
+    words = str.split(regx).map do |word|
+      word.capitalize
+    end
+    words[0].downcase! if style == :lower
+    words.join
+  end
+
+  def self.delimited_case str, delimiter = '_'
+    regx = /[[:space:]]+|[^[[:alnum:]]]+|#{delimiter}+/
+    words = str.split(regx).join(delimiter)
+  end
+
+  def self.snake_case str
+    BBLib.delimited_case str, '_'
+  end
+
+  def self.spinal_case str
+    BBLib.delimited_case str, '-'
+  end
+
+  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
+  end
+
+  def start_case first_only: false
+    BBLib.start_case self, first_only:first_only
+  end
+
+  def camel_case style = :lower
+    BBLib.camel_case self, style
+  end
+
+  def delimited_case delimiter = '_'
+    BBLib.delimited_case self, delimiter
+  end
+
+  def snake_case
+    BBLib.snake_case self
+  end
+
+  def spinal_case
+    BBLib.spinal_case self
+  end
+
+  def train_case
+    BBLib.train_case self
+  end
+
+end

data/lib/string/fuzzy_matcher.rb

@@ -2,20 +2,21 @@
 module BBLib
 
   class FuzzyMatcher
-    attr_reader :threshold
-    attr_accessor :case_sensitive, :remove_symbols, :move_articles, :convert_roman
+    attr_reader :threshold, :algorithms
+    attr_accessor :case_sensitive, :remove_symbols, :move_articles, :convert_roman, :a, :b
 
     def initialize threshold: 75, case_sensitive: true, remove_symbols: false, move_articles: false, convert_roman: true
       self.threshold = threshold
+      setup_algorithms
       @case_sensitive, @remove_symbols, @move_articles, @convert_roman = case_sensitive, remove_symbols, move_articles, convert_roman
     end
 
     # Calculates a percentage match between string a and string b.
     def similarity a, b
-      return 100.0 if a == b
       prep_strings a, b
-      score, total_weight = 0, ALGORITHMS.map{|a, v| v[:weight] }.inject{ |sum, w| sum+=w }
-      ALGORITHMS.each do |algo, vals|
+      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]
       end
@@ -44,23 +45,25 @@ module BBLib
     end
 
     def set_weight algorithm, weight
-      return nil unless ALGORITHMS.include? algorithm
-      ALGORITHMS[algorithm] = BBLib.keep_between(weight, 0, nil)
+      return nil unless @algorithms.include? algorithm
+      @algorithms[algorithm][:weight] = BBLib.keep_between(weight, 0, nil)
     end
 
     def algorithms
-      ALGORITHMS.keys
+      @algorithms.keys
     end
 
     private
 
-      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}
-      }
+      def setup_algorithms
+        @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 prep_strings a, b
         @a, @b = a.to_s.dup.strip, b.to_s.dup.strip

data/lib/string/matching.rb

@@ -26,7 +26,7 @@ module BBLib
   # 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
+    matches, temp = 0, b.dup
     a.chars.each do |c|
       if temp.chars.include? c
         matches+=1
@@ -53,7 +53,7 @@ module BBLib
   # Percentage calculations here need to be weighted better...TODO
   def self.numeric_similarity a, b
     a, b = a.extract_numbers, b.extract_numbers
-    return 100.0 if a.empty? && b.empty?
+    return 100.0 if a.empty? && b.empty? || a == b
     matches = []
     for i in 0..[a.size, b.size].max-1
       matches << 1.0 / ([a[i].to_f, b[i].to_f].max - [a[i].to_f, b[i].to_f].min + 1.0)

data/lib/time/bbtime.rb

@@ -1,10 +1,25 @@
 require_relative 'task_timer'
+require_relative 'cron'
 
 module BBLib
 
   # Parses known time based patterns out of a string to construct a numeric duration.
-  def self.parse_duration str, output: :sec
+  def self.parse_duration str, output: :sec, min_interval: :sec
     msecs = 0.0
+
+    # Parse time expressions such as 04:05.
+    # The argument min_interval controls what time interval the final number represents
+    str.scan(/\d+\:[\d+\:]+\d+/).each do |e|
+      keys = TIME_EXPS.keys
+      position = keys.index(min_interval)
+      e.split(':').reverse.each do |sec|
+        key = keys[position]
+        msecs+= sec.to_f * TIME_EXPS[key][:mult]
+        position+=1
+      end
+    end
+
+    # Parse expressions such as '1m' or '1 min'
     TIME_EXPS.each do |k, v|
       v[:exp].each do |e|
         numbers = str.downcase.scan(/(?=\w|\D|\A)\d*\.?\d+[[:space:]]*#{e}(?=\W|\d|\z)/i)
@@ -13,6 +28,7 @@ module BBLib
         end
       end
     end
+
     msecs / (TIME_EXPS[output][:mult] rescue 1)
   end
 
@@ -108,8 +124,8 @@ module BBLib
 end
 
 class String
-  def parse_duration output: :sec
-    BBLib.parse_duration self, output:output
+  def parse_duration output: :sec, min_interval: :sec
+    BBLib.parse_duration self, output:output, min_interval:min_interval
   end
 end
 

data/lib/time/cron.rb

@@ -0,0 +1,171 @@
+module BBLib
+
+  class Cron
+    attr_reader :exp, :parts, :time
+
+    def initialize exp
+      @parts = Hash.new
+      self.exp = exp
+    end
+
+    def closest exp = @exp, direction:1, count: 1, time: Time.now
+      if exp then self.exp = exp end
+      results = []
+      return results unless @exp
+      (1..count).each{ |i| results.push next_time(i == 1 ? time : results.last, direction) }
+      count <= 1 ? results.first : results.reject{ |r| r.nil? }
+    end
+
+    def next exp = @exp, count: 1, time: Time.now
+      closest exp, count:count, time:time, direction:1
+    end
+
+    def prev exp = @exp, count: 1, time: Time.now
+      closest exp, count:count, time:time, direction:-1
+    end
+
+    def exp= e
+      SPECIAL_EXP.each{ |x, v| if v.include?(e) then e = x end }
+      @exp = e
+      parse
+    end
+
+    def self.next exp, count: 1, time: Time.now
+      t = BBLib::Cron.new(exp).next(count:count, time:time)
+    end
+
+    def self.prev exp, count: 1, time: Time.now
+      BBLib::Cron.new(exp).prev(count:count, time:time)
+    end
+
+    def self.valid? exp
+      !(numeralize(exp) =~ /\A(.*?\s){4,5}.*?\S\z/).nil?
+    end
+
+    def valid? exp
+      BBLib::Cron.valid?(exp)
+    end
+
+    private
+
+      def parse
+        return nil unless @exp
+        pieces, i = @exp.split(' '), 0
+        PARTS.each do |part, info|
+          @parts[part] = parse_cron_numbers(pieces[i], info[:min], info[:max], Time.now.send(info[:send]))
+          i+=1
+        end
+      end
+
+      def self.numeralize exp
+        exp = exp.to_s.downcase
+        REPLACE.each do |k, v|
+          v.each do |r|
+            exp.gsub!(r.to_s, k.to_s)
+          end
+        end
+        exp
+      end
+
+      def parse_cron_numbers exp, min, max, qmark
+        numbers = Array.new
+        exp = Cron.numeralize(exp)
+        exp.gsub!('?', qmark.to_s)
+        exp.scan(/\*\/\d+|\d+\/\d+|\d+-\d+\/\d+/).each do |s|
+          range, divisor = s.split('/').first, s.split('/').last.to_i
+          if range == '*'
+            range = (min..max)
+          elsif range =~ /\d+\-\d+/
+            range = (range.split('-').first.to_i..range.split('-').last.to_i)
+          else
+            range = (range.to_i..max)
+          end
+          index = 0
+          range.each do |i|
+            if index == 0 || index % divisor.to_i == 0
+              numbers.push i
+            end
+            index+=1
+          end
+          exp.sub!(s, '')
+        end
+        numbers.push exp.scan(/\d+/).map{ |m| m.to_i }
+        exp.strip.scan(/\d+\-\d+/).each do |e|
+          nums = e.scan(/\d+/).map{ |n| n.to_i }
+          numbers.push (nums.min..nums.max).map{ |n| n }
+        end
+        numbers.flatten!.sort!
+        numbers.uniq.reject{ |r| r < min || r > max }
+      end
+
+      def next_day time, direction
+        return nil unless time
+        weekdays, days, months, years = @parts[:weekday], @parts[:day], @parts[:month], @parts[:year]
+        date, safety = nil, 0
+        while date.nil? && safety < 50000
+          if (days.empty? || days.include?(time.day)) && (months.empty? || months.include?(time.month)) && (years.empty? || years.include?(time.year)) && (weekdays.empty? || weekdays.include?(time.wday))
+            date = time
+          else
+            time+= 24*60*60*direction
+            # time = Time.new(time.year, time.month, time.day, 0, 0)
+          end
+          safety+=1
+        end
+        return nil if safety == 50000
+        time
+      end
+
+      def next_time time, direction
+        orig, fw = time.to_f, (direction == 1)
+        current = next_day(time, direction)
+        return nil unless current
+        if (fw ? current.to_f > orig : current.to_f < orig)
+          current = Time.new(current.year, current.month, current.day, (fw ? 0 : 23), (fw ? 0 : 59))
+        else
+          current+= (fw ? 60 : -60)
+        end
+        while !@parts[:day].empty? && !@parts[:day].include?(current.day) || !@parts[:hour].empty? && !@parts[:hour].include?(current.hour) || !@parts[:minute].empty? && !@parts[:minute].include?(current.min)
+          day = [current.day, current.month, current.year]
+          current+= (fw ? 60 : -60)
+          if day != [current.day, current.month, current.year] then current = next_day(current, direction) end
+          return nil unless current
+        end
+        current - current.sec
+      end
+
+      PARTS = {
+        minute: {send: :min, min:0, max:59, size: 60},
+        hour: {send: :hour, min:0, max:23, size: 60*60},
+        day: {send: :day, min:1, max:31, size: 60*60*24},
+        month: {send: :month, min:1, max:12},
+        weekday: {send: :wday, min:0, max:6},
+        year: {send: :year, min:0, max:90000}
+      }
+
+      REPLACE = {
+        1 => [:sunday, :sun, :january, :jan],
+        2 => [:monday, :mon, :february, :feb],
+        3 => [:tuesday, :tues, :tue, :march, :mar],
+        4 => [:wednesday, :wednes, :wed, :april, :apr],
+        5 => [:thursday, :thurs, :thu, :may],
+        6 => [:friday, :fri, :june, :jun],
+        7 => [:saturday, :sat, :july, :jul],
+        8 => [:august, :aug],
+        9 => [:september, :sept, :sep],
+        10 => [:october, :oct],
+        11 => [:november, :nov],
+        12 => [:december, :dec]
+      }
+
+      SPECIAL_EXP = {
+        '0 0 * * * *' => ['@daily', '@midnight', 'daily', 'midnight'],
+        '0 12 * * * *' => ['@noon', 'noon'],
+        '0 0 * * 0 *' => ['@weekly', 'weekly'],
+        '0 0 1 * * *' => ['@monthly', 'monthly'],
+        '0 0 1 1 * *' => ['@yearly', '@annually', 'yearly', 'annually'],
+        '? ? ? ? ? ?' => ['@reboot', '@restart', 'reboot', 'restart']
+      }
+
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bblib
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Brandon Black
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-02-12 00:00:00.000000000 Z
+date: 2016-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,10 +80,12 @@ files:
 - lib/number/bbnumber.rb
 - lib/object/bbobject.rb
 - lib/string/bbstring.rb
+- lib/string/cases.rb
 - lib/string/fuzzy_matcher.rb
 - lib/string/matching.rb
 - lib/string/roman.rb
 - lib/time/bbtime.rb
+- lib/time/cron.rb
 - lib/time/task_timer.rb
 homepage: https://github.com/bblack16/bblib-ruby
 licenses: