bblib 0.3.0 → 0.4.1

data/Rakefile

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

data/bblib.gemspec

@@ -1,34 +1,34 @@
-# 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{A library containing many reusable, basic functions.}
-  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"
-  spec.add_development_dependency "simplecov"
-end
+# 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{A library containing many reusable, basic functions.}
+  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"
+  spec.add_development_dependency "simplecov"
+end

data/bin/console

@@ -1,14 +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
+#!/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

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

data/lib/array/bbarray.rb

@@ -1,50 +1,92 @@
-
+# frozen_string_literal: true
 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
-    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
+  # Takes two arrays (can be of different length) and interleaves
+  # them like [a[0], b[0], a[1], b[1]...]
+  def self.interleave(ary_a, ary_b)
+    ary = []
+    [ary_a.size, ary_b.size].max.times do |indx|
+      ary.push(ary_a[indx]) if indx < ary_a.size
+      ary.push(ary_b[indx]) if indx < ary_b.size
     end
     ary
   end
 
+  # Returns the element that occurs the most frequently in an array or
+  def self.most_frequent(*args)
+    totals = args.each_with_object(Hash.new(0)) { |elem, hash| hash[elem] += 1 }
+    max = totals.values.max
+    totals.keys.find { |key| totals[key] == max }
+  end
+
+  # Returns the most commonly occurring string in an arrray of params.
+  # Elements that are not strings are converted to their string representations.
+  #
+  # @param [TrueClass, FalseClass] case_insensitive Compare strings case isensitively.
+  def self.most_frequent_str(*args, case_insensitive: false)
+    most_frequent(*args.map { |arg| case_insensitive ? arg.to_s.downcase : arg.to_s })
+  end
+
+  # Takes an array and averages all of the floats and integers within it.
+  # Non numeric values are ignored.
+  def self.average(ary)
+    numbers = ary.select { |v| BBLib.is_a?(v, Integer, Float) }
+    numbers.inject(0) do |sum, x|
+      sum += x
+    end / numbers.size.to_f
+  end
 end
 
+# Monkey Patches for the Array class
 class Array
+  # Splits all elements in an array using a list of delimiters.
+  def msplit(*delims)
+    map { |elem| elem.msplit(*delims) if elem.respond_to?(:msplit) }.flatten
+  end
+
+  alias multi_split msplit
+
+  # Converts all keys in nested hashes to symbols.
+  def keys_to_sym(clean: false)
+    map { |elem| elem.respond_to?(:keys_to_sym) ? elem.keys_to_sym(clean: clean) : elem }
+  end
 
-  def msplit *delims, keep_empty: false
-    self.map{ |i| i.msplit(delims, keep_empty:keep_empty)}.flatten
+  # Converts all keys in nested hashes to strings.
+  def keys_to_s
+    map { |v| v.respond_to?(:keys_to_s) ? v.keys_to_s : v }
   end
-  alias_method :multi_split, :msplit
 
-  def keys_to_sym clean: false
-    self.map{ |v| v.is_a?(Hash) || v.is_a?(Array) ? v.keys_to_sym(clean:clean) : v }
+  # Takes two arrays (can be of different length) and interleaves
+  # them like [a[0], b[0], a[1], b[1]...]
+  def interleave(ary)
+    BBLib.interleave(self, ary)
   end
 
-  def keys_to_s clean: false
-    self.map{ |v| v.is_a?(Hash) || v.is_a?(Array) ? v.keys_to_s : v }
+  # Displays all elements between this hash and another hash that are different.
+  # @param [Array] ary The ary to compare elements to.
+  def diff(ary)
+    (self - ary) + (ary - self)
   end
 
-  def to_xml level: 0, key:nil
-    map do |v|
-      nested = v.respond_to?(:to_xml)
-      value = nested ? v.to_xml(level:level + 1, key:key) : v
-      "\t" * level + "<#{key}>\n" +
-      (nested ? '' : "\t"*(level+1)) +
-      "#{value}\n" +
-      "\t"*level + "</#{key}>\n"
-    end.join
+  # Creates a tree hash wrapper for this array.
+  def to_tree_hash
+    TreeHash.new(self)
   end
 
-  def interleave b
-    BBLib.interleave self, b
+  # Conventient way to join an array into a comma seperated list with the last two elements
+  # seperated by a word like 'and' or 'or'.
+  # @param seperator [String] The term or phrase to seperate the last two elements by
+  # @param delimiter [String] The delimiter used in the join. This allows something other than ', ' to be used
+  # @param encapsulate [String] This will optionally encapsulate each element with a character or string. Useful to wrap all elements in quotes.
+  # @returns [String] By default returns a comma seperated list with the final elements seperated by an 'and'. Behavior can be overriden using the params.
+  def join_terms(seperator = :and, delimiter: ', ', encapsulate: nil)
+    elements = (encapsulate ? map { |element| element.to_s.encapsulate(encapsulate) } : self)
+    return elements.join(delimiter) if size <= 1
+    return elements.join(" #{seperator} ") if size == 2
+    [elements[0..-2].join(delimiter), elements.last].join(" #{seperator} ")
   end
 
