bblib 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d6ed599d59ab2bd4d0a8cdae4cd61383e23d4e64
-  data.tar.gz: 2a528e9bcdb00c34514420da98cb1f990996f9d6
+  metadata.gz: 0877d2a3cdc6b8ce850cc65fc4996ac413f385b7
+  data.tar.gz: 3e6e7d62d8ec1ec1feec1deb6080ab079251e02b
 SHA512:
-  metadata.gz: e0db224a5d5c9c8b430066ab093af08e510958b7a6aaa0f530f9a1d9e8e63f2bd9768586bf96643b2935d4f5ca68022c57f9db69067181400557cc6177e4775f
-  data.tar.gz: eab50c5ad0d2cf24e7f83b07d86a969a0c6a8fbe660b3db1c57098c00dc6e5fac480f824c7546fcae5b7eef5377623402d86dc8e366d546d2872ca48d4297e0c
+  metadata.gz: 2f0bd38d8d3ea39e9a671f2e060ffe4e2c7342eec1b1751fcceb9e45c6f3792c61f27e55b75688531df083939f12d44e76f90fd3c7be310b2708c129bba2b0b3
+  data.tar.gz: e9e1f54e7b2e15bd184751dfd89190f7d50591c1b8aa14aac38af969a8424d33d075bb47024c06f274712e287816ba8545fe21a260a7cc5b6bf868995f700bf3

data/README.md

@@ -1,31 +1,44 @@
 # BBLib
 
-BBLib (Brandon-Black-Lib) is a collection of various reusable methods and classes to extend the Ruby language.
+BBLib (Brandon-Black-Lib) is a collection of various reusable methods and classes to extend the Ruby language. 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.
 
-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.
+Good news! BBLib is now compatible with Opal! Well, like 90% compatible, but it can be 100% compiled into Javascript. Only very small tweaks were made to support this, so base functionality for the BBLib outside of Opal remains the same. But now it can coexist as both a Ruby gem, and an Opal library.
 
-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 contains A LOT of functionality, but is a very small, lightweight library. As such, it can be hard to document everything that is included (and even harder to make a TL:DR version). Continue scrolling for a comprehensive view of what is offered, or take a look at the highlights below for the library's most significant features.
 
-* __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).
+* __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 both hashes and arrays, including nested hashes/arrays (as deep as they can go!). It isn't only for navigating hashes; it can also copy, move, delete and run various methods using the same path notation.
 
 ```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]
+# => [5] - !!Hash Path always returns an array!!
+p myhash.hash_path('..e')
+# => [5]
+p myhash.hash_path('c.d.[1]')
+# => [4]
+p myhash.hash_path('c.d.[0..1]')
+# => [3, 4]
+
+# Hash Path also supports formulas (evaluation statements)
+# Formulas are surrounded in parenthesis following a path name
+# A $ can be used to specify where in the eval statement to inject the variable
+
+myarray = [
+  {title: 'Catan', cost: 41.99},
+  {title: 'Mouse Trap', cost: 5.50},
+  {title: 'Chess', cost: 25.99}
+]
+
+p myarray.hpath('[0..-1]($[:cost] > 10).title') # hpath is a shorter alias for hash_path
+# => ["Catan", "Chess"]
 
 # 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}
+# => {: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}
+# => {: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.
@@ -210,9 +223,23 @@ h.reverse
 #=> {:d=>4, :c=>3, :b=>2, :a=>1}
 ```
 
+### Array
 
+#### Interleave
 
-### Math
+Interleave takes two arrays and pieces them together by grabbing alternating elements from both arrays.
+
+```ruby
+a = ['This', 'a', '.']
+b = ['is', 'test']
+
+p BBLib.interleave a, b
+# OR
+p a.interleave b
+#=> ["This", "is", "a", "test", "."]
+```
+
+### Numeric
 
 #### Keep Between
 
@@ -286,7 +313,7 @@ fm.best_match 'Ruby', ['Ruby', 'Rails', 'Java', 'C++']
 
 Implementations of the following algorithms are currently available. All algorithms are for calculating similarity between strings. Most are useful for fuzzy matching. All algorithms are available statically in the BBLib module but are also available as extensions to the String class. Most of these algorithms are case sensitive by default.
 
