bblib 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0ee410b186ccd9feaaf7a4bc76bb6919aa1ecc3a
+  data.tar.gz: 260e264c246c8a894078386376874d09ee0ac877
+SHA512:
+  metadata.gz: 113718b874eb1e0c9fae613e6c6d1ece6f5e1cbef055c2f8f7cd5903911803b2d48d43b3d595e6acd4596038e34a61af0d0954b9459b06b78433d9453cae6dc6
+  data.tar.gz: 045421131ce65287668aa2c89b835f1b566bca620d346b2f4783b400aa6b714c1626cd7bb459c2116a9d96475ee3bf41eb8b274ab84ccb24302c69d776468022

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.gem

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.6
+before_install: gem install bundler -v 1.10.6

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bblib.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Brandon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,211 @@
+# 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.
+
+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.
+
+For a full breakdown of what is currently in this library, scroll down.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'bblib'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bblib
+
+## Usage
+
+BBLib is currently broken up into the following categories:
+* File
+* Hash
+* Math
+* Net
+* String
+* Time
+
+### File
+#### File Scanners
+
+Various simple file scan methods are available. All of these are toggleable-recursive and can be passed filters using an wildcarding supported by the Ruby Dir.glob() method.
+
+```ruby
+# Scan for any files or folders in a path
+BBLib.scan_dir 'C:/path/to/files'
+
+#=> 'C:/path/to/files/readme.md'
+#=> 'C:/path/to/files/license.txt'
+#=> 'C:/path/to/files/folder/'
+```
+
+If you need only files or dirs but not both, the following two convenience methods are also available:
+```ruby
+# Scan for files ONLY
+BBLib.scan_files 'C:/path/to/files'
+
+#=> 'C:/path/to/files/readme.md'
+#=> 'C:/path/to/files/license.txt'
+
+# Scan for folders  ONLY
+BBLib.scan_dirs 'C:/path/to/files'
+
+#=> 'C:/path/to/files/folder/'
+```
+
+All of the scan methods also allow for the following named arguments:
+* **recursive**: Default is false. Set to true to recursively scan directories
+* **filter**: Default is nil. Can take either a String or Array of Strings. These strings will be used as filters so that only matching files or dirs are returned (Ex: '*.jpg', which would return all jpg files.)
+
+```ruby
+# Scan for any 'txt' or 'jpg' files recursively in a dir
+BBLib.scan_dir 'C:/path/to/files', recursive: true, filter: ['*.jpg', '*.txt']
+
+#=> 'C:/path/to/files/license.txt'
+#=> 'C:/path/to/files/folder/profile.jpg'
+#=> '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.
+
+#### File Size Parsing
+
+A file size parser is available that analyzes known patterns in a string to construct a numeric file size. This is very useful for parsing the output from outside applications or from web scrapers.
+
+```ruby
+# Turn a string into a file size (in bytes)
+BBLib.parse_file_size "1MB 100KB"
+
+#=> 1150976.0
+```
+
+By default the output is in bytes, however, this can be modified using the named argument **output**.
+
+```ruby
+# Turn a string into a file size (in bytes)
+BBLib.parse_file_size "1MB 100KB", output: :megabyte
+
+#=> 1.09765625
+
+# The method can also be called directly on a string
+
+"1.5 Mb".parse_file_size output: :kilobyte
+
+#=> 1536.0
+```
+
+All of the following are options for output:
+* :byte
+* :kilobyte
+* :megabyte
+* :gigabyte
+* :terabtye
+* :petabtye
+* :exabtye
+* :zettabtye
+* :yottabtye
+
+Additionally, ANY matching pattern in the string is added to the total, so a string such as "1MB 1megabyte" would yield the equivalent of "2MB". File sizes can also be intermingled with any other text, so "The file is 2 megabytes in size." would successfully parse the file size as 2 megabytes.
+
+#### Other Methods
+
+**string_to_file**
+
+This method is a convenient way to write a string to disk as file. It simply takes a path and a string. By default if the path does not exist it will attempt to create it. This can be controlled using the mkpath argument.
+
+```ruby
+# Write a string to disk
+string = "This is my wonderful string."
+BBLib.string_to_file '/home/user/my_file', string
+
+# OR to avoid the creation of the path if it doesn't exist:
+
+BBLib.string_to_file '/home/user/my_file', string, false
+
+# OR call the method directly on the string
+
+string.to_file '/home/user/another_file', true
+```
+
+### Hash
+
+#### Deep Merge
+
+A simple implementation of a deep merge algorithm that merges two hashes including nested hashes within them. It can also merge arrays (default) within the hashes and merge values into arrays (not default) rather than overwriting the values with the right side hash.
+
+```ruby
+h1 = ({value: 1231, array: [1, 2], hash: {a: 1, b_hash: {c: 2, d:3}}})
+h2 = ({value: 5, array: [6, 7], hash: {a: 1, z: nil, b_hash: {c: 9, d:10, y:10}}})
+
+# Default behavior merges arrays and overwrites non-array/hash values
+h1.deep_merge h2
+
+#=> {:value=>5, :array=>[1, 2, 6, 7], :hash=>{:a=>1, :b_hash=>{:c=>9, :d=>10, :y=>10}, :z=>nil}}
+
+# Don't overwrite colliding values, instead, place them into an array together
+h1.deep_merge h2, overwrite_vals: false
+
+#=> {:value=>[1231, 5], :array=>[1, 2, 6, 7], :hash=>{:a=>[1, 1], :b_hash=>{:c=>[2, 9], :d=>[3, 10], :y=>10}, :z=>nil}}
+
+# Don't merge arrays, instead, overwrite them.
+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.
+
+#### 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.
+
+```ruby
+h = {"author" => "Tom Clancy", "books" => ["Rainbow Six", "The Hunt for Red October"]}
+h.keys_to_sym
+
+#=> {:author=>"Tom Clancy", :books=>["Rainbow Six", "The Hunt for Red October"]}
+```
+
+#### Reverse
+
+Similar to reverse for Array. Calling this will reverse the current order of the Hash's keys. An inplace version is also available.
+
+```ruby
+h = {a:1, b:2, c:3, d:4}
+h.reverse
+
+#=> {:d=>4, :c=>3, :b=>2, :a=>1}
+```
+
+### Math
+
+
+### Net
+Currently empty...
+
+### String
+
+
+### Time
+
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/bblack16/bblib. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bblib.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bblib/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bblib"
+  spec.version       = BBLib::VERSION
+  spec.authors       = ["Brandon Black"]
+  spec.email         = ["d2sm10@hotmail.com"]
+
+  spec.summary       = %q{A library containing many reusable, basic functions.}
+  spec.description   = %q{See summary for now...}
+  spec.homepage      = "https://github.com/bblack16/bblib-ruby"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) || f.end_with?('.gem') }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "bblib"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/bblib.rb

