bblib 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f7b1504ef918ed9ec7c63df50cf267714f4fffed
-  data.tar.gz: b9627fa1e26c9932a4c0e8301134560a90e2caab
+  metadata.gz: 46227889fa2341b852f07f10dd28892a0770b759
+  data.tar.gz: f7e8f2dae0ba5148cb77d0ec7086c87806dce3c7
 SHA512:
-  metadata.gz: ad8d53750aa9b2842b63cccf814be382468f426f7360e41ff97ca37790a18790110e1f4cff275685982cf2e46b50957e1d8140c2a008eef8c32f695ca5cf11f4
-  data.tar.gz: e1841e600e35928460e7320800f39858e7e5d2cc2d2920e7d1afa4cbf9628160d1d49df9e2c43c2a385bf11d83de83824189039f98f020d91df6a63c1a882e36
+  metadata.gz: 45f56290f00c86f5ead9f13746fe76104d87698bfd8b99a89abc2fc1660b4dc4137fb0bb85d50ed9dc8bfcfb0e987b1bef83e41e40c9599eb2205b2809a0cc7a
+  data.tar.gz: 50f0e4937c9857b0f66c14b748a74fec84bd835da790e01c64774005e7d9f9f24a58e0e96f2204cfcaf65a690e1ae5ce0d3eec40c0b76e9a25623f1824f6fd60

data/.gitignore

@@ -7,4 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
-/.gem
+*.gem

data/lib/array/bbarray.rb

@@ -0,0 +1,15 @@
+
+
+class Array
+  def msplit *delims, keep_empty: false
+    self.map{ |i| i.msplit(delims, keep_empty:keep_empty)}.flatten
+  end
+
+  def keys_to_sym clean: false
+    self.map{ |v| Hash === v || Array === v ? v.keys_to_sym(clean:clean) : v }
+  end
+
+  def keys_to_s clean: false
+    self.map{ |v| Hash === v || Array === v ? v.keys_to_s : v }
+  end
+end

data/lib/bblib.rb

@@ -3,8 +3,12 @@ require_relative "string/bbstring"
 require_relative "file/bbfile"
 require_relative "time/bbtime"
 require_relative "hash/bbhash"
-require_relative "math/bbmath"
+require_relative "number/bbnumber"
+require_relative "object/bbobject"
+require_relative "array/bbarray"
 require 'fileutils'
+require 'net/http'
+require 'uri'
 
 module BBLib
 

data/lib/bblib/version.rb

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

data/lib/file/bbfile.rb

@@ -23,11 +23,12 @@ module BBLib
   end
 
   # Shorthand method to write a string to dist. By default the path is created if it doesn't exist.
-  def self.string_to_file path, str, mkpath = true
+  # Set mode to w to truncate file or leave at a to append.
+  def self.string_to_file path, str, mkpath = true, mode: 'a'
     if !Dir.exists?(path) && mkpath
       FileUtils.mkpath File.dirname(path)
     end
-    File.write(path, str.to_s)
+    File.write(path, str.to_s, mode:mode)
   end
 
   # A file size parser for strings. Extracts any known patterns for file sizes.
@@ -36,7 +37,7 @@ module BBLib
     bytes = 0.0
     FILE_SIZES.each do |k, v|
       v[:exp].each do |e|