-  def diff b
-    (self-b) + (b-self)
+  def hmap
+    return map unless block_given?
+    map { |v| yield(v) }.to_h
   end
-  
 end

data/lib/bblib.rb

@@ -1,27 +1,27 @@
 require_relative 'bblib/version'
 require_relative 'opal/bbopal'
 require_relative 'object/bbobject'
-require_relative 'object/lazy_class'
+require_relative 'hash/bbhash'
+require_relative 'mixins/bbmixins'
+require_relative 'class/effortless'
+require_relative 'hash_path/hash_path'
 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'
+require_relative 'system/bbsystem'
+require_relative 'logging/bblogging'
+require_relative 'error/abstract'
+require_relative 'html/bbhtml'
 
-non_opal = ['os/bbos', 'gem/bbgem']
-
-unless BBLib::in_opal?
-  non_opal.each{ |i| require_relative i }
-end
+non_opal = ['os/bbos']
 
+non_opal.each { |i| require_relative i } unless BBLib.in_opal?
 
 require 'fileutils'
-# require 'uri'
+require 'time'
 
 module BBLib
-
-  CONFIGS_PATH = 'config/'
-
+  CONFIGS_PATH = 'config/'.freeze
 end

data/lib/bblib/version.rb

@@ -1,3 +1,3 @@
-module BBLib
-  VERSION = "0.3.0"
-end
+module BBLib
+  VERSION = '0.4.1'.freeze
+end

data/lib/class/effortless.rb

@@ -0,0 +1,23 @@
+
+module BBLib
+  module Effortless
+    def self.included(base)
+      base.extend(BBLib::Attrs)
+      base.extend(BBLib::Hooks)
+      base.singleton_class.extend(BBLib::Hooks)
+      base.extend(BBLib::FamilyTree) unless BBLib.in_opal?
+      base.extend(BBLib::Bridge)
+      base.send(:include, BBLib::Serializer)
+      base.send(:include, BBLib::SimpleInit)
+      base.send(:include, BBLib::Logger)
+    end
+
+    def _attrs
+      self.class._attrs
+    end
+  end
+
+  class EffortlessClass
+    include Effortless
+  end
+end

data/lib/error/abstract.rb

@@ -0,0 +1,3 @@
+class AbstractError < StandardError
+  # Enhance at some point
+end

data/lib/file/bbfile.rb

@@ -1,91 +1,132 @@
 
-
 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('/')
+  def self.pathify(*strings)
+    (strings.first.start_with?('/', '\\') ? '/' : '') + 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?
-      filter = [filter].flatten.map{ |f| path.to_s + (recursive ? '/**/' : '/') + f.to_s }
-    else
-      filter = (path.to_s + (recursive ? '/**/*' : '/*')).gsub('//', '/')
-    end
-    Dir.glob(filter)
+  # @param [String] path The directory to scan files from.
+  # @param [String..., Regexp...] filters A list of filters to apply. Can be regular expressions or strings.
+  #  Strings with a * are treated as regular expressions with a .*. If no filters are passed, all files/dirs are returned.
+  # @param [Boolean] recursive When true scan will recursively search directories
+  # @param [Boolean] files If true, paths to files matching the filter will be returned.
+  # @param [Boolean] dirs If true, paths to dirs matching the filter will be returned.
+  def self.scan_dir(path, *filters, recursive: false, files: true, dirs: true, &block)
+    return [] unless Dir.exist?(path)
+    filters = filters.map { |filter| filter.is_a?(Regexp) ? filter : /^#{Regexp.quote(filter).gsub('\\*', '.*')}$/ }
+    Dir.foreach(path).flat_map do |item|
+      next if item =~ /^\.{1,2}$/
+      item = "#{path}/#{item}".gsub('\\', '/')
+      if File.file?(item)
+        if files && (filters.empty? || filters.any? { |filter| item =~ filter })
+          block_given? ? yield(item) : item
+        end
+      elsif File.directory?(item)
+        recur = recursive ? scan_dir(item, *filters, recursive: recursive, files: files, dirs: dirs, &block) : []
+        if dirs && (filters.empty? || filters.any? { |filter| item =~ filter })
+          (block_given? ? yield(item) : [item] + recur)
+        elsif recursive
+          recur
+        end
+      end
+    end.compact
   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? }
+  # Uses BBLib.scan_dir but returns only files
+  def self.scan_files(path, *filters, recursive: false, &block)
+    scan_dir(path, *filters, recursive: recursive, dirs: false, &block)
   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? }
+  # Uses BBLib.scan_dir but returns only directories.
+  def self.scan_dirs(path, *filters, recursive: false, &block)
+    scan_dir(path, *filters, recursive: recursive, files: false, &block)
   end
 