@@ -0,0 +1,13 @@
+require_relative "bblib/version"
+require_relative "string/bbstring"
+require_relative "file/bbfile"
+require_relative "time/bbtime"
+require_relative "hash/bbhash"
+require_relative "math/bbmath"
+require 'fileutils'
+
+module BBLib
+
+  CONFIGS_PATH = 'config/'
+
+end

data/lib/bblib/version.rb

@@ -0,0 +1,3 @@
+module BBLib
+  VERSION = "0.1.0"
+end

data/lib/file/bbfile.rb

@@ -0,0 +1,78 @@
+
+
+module BBLib
+
+  # 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?
+      filter = [filter].flatten.map{ |f| path.to_s + (recursive ? '/**/' : '/') + f.to_s }
+    else
+      filter = path.to_s + (recursive ? '/**/*' : '/*')
+    end
+    Dir.glob(filter)
+  end
+
+  # Uses BBLib.scan_dir but returns only files. Mode can be used to return strings (:path) or File objects (:file)
+  def self.scan_files path, filter: nil, recursive: false, mode: :path
+    BBLib.scan_dir(path, filter: filter, recursive: recursive).map{ |f| File.file?(f) ? (mode == :file ? File.new(f) : f) : nil}.reject{ |r| r.nil? }
+  end
+
+  # Uses BBLib.scan_dir but returns only directories. Mode can be used to return strings (:path) or Dir objects (:dir)
+  def self.scan_dirs path, filter: nil, recursive: false, mode: :path
+    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.
+  def self.string_to_file path, str, mkpath = true
+    if !Dir.exists?(path) && mkpath
+      FileUtils.mkpath File.dirname(path)
+    end
+    File.write(path, str.to_s)
+  end
+
+  # A file size parser for strings. Extracts any known patterns for file sizes.
+  def self.parse_file_size str, output: :byte
+    output = FILE_SIZES.keys.find{ |f| f == output || FILE_SIZES[f][:exp].include?(output.to_s.downcase) } || :byte
+    bytes = 0.0
+    FILE_SIZES.each do |k, v|
+      v[:exp].each do |e|
+        numbers = str.scan(/(?=\w|\D|\A)\d?\.?\d+[[:space:]]*#{e}(?=\W|\d|\z)/i)
+        numbers.each{ |n| bytes+= n.to_f * v[:mult] }
+      end
+    end
+    return bytes / FILE_SIZES[output][:mult]
+  end
+
+FILE_SIZES = {
+    byte: { mult: 1, exp: ['b', 'byt', 'byte'] },
+    kilobyte: { mult: 1024, exp: ['kb', 'kilo', 'k', 'kbyte', 'kilobtye'] },
+    megabyte: { mult: 1048576, exp: ['mb', 'mega', 'm', 'mib', 'mbyte', 'megabtye'] },
+    gigabyte: { mult: 1073741824, exp: ['gb', 'giga', 'g', 'gbyte', 'gigabtye'] },
+    terabtye: { mult: 1099511627776, exp: ['tb', 'tera', 't', 'tbyte', 'terabtye'] },
+    petabtye: { mult: 1125899906842624, exp: ['pb', 'peta', 'p', 'pbyte', 'petabtye'] },
+    exabtye: { mult: 1152921504606846976, exp: ['eb', 'exa', 'e', 'ebyte', 'exabtye'] },
+    zettabtye: { mult: 1180591620717411303424, exp: ['zb', 'zetta', 'z', 'zbyte', 'zettabtye'] },
+    yottabtye: { mult: 1208925819614629174706176, exp: ['yb', 'yotta', 'y', 'ybyte', 'yottabtye'] }
+  }
+
+end
+
+class File
+  def dirname
+    File.dirname(self.path)
+  end
+end
+
+class String
+  def to_file path, mkpath = true
+    BBLib.string_to_file path, self, mkpath
+  end
+
+  def file_name with_extension = true
+    self[(self.include?('/') ? self.rindex('/').to_i+1 : 0)..(with_extension ? -1 : self.rindex('.').to_i-1)]
+  end
+
+  def parse_file_size output: :byte
+    BBLib.parse_file_size(self, output:output)
+  end
+end

data/lib/hash/bbhash.rb

@@ -0,0 +1,33 @@
+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)) }
+      self.merge(with, &merger)
+  end
+
+  def deep_merge! with, merge_arrays: true, overwrite_vals: true
+    replace self.deep_merge(with, merge_arrays: merge_arrays, overwrite_vals: overwrite_vals)
+  end
+
+  # 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}
+  end
+
+  def keys_to_sym!
+    replace self.keys_to_sym
+  end
+
+  # Reverses the order of keys in the Hash
+  def reverse
+    self.to_a.reverse.to_h
+  end
+
+  def reverse!
+    replace self.reverse
+  end
+
+end