-1 - Levenshtein Distance
+__1 - Levenshtein Distance__
 
 A fairly simple rendition of the Levenshtein distance algorithm in Ruby. There are two functions available: **levenshtein_distance** and **levenshtein_similarity**. The former, calculates the number of additions, removals or substitutions needed to turn one string into another. The latter, uses the distance to calculate a percentage based match of two strings.
 
@@ -302,7 +329,7 @@ BBLib.levenshtein_distance 'Ruby is great', 'Rails is great'
 #=> 71.42857142857143
 ```
 
-2 - String Composition
+__2 - String Composition__
 
 Compares the character composition of two strings. The order of characters is not relevant, however, the number of occurrences is factored in.
 
@@ -311,7 +338,7 @@ Compares the character composition of two strings. The order of characters is no
 #=> 71.42857142857143
 ```
 
-3 - Phrase Similarity
+__3 - Phrase Similarity__
 
 Checks to see how many words in a string match another. Words must match exactly, including case. The results is the percentage of words that have an exact pair. The number of occurrences is also a factor.
 
@@ -323,7 +350,7 @@ 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...
 
@@ -346,7 +373,7 @@ puts a.numeric_similarity b
 ```
 This algorithm is generally only useful when combined with another algorithm, which is exactly what the FuzzyMatcher class does.
 
-5 - QWERTY Similarity
+__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.
 
@@ -407,6 +434,51 @@ BBLib.from_roman "Toy Story III"
 #=> 'Donkey Kong CountryIII'
 ```
 
+#### Case Converters
+
+Some basic case converters are now available. The majority of these are complete but not heavily tested, so some bugs or edge cases may exist.
+
+Case supported:
+* Title Case
+* Start Case
+* Camel Case
+* Snake Case
+* Spinal Case
+* Train Case
+* Delimited Case
+
+Each case may be called directly on a string or using class methods in the BBLib module.
+
+```ruby
+sent = 'This is a casing-test. OK?'
+
+puts sent.title_case
+#=> This Is a Casing-Test. Ok?
+
+puts sent.start_case
+#=> This Is A Casing-Test. Ok?
+
+puts sent.snake_case
+#=> This_is_a_casing_test_OK
+
+puts sent.spinal_case
+#=> This-is-a-casing-test-OK
+
+puts sent.train_case
+#=> This-Is-A-Casing-Test-Ok
+
+puts sent.delimited_case '+'
+#=> This+is+a+casing+test+OK
+
+# By default when title casing or start casing, the capitalize method is used on each word.
+# This results in characters following the first to be downcased. To avoid this, the first_only param can be used.
+# This param prevents all other chars in a word from being processed.
+puts 'i like SQL'.title_case
+#=> 'I Like Sql'
+
+puts 'i like SQL'.title_case first_only: true
+#=> I Like SQL
+```
 
 #### Other
 
@@ -507,7 +579,35 @@ 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:
+Named days of the week and month are also supported in various formats and can be used in ranges or comma separated lists. They can even the intermingled with numbers such as 'Jun-9'.
+
+```ruby
+puts BBLib::Cron.next('* * * * sun *')
+#=> 2016-04-10 00:00:00 -0600
+
+puts BBLib::Cron.next('* * * * sunday *')
+#=> 2016-04-10 00:00:00 -0600
+
+puts BBLib::Cron.next('* * * * sun,sat *')
+#=> 2016-04-09 00:00:00 -0600
+
+puts BBLib::Cron.next('* * * Jun-Dec * *')
+#=> 2016-06-01 00:00:00 -0600
+
+# The next Friday the 13th in December
+puts BBLib::Cron.next('* * 13 Dec Fri *')
+#=> 2019-12-13 00:00:00 -0700
+
+# The next leap year
+puts BBLib::Cron.next('* * 29 February * *')
+#=> 2020-02-29 00:00:00 -0700
+
+# The next Feb 29th that also happens to be a Monday
+puts BBLib::Cron.next('* * 29 February Monday *')
+#=> 2044-02-29 00:00:00 -0700
+```
+
+Common Vixie-isms are also supported:
 
 ```ruby
 puts BBLib::Cron.next('@daily')
@@ -517,6 +617,9 @@ puts BBLib::Cron.next('@weekly')
 #=> 2016-04-10 00:00:00 -0600
 ```
 