-        numbers = str.scan(/(?=\w|\D|\A)\d?\.?\d+[[:space:]]*#{e}s?(?=\W|\d|\z)/i)
+        numbers = str.scan(/(?=\w|\D|\A)\d*\.?\d+[[:space:]]*#{e}s?(?=\W|\d|\z)/i)
         numbers.each{ |n| bytes+= n.to_f * v[:mult] }
       end
     end
@@ -64,8 +65,8 @@ class File
 end
 
 class String
-  def to_file path, mkpath = true
-    BBLib.string_to_file path, self, mkpath
+  def to_file path, mkpath = true, mode: 'a'
+    BBLib.string_to_file path, self, mkpath, mode:mode
   end
 
   def file_name with_extension = true

data/lib/hash/bbhash.rb

@@ -1,5 +1,9 @@
+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
@@ -13,12 +17,23 @@ class Hash
 
   # Converts the keys of the hash as well as any nested hashes to symbols.
   # Based on method found @ http://stackoverflow.com/questions/800122/best-way-to-convert-strings-to-symbols-in-hash
-  def keys_to_sym
-    self.inject({}){|memo,(k,v)| memo[k.to_sym] = (Hash === v ? v.keys_to_sym : v); memo}
+  def keys_to_sym clean: false
+    self.inject({}){|memo,(k,v)| memo[clean ? k.to_s.to_clean_sym : k.to_s.to_sym] = (Hash === v || Array === v ? v.keys_to_sym(clean:clean) : v); memo}
+    # self.inject({}){|memo,(k,v)| memo[clean ? k.to_s.to_clean_sym : k.to_s.to_sym] = (Hash === v ? v.keys_to_sym : (Array === v ? v.flatten.map{ |a| Hash === a ? a.keys_to_sym : a } : v) ); memo}
+  end
+
+  def keys_to_sym! clean: false
+    replace(self.keys_to_sym clean:clean)
   end
 
-  def keys_to_sym!
-    replace self.keys_to_sym
+  # Converts the keys of the hash as well as any nested hashes to strings.
+  def keys_to_s
+    self.inject({}){|memo,(k,v)| memo[k.to_s] = (Hash === v || Array === v ? v.keys_to_s : v); memo}
+    # self.inject({}){|memo,(k,v)| memo[k.to_s] = (Hash === v ? v.keys_to_s : (Array === v ? v.flatten.map{ |a| Hash === a ? a.keys_to_s : a } : v)); memo}
+  end
+
+  def keys_to_s!
+    replace(self.keys_to_s)
   end
 
   # Reverses the order of keys in the Hash
@@ -30,4 +45,9 @@ class Hash
     replace self.reverse
   end
 
+  def unshift hash, value = nil
+    if !hash.is_a? Hash then hash = {hash => value} end
+    replace hash.merge(self).merge(hash)
+  end
+
 end

data/lib/hash/hash_path.rb

@@ -0,0 +1,391 @@
+require_relative 'hash_path_proc'
+
+module BBLib
+
+  def self.hash_path hashes, path, recursive: false, delimiter: '.', symbol_sensitive: false
+    if String === path then path = BBLib.split_and_analyze(path, delimiter) end
+    if !hashes.is_a? Array then hashes = [hashes] end
+    return hashes if path.nil? || path.empty?
+    if path[0][:key] == '' then return BBLib.hash_path(hashes, path[1..-1], recursive: true, symbol_sensitive:symbol_sensitive) end
+    matches, p = Array.new, path.first
+    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]]
+      else
+        if p[:key].nil?
+          if hash.is_a?(Array) then matches << hash[p[:slice]] end
+        elsif Symbol === p[:key] || String === p[:key]
+          if p[:key].to_s == '*'
+            matches.push hash.values.flatten(1)[p[:slice]]
+          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 ))
+            matches.push mat.is_a?(Array) ? mat[p[:slice]] : mat
+          end
+        elsif Regexp === p[:key]
+          hash.keys.find_all{ |k| k =~ p[:key] }.each{ |m| matches << hash[m] }
+        end
+      end
+    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)
+    end
+  end
+
+  def self.hash_path_set hash, *args
+    details = BBLib.hash_path_setup(hash, args)
+    count = 0
+    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) ))
+        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
+        if Fixnum === d[:last][:slice]
+          h[key][d[:last][:slice]] = d[:value]
+        else
+          if h.is_a?(Hash)
+            h[key] = d[:value]
+          end
+        end
+      end
+      if count == 0 && details[:bridge] then hash.bridge(path, value:d[:value], symbols:details[:symbols]) end
+    end
+    hash
+  end
+
+  def self.hash_path_exists? hash, path, delimiter: '.', symbol_sensitive: false
+    return !BBLib.hash_path(hash, path, delimiter:delimiter, symbol_sensitive:symbol_sensitive).empty?
+  end
+
+  def self.hash_path_move hash, *args
+    BBLib.hash_path_copy hash, args
+    details = BBLib.hash_path_setup(hash, args)
+    opts = Hash.new
+    details.each do |k, v|
+      if HASH_PATH_PARAMS.include?(k) then opts[k] = v end
+    end
+    BBLib.hash_path_delete hash, [details[:paths].keys, opts ].flatten
+    return hash
+  end
+
+  def self.hash_path_move_to from, to, *args
+    BBLib.hash_path_copy_to from, to, args
+    BBLib.hash_path_delete from, args
+    return to
+  end
+
+  def self.hash_path_copy hash, *args
+    details = BBLib.hash_path_setup(hash, args)
+    details[:paths].each do |path, d|
+      d[:hashes].each do |h|
+        if Hash === h || Array === h
+          exist = details[:symbol_sensitive] ? h.include?(d[:last][:key]) : (h.include?(d[:last][:key].to_sym) || h.include?(d[:last][:key].to_s) )
+          next unless exist || details[:bridge]
+          value = details[:symbol_sensitive] ? h[d[:last][:key]] : (if h.include?(d[:last][:key].to_sym) then h[d[:last][:key].to_sym] else h[d[:last][:key].to_s] end )
+          if value
+            BBLib.hash_path_set hash, d[:value] => value, symbols:details[:symbols]
+          end
+        elsif !details[:stop_on_nil]
+          BBLib.hash_path_set hash, d[:value] => nil, symbols:details[:symbols]
+        end
+      end
+    end
+    hash
+  end
+
+  def self.hash_path_copy_to from, to, *args
+    details = BBLib.hash_path_setup(from, args)
+    details[:paths].each do |path, d|
+      value = from.hash_path(path)
+      if !value.empty? || !details[:stop_on_nil]
+        if !details[:arrays].include?(d[:value]) then value = value.first end
+        to = to.bridge(d[:value], value: value, symbols:details[:symbols])
+      end
+    end
+    to
+  end
+
+  def self.hash_path_delete hash, *args
+    args.flatten!
+    details = BBLib.hash_path_setup hash, [args.find{ |f| Hash === f }.to_h.merge(args.find_all{ |a| String === a }.zip([]).to_h)]
+    deleted = []
+    details[:paths].each do |path, d|
+      d[:hashes].each do |h|
+        next unless details[:symbol_sensitive] ? h.include?(d[:last][:key]) : (h.include?(d[:last][:key].to_sym) || h.include?(d[:last][:key].to_s) )
+        if Fixnum === d[:last][:slice]
+          (details[:symbol_sensitive] ? h[d[:last][:key]] : (if h.include?(d[:last][:key].to_sym) then h[d[:last][:key].to_sym] else h[d[:last][:key].to_s] end)).delete_at d[:last][:slice]
+        else
+          if details[:symbol_sensitive]
+            deleted << h.delete(d[:last][:key])
+          else
+            if h.include?(d[:last][:key].to_sym) then deleted << h.delete(d[:last][:key].to_sym) end
+            if h.include?(d[:last][:key].to_s) then deleted << h.delete(d[:last][:key].to_s) end
+          end
+        end
+      end
+    end
+    return deleted.flatten
+  end
+
+  def self.hash_path_keys hash
+    hash.squish.keys
+  end
+
+  def self.hash_path_key_for hash, value
+    hash.squish.find_all{ |k,v| v == value }.to_h.keys
+  end
+
+  def self.path_nav obj, path = '', delimiter = '.', &block
+    case [obj.class]
+    when [Hash]
+      obj.each{ |k,v| path_nav v, "#{path}#{path.nil? || path.empty? ? nil : delimiter}#{k}", delimiter, &block }
+    when [Array]
+      index = 0
+      obj.each{ |o| path_nav o, "#{path}#{path.end_with?(']') ? delimiter : nil}[#{index}]", delimiter, &block ; index+=1 }
+    else
+      yield path, obj
+    end
+  end
+
+  private
+
+    def self.hash_path_analyze path
+      key = path.scan(/\A.*^[^\[\(\{]*/i).first.to_s
+      if key.encap_by?('/')
+        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
+      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
+      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
+        stop += 1
+      end
+      paths << path
+    end
+
+    def self.split_and_analyze path, delimiter = '.'
+      split_hash_path(path, delimiter).collect{ |p| hash_path_analyze(p) }
+    end
+
+    def self.analyze_hash_path_formula formula, hashes
+      return hashes unless formula
+      temp = []
+      hashes.flatten.each do |p|
+        begin
+          if eval(formula.gsub('$', p.to_s))
+            temp << p
+          end
+        rescue StandardError, SyntaxError => se
+          # Do nothing, the formula failed and we reject the value as a false
+        end
+      end
+      temp
+    end
+
+    def self.hash_path_setup hash, *args
+      args.flatten!
+      return nil unless args && args[0].class == Hash
+      info = Hash.new
+      info[:paths] = Hash.new
+      map = args[0].dup
+      HASH_PATH_PARAMS.each do |p, h|
+        info[p] = (map.include?(p) ? map.delete(p) : h[:default])
+      end
+      if info[:keys_to_sym] then hash.keys_to_sym! end
+      map.each do |path, value|
+        info[:paths][path] = Hash.new
+        info[:paths][path][:value] = value
+        info[:paths][path][:paths] = BBLib.split_hash_path(path, info[:delimiter])
+        info[:paths][path][:last] = BBLib.hash_path_analyze info[:paths][path][:paths].last
+        info[:paths][path][:hashes] = BBLib.hash_path(hash, info[:paths][path][:paths][0..-2].join(info[:delimiter]), delimiter:info[:delimiter], symbol_sensitive:info[:symbol_sensitive] )
+      end
+      return info
+    end
+
+    HASH_PATH_PARAMS = {
+      delimiter: {default:'.'},
+      bridge: {default:true},
+      symbols: {default:true},
+      symbol_sensitive: {default:false},
+      stop_on_nil: {default:true},
+      arrays: {default:[]},
+      keys_to_sym: {default:true}
+    }
+
+end
+
+
+
+class Hash
+
+  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
+
+  # Returns all matching values with a specific key (or Array of keys) recursively within a Hash (including nested Arrays)
+  def dig keys, search_arrays: true
+    keys = [keys].flatten
+    matches = []
+    self.each do |k, v|
+      if keys.any?{ |a| (a.is_a?(Regexp) ? a =~ k : a == k ) } then matches << v end
+      if v.is_a? Hash
+        matches+= v.dig(keys)
+      elsif v.is_a?(Array) && search_arrays
+        v.flatten.each{ |i| if i.is_a?(Hash) then matches+= i.dig(keys) end }
+      end
+    end
+    matches
+  end
+
+  # Turns nested values' keys into delimiter separated paths
+  def squish delimiter: '.', path_start: nil
+    sh = Hash.new
+    BBLib.path_nav(self.dup, path_start, delimiter){ |k, v| sh[k] = v }
+    sh
+  end
+
+  # Expands keys in a hash using a delimiter. Opposite of squish.
+  def expand delimiter: '.', symbols: false
+    eh = Hash.new
+    self.dup.each do |k,v|
+      eh.bridge k, delimiter: delimiter, value:v, symbols: true
+    end
+    return eh
+  end
+
+  # Builds out a shell of a hash path using a delimited path. Use value to set a value.
+  def bridge path, delimiter: '.', value: nil, symbols: false
+    # Ensure the path is a delimiter string. This supports arrays being passed in
+    path = (path.is_a?(Array) ? path.join(delimiter) : path.to_s)
+    #Generate the paths and set the current variable
+    current, paths = self, BBLib.split_and_analyze(path, delimiter)
+    # If symbols is true, then all keys are turned into symbols
+    if symbols then paths.each{ |p| p[:key] = p[:key].to_s.to_sym } end
+    # Check to see if there is only one path. If there is return either an Array of Hash
+    if paths.size == 1
+      # If the first value is a slice the value is inserted into an empty array
+      if Fixnum === paths.first[:slice]
+        current[paths.first[:key]] = ([].insert paths.first[:slice], value )
+        return self
+      end
+      # If the value does not have a slice, a hash with a single key-value pair is returned
+      current[paths.first[:key]] = value
+      return self
+    end
+    index, count = -1, 0
+    paths.each do |p|
+      count+=1
+      last = paths.size == count
+      if p[:slice].is_a?(Fixnum)
+        index = p[:slice]
+        if paths[count-2] && Fixnum === paths[count-2][:slice]
+          current[paths[count-2][:slice]] = current[paths[count-2][:slice]] ||= Array.new
+          current = current[paths[count-2][:slice]]
+        else
+          if current[p[:key]].nil?
+            current[p[:key]] = []
+          end
+            current = current[p[:key]]
+        end
+        if last then current[index] = value end
+      else
+        if current.is_a?(Hash)
+          if last
+            current[p[:key]] = value
+          else
+            current[p[:key]] = current[p[:key]] ||= Hash.new
+          end
+          current = current[p[:key]]
+        else
+          if last
+            if current[index]
+              if current[index].is_a? Hash
+                current[index].merge({p[:key] => value})
+              else
+                current[index] = ({p[:key] => value})
+              end
+            else
+              current.insert index, {p[:key] => value}
+            end
+          else
+            temp = { p[:key] => {} }
+            if current[index].is_a? Hash
+              current[index].merge!(temp)
+            else
+              current[index] = temp
+            end
+          end
+          if !last then current = temp[p[:key]] end
+        end
+        index = -1
+      end
+    end
+    return self
+  end
+
+end
+
+class Array
+
+  def dig keys
+    matches = []
+    self.each do |i|
+      matches << i.dig(keys) if i.is_a?(Hash) || i.is_a?(Array)
+    end
+    matches
+  end
+
+end

data/lib/hash/hash_path_proc.rb

@@ -0,0 +1,163 @@
+require 'time'
+
+class Hash
+  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
+        end
+      end
+      HashPath.send(action, hash, path, value, *args, **params)
+    end
+    return hash
+  end
+
+  HASH_PATH_PROC_TYPES = {
+    evaluate: { aliases: [:eval, :equation, :equate]},
+    append: { aliases: [:suffix]},
+    prepend: { aliases: [:prefix]},
+    split: { aliases: [:delimit, :delim, :separate, :msplit]},
+    replace: { aliases: [:swap]},
+    extract: { aliases: [:grab, :scan]},
+    extract_first: {aliases: [:grab_first, :scan_first]},
+    extract_last: {aliases: [:grab_last, :scan_last]},
+    parse_date: { aliases: [:date, :parse_time, :time]},
+    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]}
+    # rename: { aliases: [:rename_key]},
+    # concat: { aliases: [:join, :concat_with]},
+    # reverse_concat: { aliases: [:reverse_join, :reverse_concat_with]}
+  }
+
+  module HashPath
+
+    def self.evaluate hash, path, value, args, params
+      exp = args.to_a.first.to_s.gsub('$', value.to_s)
+      hash.hash_path_set path => eval(exp)
+    end
+
+    def self.append hash, path, value, args, params
+      hash.hash_path_set path => "#{value}#{args}"
+    end
+
+    def self.prepend hash, path, value, args, params
+      hash.hash_path_set path => "#{args}#{value}"
+    end
+
+    def self.split hash, path, value, args, params
+      hash.hash_path_set path => value.msplit(args)
+    end
+
+    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) }
+      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]
+    end
+
+    def self.extract_first hash, path, value, *args, **params
+      extract(hash, path, value, *args + [0])
+    end
+
+    def self.extract_last hash, path, value, *args, **params
+      extract(hash, path, value, *args + [-1])
+    end
+
+    def self.parse_date 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
+    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
+
+    def self.parse_file_size hash, path, value, args, params
+      hash.hash_path_set path => value.to_s.parse_file_size(output: args.empty? ? :bytes : args )
+    end
+
+    def self.to_string hash, path, value, *args, **params
+      hash.hash_path_set path => value.to_s
+    end
+
+    def self.downcase hash, path, value, *args, **params
+      hash.hash_path_set path => value.to_s.downcase
+    end
+
+    def self.upcase hash, path, value, *args, **params
+      hash.hash_path_set path => value.to_s.upcase
+    end
+
+    def self.roman hash, path, value, *args, **params
+      hash.hash_path_set path => (args[0] == :to ? value.to_s.to_roman : value.to_s.from_roman)
+    end
+
+    def self.remove_symbols hash, path, value, *args, **params
+      hash.hash_path_set path => value.to_s.drop_symbols
+    end
+
+    def self.format_articles hash, path, value, args, **params
+      hash.hash_path_set path => value.to_s.move_articles(args.nil? ? :front : args)
+    end
+
+    def self.reverse hash, path, value, *args, **params
+      hash.hash_path_set path => value.to_s.reverse
+    end
+
+    def self.delete hash, path, value, *args, **params
+      hash.hash_path_delete path
+    end
+
+    def self.remove hash, path, value, *args, **params
+      removed = value.to_s
+      args.each{ |a| removed.gsub!(a, '')}
+      hash.hash_path_set path => removed
+    end
+
+    def self.custom hash, path, value, *args, **params
+      hash.hash_path_set path => value.send(*args)
+    end
+
+  end
+
+end