data/lib/math/bbmath.rb

@@ -0,0 +1,12 @@
+module BBLib
+
+  # Used to keep any numeric number between a set of bounds. Passing nil as min or max represents no bounds in that direction.
+  # min and max are inclusive to the allowed bounds.
+  def self.keep_between num, min, max
+    raise "Argument must be numeric: #{num} (#{num.class})" unless Numeric === num
+    if !min.nil? && num < min then num = min end
+    if !max.nil? && num > max then num = max end
+    return num
+  end
+
+end

data/lib/net/bbnet.rb

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

data/lib/string/bbstring.rb

@@ -0,0 +1,97 @@
+
+require_relative 'matching.rb'
+require_relative 'roman.rb'
+require_relative 'fuzzy_matcher.rb'
+
+module BBLib
+
+  ##############################################
+  # General Functions
+  ##############################################
+
+  # 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]|_/, '')
+  end
+
+  # 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 }
+  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 }
+  end
+
+  # Alias for extract_floats
+  def self.extract_numbers str, convert: true
+    BBLib.extract_floats str, convert:convert
+  end
+
+  # Used to move the position of the articles 'the', 'a' and 'an' in strings for normalization.
+  def self.move_articles str, position = :front, capitalize = true
+    return str unless [:front, :back, :none].include? position
+    articles = ["the", "a", "an"]
+    articles.each do |a|
+      starts, ends = str.downcase.start_with?(a + ' '), str.downcase.end_with?(' ' + a)
+      if starts && position != :front
+        if position == :none
+          str = str[(a.length + 1)..str.length]
+        elsif position == :back
+          str = str[(a.length + 1)..str.length] + (!ends ? ", #{capitalize ? a.capitalize : a}" : '')
+        end
+      end
+      if ends && position != :back
+        if position == :none
+          str = str[0..-(a.length + 2)]
+        elsif position == :front
+          str = (!starts ? "#{capitalize ? a.capitalize : a} " : '') + str[0..-(a.length + 2)]
+        end
+      end
+    end
+    while str.strip.end_with?(',')
+      str.strip!
+      str.chop!
+    end
+    str
+  end
+
+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
+    return [self] unless !delims.nil? && !delims.empty?
+    ar = [self]
+    delims.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
+  end
+
+  def move_articles! position, capitalize = true
+    replace BBLib.move_articles(self, position, capitalize)
+  end
+
+  def drop_symbols
+    BBLib.drop_symbols self
+  end
+
+  def drop_symbols!
+    replace BBLib.drop_symbols(self)
+  end
+
+  def extract_integers convert: true
+    BBLib.extract_integers self, convert:convert
+  end
+
+  def extract_numbers convert: true
+    BBLib.extract_numbers self, convert:convert
+  end
+end