-  # Shorthand method to write a string to disk. 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
-      FileUtils.mkpath File.dirname(path)
-    end
-    File.write(path, str.to_s, mode:mode)
+  def self.string_to_file(str, path, mkpath: true, mode: 'a')
+    FileUtils.mkpath(File.dirname(path)) if mkpath && !Dir.exist?(path)
+    File.write(path, str.to_s, mode: mode)
   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
+  def self.parse_file_size(str, output: :byte)
+    output = FILE_SIZES.keys.find { |fs| fs == output || FILE_SIZES[fs][: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|^)\d*\.?\d+\s*#{e}s?(?=\W|\d|$)/i)
-        numbers.each{ |n| bytes+= n.to_f * v[:mult] }
+    FILE_SIZES.each do |_k, v|
+      v[:exp].each do |exp|
+        str.scan(/(?=\w|\D|^)\d*\.?\d+\s*#{exp}s?(?=\W|\d|$)/i)
+           .each { |num| bytes += num.to_f * v[:mult] }
       end
     end
-    return bytes / FILE_SIZES[output][:mult]
+    bytes / FILE_SIZES[output][:mult]
   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'] },
-    zettabyte: { mult: 1180591620717411303424, exp: ['zb', 'zetta', 'z', 'zbyte', 'zettabyte'] },
-    yottabyte: { mult: 1208925819614629174706176, exp: ['yb', 'yotta', 'y', 'ybyte', 'yottabyte'] }
-  }
+  # Takes an integer or float and converts it into a string that represents
+  #   a file size (e.g. "5 MB 156 kB")
+  # @param [Integer, Float] num The number of bytes to convert to a file size string.
+  # @param [Symbol] input Sets the value of the input. Default is byte.
+  # @param [Symbol] stop Sets a minimum file size to display.
+  #   e.g. If stop is set to :megabyte, :kilobyte and below will be truncated.
+  # @param [Symbol] style The out style, Current options are :short and :long
+  def self.to_file_size(num, input: :byte, stop: :byte, style: :short)
+    return nil unless num.is_a?(Numeric)
+    return '0' if num.zero?
+    style = :short unless [:long, :short].include?(style)
+    expression = []
+    n = num * FILE_SIZES[input.to_sym][:mult]
+    done = false
+    FILE_SIZES.reverse.each do |k, v|
+      next if done
+      done = true if k == stop
+      div = n / v[:mult]
+      next unless 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
+    expression.join(' ')
+  end
 
+  FILE_SIZES = {
+    byte:      { mult: 1, exp: %w(b byt byte), styles: { short: 'B', long: ' byte' } },
+    kilobyte:  { mult: 1024, exp: %w(kb kilo k kbyte kilobyte), styles: { short: 'kB', long: ' kilobyte' } },
+    megabyte:  { mult: 1024**2, exp: %w(mb mega m mib mbyte megabyte), styles: { short: 'MB', long: ' megabyte' } },
+    gigabyte:  { mult: 1024**3, exp: %w(gb giga g gbyte gigabyte), styles: { short: 'GB', long: ' gigabyte' } },
+    terabyte:  { mult: 1024**4, exp: %w(tb tera t tbyte terabyte), styles: { short: 'TB', long: ' terabyte' } },
+    petabyte:  { mult: 1024**5, exp: %w(pb peta p pbyte petabyte), styles: { short: 'PB', long: ' petabyte' } },
+    exabyte:   { mult: 1024**6, exp: %w(eb exa e ebyte exabyte), styles: { short: 'EB', long: ' exabyte' } },
+    zettabyte: { mult: 1024**7, exp: %w(zb zetta z zbyte zettabyte), styles: { short: 'ZB', long: ' zettabyte' } },
+    yottabyte: { mult: 1024**8, exp: %w(yb yotta y ybyte yottabyte), styles: { short: 'YB', long: ' yottabyte' } }
+  }.freeze
 end
 
-class File
-  def dirname
-    File.dirname(self.path)
+# Monkey patches for the Numeric class
+class Numeric
+  def to_file_size(*args)
+    BBLib.to_file_size(self, *args)
   end
 end
 
+# Monkey patches for the String class
 class String
-  def to_file path, mkpath = true, mode: 'a'
-    BBLib.string_to_file path, self, mkpath, mode:mode
+  def to_file(*args)
+    BBLib.string_to_file(self, *args)
   end
 
-  def file_name with_extension = true
-    self[(self.include?('/') ? self.rindex('/').to_i+1 : 0)..(with_extension ? -1 : self.rindex('.').to_i-1)]
+  def file_name(with_extension = true)
+    with_extension ? File.basename(self) : File.basename(self, File.extname(self))
   end
 
   def dirname
-    self.scan(/.*(?=\/)/).first
+    File.dirname(self)
   end
 
-  def parse_file_size output: :byte
-    BBLib.parse_file_size(self, output:output)
+  def parse_file_size(*args)
+    BBLib.parse_file_size(self, *args)
   end
 
   def pathify