data/lib/object/bbobject.rb

@@ -0,0 +1,28 @@
+module BBLib
+
+  def self.to_hash obj
+    return {obj => nil} unless !obj.instance_variables.empty?
+    hash = {}
+    obj.instance_variables.each do |var|
+      value = obj.instance_variable_get(var)
+      if value.is_a? Array
+        hash[var.to_s.delete("@")] = value.map{ |v| v.respond_to?(:obj_to_hash) && !v.instance_variables.empty? ? v.obj_to_hash : v }
+      elsif value.is_a? Hash
+        begin
+          if !hash[var.to_s.delete("@")].is_a?(Hash) then hash[var.to_s.delete("@")] = Hash.new end
+        rescue
+          hash[var.to_s.delete("@")] = Hash.new
+        end
+        value.each do |k, v|
+          hash[var.to_s.delete("@")][k.to_s.delete("@")] = v.respond_to?(:obj_to_hash) && !v.instance_variables.empty? ? v.obj_to_hash : v
+        end
+      elsif value.respond_to?(:obj_to_hash) && !value.instance_variables.empty?
+        hash[var.to_s.delete("@")] = value.obj_to_hash
+      else
+        hash[var.to_s.delete("@")] = value
+      end
+    end
+    return hash
+  end
+
+end

data/lib/string/bbstring.rb