data/lib/string/fuzzy_matcher.rb

@@ -0,0 +1,75 @@
+
+module BBLib
+
+  class FuzzyMatcher
+    attr_reader :threshold
+    attr_accessor :case_sensitive, :remove_symbols, :move_articles, :convert_roman
+
+    def initialize threshold: 75, case_sensitive: true, remove_symbols: false, move_articles: false, convert_roman: true
+      self.threshold = threshold
+      @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|
+        next unless vals[:weight] > 0
+        score+= @a.send(vals[:signature], @b) * vals[:weight]
+      end
+      score / total_weight
+    end
+
+    # Checks to see if the match percentage between Strings a and b are equal to or greater than the threshold.
+    def match? a, b
+      similarity(a, b) >= @threshold.to_f
+    end
+
+    # Returns the best match from array b to string a based on percent.
+    def best_match a, b
+      similarities(a, b).max_by{ |k, v| v}[0]
+    end
+
+    # Returns a hash of array 'b' with the percentage match to a. If sort is true, the hash is sorted desc by match percent.
+    def similarities a, b, sort: false
+      matches = Hash.new
+      [b].flatten.each{ |m| matches[m] = self.similarity(a, m) }
+      sort ? matches.sort_by{ |k, v| v }.reverse.to_h : matches
+    end
+
+    def threshold= threshold
+      @threshold = BBLib.keep_between(threshold, 0, 100)
+    end
+
+    def set_weight algorithm, weight
+      return nil unless ALGORITHMS.include? algorithm
+      ALGORITHMS[algorithm] = BBLib.keep_between(weight, 0, nil)
+    end
+
+    def algorithms
+      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},
+        qwerty: {weight: 0, signature: :qwerty_similarity}
+      }
+
+      def prep_strings a, b
+        @a, @b = a.to_s.dup.strip, b.to_s.dup.strip
+        if !@case_sensitive then @a.downcase!; @b.downcase! end
+        if @remove_symbols then @a.drop_symbols!; @b.drop_symbols! end
+        if @convert_roman then @a.from_roman!; @b.from_roman! end
+        if @move_articles then @a.move_articles!(:front, @case_sensitive); @b.move_articles! :front, @case_sensitive end
+      end
+
+  end
+
+end

data/lib/string/matching.rb