+_Supported list of Vixie-isms: @daily, @midnight, @noon, @weekly, @monthly, @yearly, @annually_
+_Note: @reboot and @restart can be parsed but are inaccurate due to the fact that they have no way of knowing the next reboot._
+
 #### Duration parser
 
 **Parsing a duration from String**
@@ -584,6 +687,61 @@ There is also a method to turn a Numeric object into a string representation of
 #=> '34h 12m 4s'
 ```
 
+#### Task Timer
+
+A very simple task timer is also included. It is not intended to replace benchmarking classes but rather to augment or be used for simplistic timing. You simply need to instantiate a timer and then call start with the name of the task. To stop the timer, call stop and pass in the same task name. Once a single time has been completed for any given task a few different metrics can be pulled on that task. These metrics may also be printed in bulk using the _stats_ method.
+
+```ruby
+# Generate a new timer object
+t = BBLib::TaskTimer.new
+
+# Call start right before initiating a task and stop immediately after.
+5.times do
+  t.start :random_sleep
+  # Perform task...
+  sleep(rand())
+  t.stop :random_sleep
+end
+
+# Print out the stats from the task
+puts t.stats :random_sleep
+#=> random_sleep
+#=> ------------------------------
+#=> Count     5
+#=> First     0.3134028911590576
+#=> Last      0.5248761177062988
+#=> Min       0.20781898498535156
+#=> Max       0.9016561508178711
+#=> Avg       0.4677897930145264
+#=> Sum       2.338948965072632
+
+# Same as above but cnverts seconds into human readable time durations.
+# The pretty argument may also be applied to individual stat calls such as avg, sum, min, max, etc...
+puts t.stats :random_sleep, pretty: true
+#=> random_sleep
+#=> ------------------------------
+#=> Count     5
+#=> First     313 mils
+#=> Last      525 mils
+#=> Min       208 mils
+#=> Max       902 mils
+#=> Avg       468 mils
+#=> Sum       2 secs 339 mils
+
+# Similar to the above task, this version uses a restart which stops the first start call and initiates a new timer
+t.start :another_task
+5.times do
+  sleep(rand())
+  t.restart :another_task
+end
+
+# Get the individual average stat for another task. Method calls are aliases so you could also use .average or .av to get the average.
+puts t.avg :another_task
+#=> 0.5790667057037353
+```
+
+By default the task timer will only keep the stats from 100 runs of each task it tracks. The retention can be increased or decreased using the _retention_ method. Also, call stop will return the total time the stopped task ran.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/bblib.gemspec

@@ -30,4 +30,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec"
+  spec.add_development_dependency "simplecov"
 end

data/lib/array/bbarray.rb

@@ -2,40 +2,49 @@
 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
+  def self.interleave a, b
+    ary = Array.new
+    [a.size, b.size].max.times do |i|
+      ary.push(a[i]) if i < a.size
+      ary.push(b[i]) if i < b.size
     end
-    a.zip(b).flatten(1)
+    ary
   end
 
 end
 
 class Array
+
   def msplit *delims, keep_empty: false
     self.map{ |i| i.msplit(delims, keep_empty:keep_empty)}.flatten
   end
+  alias_method :multi_split, :msplit
 
   def keys_to_sym clean: false
-    self.map{ |v| Hash === v || Array === v ? v.keys_to_sym(clean:clean) : v }
+    self.map{ |v| v.is_a?(Hash) || v.is_a?(Array) ? 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 }
+    self.map{ |v| v.is_a?(Hash) || v.is_a?(Array) ? 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"
+      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
+  def interleave b
+    BBLib.interleave self, b
+  end
+
+  def diff b
+    (self-b) + (b-self)
   end
+  
 end

data/lib/bblib.rb

@@ -1,17 +1,27 @@
-require_relative "bblib/version"
-require_relative "string/bbstring"
-require_relative "file/bbfile"
-require_relative "time/bbtime"
-require_relative "hash/bbhash"
-require_relative "number/bbnumber"
-require_relative "object/bbobject"
-require_relative "array/bbarray"
-require 'fileutils'
-require 'net/http'
-require 'uri'
-
-module BBLib
-
-  CONFIGS_PATH = 'config/'
-
-end
+require_relative 'bblib/version'
+require_relative 'opal/bbopal'
+require_relative 'object/bbobject'
+require_relative 'object/lazy_class'
+require_relative 'string/bbstring'
+require_relative 'file/bbfile'
+require_relative 'time/bbtime'
+require_relative 'hash/bbhash'
+require_relative 'gem/bbgem'
+require_relative 'number/bbnumber'
+require_relative 'array/bbarray'
+
+non_opal = ['os/bbos', 'gem/bbgem']
+
+unless BBLib::in_opal?
+  non_opal.each{ |i| require_relative i }
+end
+
+
+require 'fileutils'
+# require 'uri'
+
+module BBLib
+
+  CONFIGS_PATH = 'config/'
+
+end

data/lib/bblib/version.rb

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

data/lib/file/bbfile.rb

@@ -2,6 +2,13 @@
 
 module BBLib
 
+  # Takes one or more strings and normalizes slashes to create a consistent file path
+  # Useful when concating two strings that when you don't know if one or both will end or begin with a slash
+  def self.pathify *strings
+    start = strings.first.start_with?('/') || strings.first.start_with?('\\')
+    (start ? '/' : '' ) + strings.map(&:to_s).msplit('/', '\\').map(&:strip).join('/')
+  end
+
   # Scan for files and directories. Can be set to be recursive and can also have filters applied.
   def self.scan_dir path = Dir.pwd, filter: nil, recursive: false
     if !filter.nil?
@@ -22,7 +29,7 @@ module BBLib
     BBLib.scan_dir(path, filter: filter, recursive: recursive).map{ |f| File.directory?(f) ? (mode == :dir ? Dir.new(f) : f ) : nil}.reject{ |r| r.nil? }
   end
 
-  # Shorthand method to write a string to dist. By default the path is created if it doesn't exist.
+  # Shorthand method to write a string to disk. By default the path is created if it doesn't exist.
   # 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
@@ -37,43 +44,21 @@ 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|^)\d*\.?\d+\s*#{e}s?(?=\W|\d|$)/i)
         numbers.each{ |n| bytes+= n.to_f * v[:mult] }
       end
     end
     return bytes / FILE_SIZES[output][:mult]
   end
 
-  # 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'] },
-    gigabyte: { mult: 1073741824, exp: ['gb', 'giga', 'g', 'gbyte', 'gigabyte'] },
-    terabyte: { mult: 1099511627776, exp: ['tb', 'tera', 't', 'tbyte', 'terabyte'] },
-    petabyte: { mult: 1125899906842624, exp: ['pb', 'peta', 'p', 'pbyte', 'petabyte'] },
-    exabyte: { mult: 1152921504606846976, exp: ['eb', 'exa', 'e', 'ebyte', 'exabyte'] },
+    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'] },
+    gigabyte:  { mult: 1073741824, exp: ['gb', 'giga', 'g', 'gbyte', 'gigabyte'] },
+    terabyte:  { mult: 1099511627776, exp: ['tb', 'tera', 't', 'tbyte', 'terabyte'] },
+    petabyte:  { mult: 1125899906842624, exp: ['pb', 'peta', 'p', 'pbyte', 'petabyte'] },
+    exabyte:   { mult: 1152921504606846976, exp: ['eb', 'exa', 'e', 'ebyte', 'exabyte'] },
     zettabyte: { mult: 1180591620717411303424, exp: ['zb', 'zetta', 'z', 'zbyte', 'zettabyte'] },
     yottabyte: { mult: 1208925819614629174706176, exp: ['yb', 'yotta', 'y', 'ybyte', 'yottabyte'] }
   }
@@ -102,4 +87,8 @@ class String
   def parse_file_size output: :byte
     BBLib.parse_file_size(self, output:output)
   end
+
+  def pathify
+    BBLib.pathify(self)
+  end
 end