@@ -9,6 +9,10 @@ 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.
   def self.drop_symbols str
     str.gsub(/[^\w\s\d]|_/, '')
@@ -16,17 +20,17 @@ module BBLib
 
   # Extract all integers from a string. Use extract_floats if numbers may contain decimal places.
   def self.extract_integers str, convert: true
-    str.scan(/\d+/).map{ |d| convert ? d.to_i : d }
+    BBLib.extract_numbers(str, convert:false).reject{ |r| r.include?('.') }.map{ |m| convert ? m.to_i : m }
   end
 
   # Extracts all integers or decimals from a string into an array.
   def self.extract_floats str, convert: true
-    str.scan(/\d+\.?\d+|\d+/).map{ |f| convert ? f.to_f : f }
+    BBLib.extract_numbers(str, convert:false).reject{ |r| !r.include?('.') }.map{ |m| convert ? m.to_f : m }
   end
 
   # Alias for extract_floats
   def self.extract_numbers str, convert: true
-    BBLib.extract_floats str, convert:convert
+    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.
@@ -61,22 +65,22 @@ end
 
 class String
   # Multi-split. Similar to split, but can be passed an array of delimiters to split on.
-  def msplit delims, keep_empty: false
+  def msplit *delims, keep_empty: false
     return [self] unless !delims.nil? && !delims.empty?
     ar = [self]