@@ -0,0 +1,119 @@
+##############################################
+# String Comparison Algorithms
+##############################################
+
+module BBLib
+
+  # A simple rendition of the levenshtein distance algorithm
+  def self.levenshtein_distance a, b, case_sensitive = false
+    if !case_sensitive then a, b = a.downcase, b.downcase end
+    costs = (0..b.length).to_a
+    (1..a.length).each do |i|
+      costs[0], nw = i, i - 1
+      (1..b.length).each do |j|
+        costs[j], nw = [costs[j] + 1, costs[j-1] + 1, a[i-1] == b[j-1] ? nw : nw + 1].min, costs[j]
+      end
+    end
+    costs[b.length]
+  end
+
+  # Calculates a percentage based match using the levenshtein distance algorithm
+  def self.levenshtein_similarity a, b, case_sensitive = false
+    distance = BBLib.levenshtein_distance a, b, case_sensitive
+    max = [a.length, b.length].max.to_f
+    return ((max - distance.to_f) / max) * 100.0
+  end
+
+  # Calculates a percentage based match of two strings based on their character composition.
+  def self.composition_similarity a, b, case_sensitive = false
+    if !case_sensitive then a, b = a.downcase, b.downcase end
+    if a.length <= b.length then t = a; a = b; b = t; end
+    matches, temp = 0, b
+    a.chars.each do |c|
+      if temp.chars.include? c
+        matches+=1
+        temp.sub! c, ''
+      end
+    end
+    (matches / [a.length, b.length].max.to_f )* 100.0
+  end
+
+  # Calculates a percentage based match between two strings based on the similarity of word matches.
+  def self.phrase_similarity a, b, case_sensitive = false
+    if !case_sensitive then a, b = a.downcase, b.downcase end
+    temp = b.split ' '
+    matches = 0
+    a.split(' ').each do |w|
+      if temp.include? w
+        matches+=1
+        temp.delete_at temp.find_index w
+      end
+    end
+    (matches.to_f / [a.split(' ').size, b.split(' ').size].max.to_f) * 100.0
+  end
+
+  # Extracts all numbers from two strings and compares them and generates a percentage of match.
+  # Percentage calculations here need to be weighted better...TODO
+  def self.numeric_similarity a, b, case_sensitive = false
+    if !case_sensitive then a, b = a.downcase, b.downcase end
+    a, b = a.extract_numbers, b.extract_numbers
+    return 100.0 if a.empty? && b.empty?
+    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)
+    end
+    (matches.inject{ |sum, m| sum + m } / matches.size.to_f) * 100.0
+  end
+
+  # A simple character distance calculator that uses qwerty key positions to determine how similar two strings are.
+  # May be useful for typo detection.
+  def self.qwerty_similarity a, b
+    a, b = a.downcase.strip, b.downcase.strip
+    if a.length <= b.length then t = a; a = b; b = t; end
+    qwerty = {
+      1 => ['1','2','3','4','5','6','7','8','9','0'],
+      2 => ['q','w','e','r','t','y','u','i','o','p'],
+      3 => ['a','s','d','f','g','h','j','k','l'],
+      4 => ['z','x','c','v','b','n','m']
+    }
+    count, offset = 0, 0
+    a.chars.each do |c|
+      if b.length <= count
+        offset+=10
+      else
+        ai = qwerty.keys.find{ |f| qwerty[f].include? c }.to_i
+        bi = qwerty.keys.find{ |f| qwerty[f].include? b.chars[count] }.to_i
+        offset+= (ai - bi).abs
+        offset+= (qwerty[ai].index(c) - qwerty[bi].index(b.chars[count])).abs
+      end
+      count+=1
+    end
+    offset
+  end
+end
+
+class String
+  def levenshtein_distance str, case_sensitive = false
+    BBLib.levenshtein_distance self, str, case_sensitive
+  end
+
+  def levenshtein_similarity str, case_sensitive = false
+    BBLib.levenshtein_similarity self, str, case_sensitive
+  end
+
+  def composition_similarity str, case_sensitive = false
+    BBLib.composition_similarity self, str, case_sensitive
+  end
+
+  def phrase_similarity str, case_sensitive = false
+    BBLib.phrase_similarity self, str, case_sensitive
+  end
+
+  def numeric_similarity str, case_sensitive = false
+    BBLib.numeric_similarity self, str, case_sensitive
+  end
+
+  def qwerty_similarity str
+    BBLib.qwerty_similarity self, str
+  end
+end

data/lib/string/roman.rb