-    delims.each do |d|
+    [delims].flatten.each do |d|
       ar.map!{ |a| a.split d }
       ar.flatten!
     end
     keep_empty ? ar : ar.reject{ |l| l.empty? }
   end
 
-  def move_articles position, capitalize = true
-    BBLib.move_articles self, position, capitalize
+  def move_articles position = :front, capitalize = true
+    BBLib.move_articles self, position, capitalize:capitalize
   end
 
-  def move_articles! position, capitalize = true
-    replace BBLib.move_articles(self, position, capitalize)
+  def move_articles! position = :front, capitalize = true
+    replace BBLib.move_articles(self, position, capitalize:capitalize)
   end
 
   def drop_symbols
@@ -91,7 +95,30 @@ class String
     BBLib.extract_integers self, convert:convert
   end
 
+  def extract_floats convert: true
+    BBLib.extract_floats self, convert:convert
+  end
+
   def extract_numbers convert: true
     BBLib.extract_numbers self, convert:convert
   end
+
+  def to_clean_sym
+    self.strip.downcase.gsub('_', ' ').drop_symbols.gsub(' ', '_').to_sym
+  end
+
+  # Simple method to convert a string into an array containing only itself
+  def to_a
+    return [self]
+  end
+
+  def encap_by? str
+    return self.start_with?(str) && self.end_with?(str)
+  end
+end
+
+class Symbol
+  def to_clean_sym
+    self.to_s.strip.downcase.gsub('_', ' ').drop_symbols.gsub(' ', '_').to_sym
+  end
 end

data/lib/time/bbtime.rb

@@ -1,19 +1,19 @@
-
+require_relative 'task_timer'
 
 module BBLib
 
   # Parses known time based patterns out of a string to construct a numeric duration.
   def self.parse_duration str, output: :sec
-    secs = 0.0
+    msecs = 0.0
     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)
+        numbers = str.downcase.scan(/(?=\w|\D|\A)\d*\.?\d+[[:space:]]*#{e}(?=\W|\d|\z)/i)
         numbers.each do |n|
-          secs+= n.to_i * v[:mult]
+          msecs+= n.to_f * v[:mult]
         end
       end
     end
-    secs / (TIME_EXPS[output][:mult].to_f rescue 1)
+    msecs / (TIME_EXPS[output][:mult] rescue 1)
   end
 
   # Turns a numeric input into a time string.
@@ -24,47 +24,83 @@ module BBLib
     n, done = num * TIME_EXPS[input.to_sym][:mult], false
     TIME_EXPS.reverse.each do |k, v|
       next unless !done
+      if k == stop then done = true end
       div = n / v[:mult]
-      if div > 1
-        expression << "#{div.floor}#{v[:styles][style]}#{div.floor > 1 && style != :short ? "s" : nil}"
-        n-= div.floor * v[:mult]
+      if div >= 1
+        val = (done ? div.round : div.floor)
+        expression << "#{val}#{v[:styles][style]}#{val > 1 && style != :short ? "s" : nil}"
+        n-= val.to_f * v[:mult]
       end
-      if k == stop then done = true end
     end
     expression.join ' '
   end
 
   TIME_EXPS = {
-    milli: {
+    yocto: {
+      mult: 0.000000000000000000001,
+      styles: {full: ' yoctosecond', medium: ' yocto', short: 'ys'},
+      exp: ['yoctosecond', 'yocto', 'yoctoseconds', 'yoctos', 'ys']
+    },
+    zepto: {
+      mult: 0.000000000000000001,
+      styles: {full: ' zeptosecond', medium: ' zepto', short: 'zs'},
+      exp: ['zeptosecond', 'zepto', 'zeptoseconds', 'zeptos', 'zs']
+    },
+    atto: {
+      mult: 0.000000000000001,
+      styles: {full: ' attosecond', medium: ' atto', short: 'as'},
+      exp: ['attoseconds', 'atto', 'attoseconds', 'attos', 'as']
+    },
+    femto: {
+      mult: 0.000000000001,
+      styles: {full: ' femtosecond', medium: ' fempto', short: 'fs'},
+      exp: ['femtosecond', 'fempto', 'femtoseconds', 'femptos', 'fs']
+    },
+    pico: {
+      mult: 0.000000001,
+      styles: {full: ' picosecond', medium: ' pico', short: 'ps'},
+      exp: ['picosecond', 'pico', 'picoseconds', 'picos', 'ps']
+    },
+    nano: {
+      mult: 0.000001,
+      styles: {full: ' nanosecond', medium: ' nano', short: 'ns'},
+      exp: ['nanosecond', 'nano', 'nanoseconds', 'nanos', 'ns']
+    },
+    micro: {
       mult: 0.001,
-      styles: {full: ' millisecond', medium: ' milli', short: 'ms'},
+      styles: {full: ' microsecond', medium: ' micro', short: 'μs'},
+      exp: ['microsecond', 'micro', 'microseconds', 'micros', 'μs']
+    },
+    milli: {
+      mult: 1,
+      styles: {full: ' millisecond', medium: ' mil', short: 'ms'},
       exp: ['ms', 'mil', 'mils', 'milli', 'millis', 'millisecond', 'milliseconds', 'milsec', 'milsecs', 'msec', 'msecs', 'msecond', 'mseconds']},
     sec: {
-      mult: 1,
+      mult: 1000,
       styles: {full: ' second', medium: ' sec', short: 's'},
       exp: ['s', 'sec', 'secs', 'second', 'seconds']},
     min: {
-      mult: 60,
+      mult: 60000,
       styles: {full: ' minute', medium: ' min', short: 'm'},
       exp: ['m', 'mn', 'mns', 'min', 'mins', 'minute', 'minutes']},
     hour: {
-      mult: 3600,
+      mult: 3600000,
       styles: {full: ' hour', medium: ' hr', short: 'h'},
       exp: ['h', 'hr', 'hrs', 'hour', 'hours']},
     day: {
-      mult: 86400,
+      mult: 86400000,
       styles: {full: ' day', medium: ' day', short: 'd'},
-      exp: ['d', 'day' 'days']},
+      exp: ['d', 'day', 'days']},
     week: {
-      mult: 604800,
+      mult: 604800000,
       styles: {full: ' week', medium: ' wk', short: 'w'},
       exp: ['w', 'wk', 'wks', 'week', 'weeks']},
     month: {
-      mult: 2592000,
+      mult: 2592000000,
       styles: {full: ' month', medium: ' mo', short: 'mo'},
       exp: ['mo', 'mon', 'mons', 'month', 'months', 'mnth', 'mnths', 'mth', 'mths']},
     year: {
-      mult: 31536000,
+      mult: 31536000000,
       styles: {full: ' year', medium: ' yr', short: 'y'},
       exp: ['y', 'yr', 'yrs', 'year', 'years']}
   }

data/lib/time/task_timer.rb

@@ -0,0 +1,101 @@
+module BBLib
+
+  class TaskTimer
+    attr_reader :tasks, :save, :retention
+
+    def initialize task:nil, retention:100
+      @tasks = {}
+      self.retention = retention
+      if task then start task end
+    end
+
+    def retention= num
+      @retention = num.nil? ? nil : BBLib.keep_between(num, -1, nil)
+    end
+
+    def time task = :default, type = :current
+      return nil unless @tasks.keys.include? task
+      numbers = @tasks[task][:history].map{ |v| v[:time] }
+      case type
+      when :current
+        return nil unless @tasks[task][:current]
+        return Time.now.to_f - @tasks[task][:current]
+      when :min
+        return numbers.min
+      when :max
+        return numbers.max
+      when :avg
+        return numbers.inject{ |sum, n| sum + n }.to_f / numbers.size
+      when :sum
+        return numbers.inject{ |sum, n| sum + n }
+      when :all
+        return numbers
+      when :first
+        return numbers.first
+      when :last
+        return numbers.last
+      when :count
+        return numbers.size
+      end
+    end
+
+    def clear task
+      return nil unless @tasks.keys.include?(task)
+      stop task
+      @tasks[task][:history].clear
+    end
+
+    def start task = :default
+      if !@tasks.keys.include?(task) then @tasks[task] = {history: [], current: nil} end
+      if @tasks[task][:current] then stop task end
+      @tasks[task][:current] = Time.now.to_f
+      return 0
+    end
+
+    def stop task = :default
+      return nil unless @tasks.keys.include?(task) && active?(task)
+      time_taken = Time.now.to_f - @tasks[task][:current].to_f
+      @tasks[task][:history] << {start: @tasks[task][:current], stop: Time.now.to_f, time: time_taken}
+      @tasks[task][:current] = nil
+      if @retention && @tasks[task][:history].size > @retention then @tasks[task][:history].shift end
+      time_taken
+    end
+
+    def restart task = :default
+      start(task) unless stop(task).nil?
+    end
+
+    def save= save
+      @save = save
+    end
+
+    def active? task
+      return false unless @tasks.keys.include? task
+      !@tasks[task][:current].nil?
+    end
+
+    def method_missing *args
+      temp = args.first.to_s.sub('p_','').to_sym
+      type, task = TIMER_TYPES.keys.find{ |k| k == temp || TIMER_TYPES[k].include?(temp) }, args[1] ||= :default
+      raise NoMethodError unless type
+      t = time task, type
+      args.first.to_s.start_with?('p_') && type != :count ? t.to_duration : t
+    end
+
+    private
+
+      TIMER_TYPES = {
+        current: [],
+        avg: [:average, :av],
+        all: [:times],
+        max: [:maximum, :largest],
+        min: [:minimum, :smallest],
+        sum: [],
+        last: [:latest],
+        first: [:initial],
+        count: [:total]
+      }
+
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bblib
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Brandon Black
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-01-12 00:00:00.000000000 Z
+date: 2016-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -70,17 +70,21 @@ files:
 - bblib.gemspec
 - bin/console
 - bin/setup
+- lib/array/bbarray.rb
 - lib/bblib.rb
 - lib/bblib/version.rb
 - lib/file/bbfile.rb
 - lib/hash/bbhash.rb
-- lib/math/bbmath.rb
-- lib/net/bbnet.rb
+- lib/hash/hash_path.rb
+- lib/hash/hash_path_proc.rb
+- lib/number/bbnumber.rb
+- lib/object/bbobject.rb
 - lib/string/bbstring.rb
 - lib/string/fuzzy_matcher.rb
 - lib/string/matching.rb
 - lib/string/roman.rb
 - lib/time/bbtime.rb
+- lib/time/task_timer.rb
 homepage: https://github.com/bblack16/bblib-ruby
 licenses:
 - MIT
@@ -101,7 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: A library containing many reusable, basic functions.

data/lib/net/bbnet.rb

@@ -1 +0,0 @@
-# TO BE WRITTEN