@@ -0,0 +1,70 @@
+
+module BBLib
+
+  # Converts any integer up to 1000 to a roman numeral string_a
+  def self.to_roman num
+     roman = {1000 => 'M', 900 => 'CM', 500 => 'D', 400 => 'CD', 100 => 'C', 90 => 'XC', 50 => 'L',
+              40 => 'XL', 10 => 'X', 9 => 'IX', 5 => 'V', 4 => 'IV', 3 => 'III', 2 => 'II', 1 => 'I'}
+    numeral = ""
+    roman.each do |n, r|
+      if num >= n
+        num-= n
+        numeral+= r
+      end
+    end
+    numeral
+  end
+
+  def self.string_to_roman str
+    sp = str.split ' '
+    sp.map! do |s|
+      if s.to_i.to_s == s
+        BBLib.to_roman s.to_i
+      else
+        s
+      end
+    end
+    sp.join ' '
+  end
+
+
+  def self.from_roman str
+    sp = str.split(' ')
+    (0..1000).each do |n|
+      num = BBLib.to_roman n
+      if !sp.select{ |i| i[/#{num}/i]}.empty?
+        for i in 0..(sp.length-1)
+          if sp[i].upcase == num
+            sp[i] = n.to_s
+          end
+        end
+      end
+    end
+    sp.join ' '
+  end
+
+end
+
+class Numeric
+  def to_roman
+    BBLib.to_roman self.to_i
+  end
+end
+
+class String
+  def from_roman
+    BBLib.from_roman self
+  end
+
+  def from_roman!
+    replace self.from_roman
+  end
+
+  def to_roman
+    BBLib.string_to_roman self
+  end
+
+  def to_roman!
+    replace self.to_roman
+  end
+end

data/lib/time/bbtime.rb

@@ -0,0 +1,84 @@
+
+
+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
+    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.each do |n|
+          secs+= n.to_i * v[:mult]
+        end
+      end
+    end
+    secs / (TIME_EXPS[output][:mult].to_f rescue 1)
+  end
+
+  # Turns a numeric input into a time string.
+  def self.to_duration num, input: :sec, stop: :mili, style: :medium
+    return nil unless Numeric === num || num > 0
+    if ![:full, :medium, :short].include?(style) then style = :medium end
+    expression = []
+    n, done = num * TIME_EXPS[input.to_sym][:mult], false
+    TIME_EXPS.reverse.each do |k, v|
+      next unless !done
+      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]
+      end
+      if k == stop then done = true end
+    end
+    expression.join ' '
+  end
+
+  TIME_EXPS = {
+    mili: {
+      mult: 0.001,
+      styles: {full: 'milisecond', medium: 'mili', short: 'ms'},
+      exp: ['ms', 'mil', 'mils', 'mili', 'milis', 'milisecond', 'miliseconds', 'milsec', 'milsecs', 'msec', 'msecs', 'msecond', 'mseconds']},
+    sec: {
+      mult: 1,
+      styles: {full: 'second', medium: 'sec', short: 's'},
+      exp: ['s', 'sec', 'secs', 'second', 'seconds']},
+    min: {
+      mult: 60,
+      styles: {full: 'minute', medium: 'min', short: 'm'},
+      exp: ['m', 'mn', 'mns', 'min', 'mins', 'minute', 'minutes']},
+    hour: {
+      mult: 3600,
+      styles: {full: 'hour', medium: 'hr', short: 'h'},
+      exp: ['h', 'hr', 'hrs', 'hour', 'hours']},
+    day: {
+      mult: 86400,
+      styles: {full: 'day', medium: 'day', short: 'd'},
+      exp: ['d', 'day' 'days']},
+    week: {
+      mult: 604800,
+      styles: {full: 'week', medium: 'wk', short: 'w'},
+      exp: ['w', 'wk', 'wks', 'week', 'weeks']},
+    month: {
+      mult: 2592000,
+      styles: {full: 'month', medium: 'mo', short: 'mo'},
+      exp: ['mo', 'mon', 'mons', 'month', 'months', 'mnth', 'mnths', 'mth', 'mths']},
+    year: {
+      mult: 31536000,
+      styles: {full: 'year', medium: 'yr', short: 'y'},
+      exp: ['y', 'yr', 'yrs', 'year', 'years']}
+  }
+
+end
+
+class String
+  def parse_duration to = :sec
+    BBLib.parse_duration self, to
+  end
+end
+
+class Numeric
+  def to_duration input: :sec, stop: :mili, style: :medium
+    BBLib.to_duration self, input: input, stop: stop, style: style
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: bblib
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Brandon Black
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-01-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: See summary for now...
+email:
+- d2sm10@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bblib.gemspec
+- bin/console
+- bin/setup
+- lib/bblib.rb
+- lib/bblib/version.rb
+- lib/file/bbfile.rb
+- lib/hash/bbhash.rb
+- lib/math/bbmath.rb
+- lib/net/bbnet.rb
+- lib/string/bbstring.rb
+- lib/string/fuzzy_matcher.rb
+- lib/string/matching.rb
+- lib/string/roman.rb
+- lib/time/bbtime.rb
+homepage: https://github.com/bblack16/bblib-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A library containing many reusable, basic functions.
+test_files: []