bblib 0.3.0 → 0.4.1

data/lib/time/task_timer.rb

@@ -1,107 +1,123 @@
 module BBLib
-
-  class TaskTimer < LazyClass
-    attr_hash :tasks, default: Hash.new
+  # Simple timer that can track tasks based on time. Also provides aggregated metrics
+  #  and history for each task run. Generally useful for benchmarking or logging.
+  #
+  # @author Brandon Black
+  # @attr [Hash] tasks The information on all running tasks and history of all tasks up to the retention.
+  # @attr [Integer] retention The number of runs to collect per task before truncation.
+  class TaskTimer
+    include Effortless
+    attr_hash :tasks, default: {}, serialize: false
     attr_int_between -1, nil, :retention, default: 100
 
-    def time task = :default, type = :current
-      return nil unless @tasks.keys.include? task
-      numbers = @tasks[task][:history].map{ |v| v[:time] }
+    # Returns an aggregated metric for a given type.
+    #
+    # @param [Symbol] task The key value of the task to retrieve
+    # @param [Symbol] type The metric to return.
+    #   Options are :avg, :min, :max, :first, :last, :sum, :all and :count.
+    # @return [Float, Integer, Array] Returns either the aggregation (Numeric) or an Array in the case of :all.
+    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
+        return nil unless tasks[task][:current]
+        Time.now.to_f - tasks[task][:current]
+      when :min, :max, :first, :last
+        numbers.send(type)
       when :avg
-        return numbers.inject{ |sum, n| sum + n }.to_f / numbers.size
+        numbers.size.zero? ? nil : numbers.inject { |sum, n| sum + n }.to_f / numbers.size
       when :sum
-        return numbers.inject{ |sum, n| sum + n }
+        numbers.inject { |sum, n| sum + n }
       when :all
-        return numbers
-      when :first
-        return numbers.first
-      when :last
-        return numbers.last
+        numbers
       when :count
-        return numbers.size
+        numbers.size
       end
     end
 
-    def clear task
-      return nil unless @tasks.keys.include?(task)
+    # Removes all history for a given task
+    #
+    # @param [Symbol] task The name of the task to clear history from.
+    # @return [NilClass] Returns nil
+    def clear(task = :default)
+      return nil unless tasks.keys.include?(task)
       stop task
-      @tasks[task][:history].clear
+      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
+    # Start a new timer for the referenced task. If a timer is already running for that task it will be stopped first.
+    #
+    # @param [Symbol] task The name of the task to start.
+    # @return [Integer] Returns 0
+    def start(task = :default)
+      tasks[task] = { history: [], current: nil } unless tasks.keys.include?(task)
+      stop task if tasks[task][:current]
+      tasks[task][:current] = Time.now.to_f
+      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
+    # Stop the referenced timer.
+    #
+    # @param [Symbol] task The name of the task to stop.
+    # @return [Float, NilClass] The amount of time the task had been running or nil if no matching task was found.
+    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
+    def restart(task = :default)
       start(task) unless stop(task).nil?
     end
 
-    def active? task
-      return false unless @tasks.keys.include? task
-      !@tasks[task][:current].nil?
+    def active?(task = :default)
+      return false unless tasks.keys.include?(task)
+      !tasks[task][:current].nil?
     end
 
-    def stats task, pretty: false
-      return nil unless @tasks.include?(task)
-      stats = "#{task}" + "\n" + '-'*30 + "\n"
-      TIMER_TYPES.each do |k,v|
+    def stats(task = :default, pretty: false)
+      return nil unless tasks.include?(task)
+      TIMER_TYPES.map do |k, _v|
         next if STATS_IGNORE.include?(k)
-        stats+= k.to_s.capitalize.ljust(10) + "#{self.send(k, task, pretty:pretty)}\n"
-      end
-      stats
+        [k, send(k, task, pretty: pretty)]
+      end.compact.to_h
     end
 
-    def method_missing *args, **named
-      temp = args.first.to_sym
-      pretty = named.delete :pretty
-      type, task = TIMER_TYPES.keys.find{ |k| k == temp || TIMER_TYPES[k].include?(temp) }, args[1] ||= :default
+    def method_missing(*args, **named)
+      temp   = args.first.to_sym
+      type   = TIMER_TYPES.keys.find { |k| k == temp || TIMER_TYPES[k].include?(temp) }
       return super unless type
-      t = time task, type
-      pretty && type != :count && t ? (t.is_a?(Array) ? t.map{|m| m.to_duration} : t.to_duration) : t
+      t = time(args[1] || :default, type)
+      return t if type == :count || !named[:pretty]
+      t.is_a?(Array) ? t.map(&:to_duration) : t.to_duration
     end
 
-    private
+    def respond_to_missing?(method, include_private = false)
+      TIMER_TYPES.keys.find { |k| k == method || TIMER_TYPES[k].include?(method) } || super
+    end
 
-      STATS_IGNORE = [:current, :all]
+    TIMER_TYPES = {
+      current: [],
+      count:   [:total],
+      first:   [:initial],
+      last:    [:latest],
+      min:     [:minimum, :smallest],
+      max:     [:maximum, :largest],
+      avg:     [:average, :av],
+      sum:     [],
+      all:     [:times]
+    }.freeze
 
-      TIMER_TYPES = {
-        current: [],
-        count:   [:total],
-        first:   [:initial],
-        last:    [:latest],
-        min:     [:minimum, :smallest],
-        max:     [:maximum, :largest],
-        avg:     [:average, :av],
-        sum:     [],
-        all:     [:times]
-      }
+    protected
 
-      def lazy_init *args
-        if args.first.is_a?(Symbol)
-          start(args.first)
-        end
-      end
+    STATS_IGNORE = [:all].freeze
 
+    def simple_init(*args)
+      start(args.first) if args.first.is_a?(Symbol)
+    end
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bblib
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Brandon Black
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-18 00:00:00.000000000 Z
+date: 2018-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -87,17 +87,31 @@ files:
 - lib/array/bbarray.rb
 - lib/bblib.rb
 - lib/bblib/version.rb
+- lib/class/effortless.rb
+- lib/error/abstract.rb
 - lib/file/bbfile.rb
-- lib/gem/bbgem.rb
 - lib/hash/bbhash.rb
-- lib/hash/hash_path.rb
-- lib/hash/hash_path_proc.rb
-- lib/hash/path_hash.rb
+- lib/hash/hash_struct.rb
+- lib/hash/tree_hash.rb
+- lib/hash_path/hash_path.rb
+- lib/hash_path/part.rb
+- lib/hash_path/path_hash.rb
+- lib/hash_path/proc.rb
+- lib/hash_path/processors.rb
+- lib/html/bbhtml.rb
+- lib/html/builder.rb
+- lib/html/tag.rb
+- lib/logging/bblogging.rb
+- lib/mixins/attrs.rb
+- lib/mixins/bbmixins.rb
+- lib/mixins/bridge.rb
+- lib/mixins/family_tree.rb
+- lib/mixins/hooks.rb
+- lib/mixins/logger.rb
+- lib/mixins/serializer.rb
+- lib/mixins/simple_init.rb
 - lib/number/bbnumber.rb
-- lib/object/attr.rb
 - lib/object/bbobject.rb
-- lib/object/hooks.rb
-- lib/object/lazy_class.rb
 - lib/opal/bbopal.rb
 - lib/os/bbos.rb
 - lib/os/bbsys.rb
@@ -105,7 +119,10 @@ files:
 - lib/string/cases.rb
 - lib/string/fuzzy_matcher.rb
 - lib/string/matching.rb
+- lib/string/pluralization.rb
+- lib/string/regexp.rb
 - lib/string/roman.rb
+- lib/system/bbsystem.rb
 - lib/time/bbtime.rb
 - lib/time/cron.rb
 - lib/time/task_timer.rb
@@ -129,7 +146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.7.4
 signing_key: 
 specification_version: 4
 summary: A library containing many reusable, basic functions.

data/lib/gem/bbgem.rb

@@ -1,28 +0,0 @@
-
-if defined? Gem
-
-  module BBLib
-
-    def self.gem_list
-      Gem::Specification.map(&:name).uniq
-    end
-
-    def self.gem_installed? name
-      BBLib.gem_list.include? name
-    end
-
-  end
-
-  # Convenience method that will try to download and install a gem before requiring it
-  # only if the gem is not already installed
-  def require_gem gem, name = nil
-    name = gem if name.nil?
-    if !BBLib.gem_installed? name
-      return false unless Gem.install gem
-    end
-    require name
-  end
-
-
-
-end

data/lib/hash/hash_path.rb

@@ -1,344 +0,0 @@
-require_relative 'hash_path_proc'
-
-module BBLib
-
-  def self.hash_path hash, *paths, multi_path: false, multi_join: false
-    if multi_path || multi_join
-      results = paths.map{ |path| BBLib.hash_path(hash, path)}
-      results = (0..results.max_by{ |m| m.size }.size - 1).map{ |i| results.map{ |r| r[i] } } if multi_join
-      return results
-    end
-    path = split_path(*paths)
-    matches, recursive = [hash], false
-    until path.empty? || matches.empty?
-      current = path.shift.to_s
-      current = current[0..-2] + '.' + path.shift.to_s if current.end_with?("\\")
-      if current.strip == ''
-        recursive = true
-        next
-      end
-      key, formula = BBLib.analyze_hash_path(current)
-      matches = matches.map do |match|
-        if recursive
-          match.dive(key.to_sym, key)
-        elsif key == '*'
-          match.is_a?(Hash) ? match.values : (match.is_a?(Array) ? match : nil)
-        elsif match.is_a?(Hash)
-          key.is_a?(Regexp) ? match.map{ |k,v| k.to_s =~ key ? v : nil } : [(BBLib::in_opal? ? nil : match[key.to_sym]), match[key]]
-        elsif match.is_a?(Array) && (key.is_a?(Fixnum) || key.is_a?(Range))
-          key.is_a?(Range) ? match[key] : [match[key]]
-        else
-          nil
-        end
-      end.flatten(1).reject{ |m| m.nil? }
-      matches = BBLib.analyze_hash_path_formula(formula, matches)
-      recursive = false
-    end
-    matches
-  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| value.is_a?(Regexp) ? v =~ value : v == value }.to_h.keys
-  end
-
-  def self.hash_path_set hash, *paths, symbols: true, bridge: true
-    paths = paths.find{ |a| a.is_a?(Hash) }
-    paths.each do |path, value|
-      parts = split_path(path)
-      matches = BBLib.hash_path(hash, *parts[0..-2])
-      matches.each do |match|
-        key, formula = BBLib.analyze_hash_path(parts.last)
-        key = match.include?(key.to_sym) || (symbols && !match.include?(key) ) ? key.to_sym : key
-        if match.is_a?(Hash)
-          match[key] = value
-        elsif match.is_a?(Array) && key.is_a?(Fixnum)
-          match[key] = value
-        end
-      end
-      hash.bridge(path, value:value, symbols:symbols) if matches.empty? && bridge
-    end
-    hash
-  end
-
-  def self.hash_path_copy hash, *paths, symbols: true, array: false, overwrite: true, skip_nil: true
-    paths = paths.find{ |a| a.is_a?(Hash) }
-    paths.each do |from, to|
-      value = BBLib.hash_path(hash, from)
-      value = value.first unless array
-      hash.bridge(to, value: value, symbols:symbols, overwrite: overwrite) unless value.nil? && skip_nil
-    end
-    hash
-  end
-
-  def self.hash_path_copy_to from, to, *paths, symbols: true, array: false, overwrite: true, skip_nil: true
-    paths = paths.find{ |a| a.is_a?(Hash) }
-    paths.each do |p_from, p_to|
-      value = BBLib.hash_path(from, p_from)
-      value = value.first unless array
-      to.bridge(p_to, value:value, symbols:symbols, overwrite: overwrite) unless value.nil? && skip_nil
-    end
-    to
-  end
-
-  def self.hash_path_delete hash, *paths
-    deleted = Array.new
-    paths.each do |path|
-      parts = split_path(path)
-      BBLib.hash_path(hash, *parts[0..-2]).each do |match|
-        key, formula = BBLib.analyze_hash_path(parts.last)
-        if match.is_a?(Hash)
-          deleted << match.delete(key) << match.delete(key.to_sym)
-        elsif match.is_a?(Array) && key.is_a?(Fixnum)
-          deleted << match.delete_at(key)
-        end
-      end
-    end
-    deleted.flatten.reject{ |v| v.nil? }
-  end
-
-  def self.hash_path_move hash, *paths
-    BBLib.hash_path_copy hash, *paths
-    BBLib.hash_path_delete hash, *paths.find{|pt| pt.is_a?(Hash) }.keys
-    hash
-  end
-
-  def self.hash_path_move_to from, to, *paths
-    BBLib.hash_path_copy_to from, to, *paths
-    BBLib.hash_path_delete from, *paths.find{|pt| pt.is_a?(Hash) }.keys
-    to
-  end
-
-  protected
-
-    def self.split_path *paths
-      paths.map{|pth| pth.to_s.gsub('..', '. .').scan(/(?:[\(|\[].*?[\)|\]]|[^\.])+/)}.flatten
-    end
-
-    def self.analyze_hash_path path
-      return '', nil if path == '' || path.nil?
-      key = path.scan(/^.*^[^\(]*/i).first.to_s
-      if key =~ /^\[\d+\]$/
-        key = key[1..-2].to_i
-      elsif key =~ /\[\-?\d+\.\s?\.{1,2}\-?\d+\]/
-        bounds = key.scan(/\-?\d+/).map{|x| x.to_i}
-        key = key =~ /\.\s?\.{2}/ ? (bounds.first...bounds.last) : (bounds.first..bounds.last)
-      elsif key =~ /\/.*[\/|\/i]$/
-        if key.end_with?('i')
-          key = /#{key[1..-3]}/i
-        else
-          key = /#{key[1..-2]}/
-        end
-      end
-      formula = path.scan(/\(.*\)/).first
-      return key, formula
-    end
-
-    def self.analyze_hash_path_formula formula, hashes
-      return hashes unless formula
-      hashes.map do |p|
-        begin
-          if eval(p.is_a?(Hash) ? formula.gsub('$', "(#{p})") : formula.gsub('$', p.to_s))
-            p
-          else
-            nil
-          end
-        rescue StandardError, Exception => e
-          # Do nothing, the formula failed and we reject the value as a false
-        end
-      end.reject{ |x| x.nil? }
-    end
-
-    def self.hash_path_nav obj, path = '', delimiter = '.', &block
-      case [obj.class]
-      when [Hash]
-        obj.each{ |k,v| hash_path_nav(v, "#{path.nil? ? k.to_s : [path, k].join(delimiter)}", delimiter, &block) }
-      when [Array]
-        index = 0
-        obj.each{ |o| hash_path_nav(o, "#{path.nil? ? "[#{index}]" : [path, "[#{index}]" ].join(delimiter)}", delimiter, &block) ; index+=1 }
-      else
-        yield path, obj
-      end
-    end
-
-end
-
-
-
-class Hash
-
-  def hash_path *path
-    BBLib.hash_path self, *path
-  end
-
-  def hash_path_set *paths
-    BBLib.hash_path_set self, *paths
-  end
-
-  def hash_path_copy *paths
-    BBLib.hash_path_copy self, *paths
-  end
-
-  def hash_path_copy_to to, *paths
-    BBLib.hash_path_copy_to self, to, *paths
-  end
-
-  def hash_path_delete *paths
-    BBLib.hash_path_delete self, *paths
-  end
-
-  def hash_path_move *paths
-    BBLib.hash_path_move self, *paths
-  end
-
-  def hash_path_move_to to, *paths
-    BBLib.hash_path_move_to self, to, *paths
-  end
-
-  def hash_paths
-    BBLib.hash_path_keys self
-  end
-
-  def hash_path_for value
-    BBLib.hash_path_key_for self, value
-  end
-
-  alias_method :hpath, :hash_path
-  alias_method :hpath_set, :hash_path_set
-  alias_method :hpath_move, :hash_path_move
-  alias_method :hpath_move_to, :hash_path_move_to
-  alias_method :hpath_delete, :hash_path_delete
-  alias_method :hpath_copy, :hash_path_copy
-  alias_method :hpath_copy_to, :hash_path_copy_to
-  alias_method :hpaths, :hash_paths
-  alias_method :hpath_for, :hash_path_for
-
-  # Returns all matching values with a specific key (or Array of keys) recursively within a Hash (including nested Arrays)
-  def dive *keys
-    matches = Array.new
-    self.each do |k, v|
-      if keys.any?{ |a| (a.is_a?(Regexp) ? a =~ k : a == k ) } then matches << v end
-      if v.respond_to? :dive
-        matches+= v.dive(*keys)
-      end
-    end
-    matches
-  end
-
-  # Turns nested values' keys into delimiter separated paths
-  def squish delimiter: '.'
-    sh = Hash.new
-    BBLib.hash_path_nav(self.dup, nil, delimiter){ |k, v| sh[k] = v }
-    sh
-  end
-
-  # Expands keys in a hash using a delimiter. Opposite of squish.
-  def expand **args
-    eh = Hash.new
-    self.dup.each do |k,v|
-      eh.bridge k, args.merge({value:v})
-    end
-    return eh
-  end
-
-  # Add a hash path to a hash
-  def bridge *path, value:nil, delimiter: '.', symbols: true, overwrite: false
-    path = path.msplit(delimiter).flatten
-    hash, part, bail, last = self, nil, false, nil
-    while !path.empty? && !bail
-      part = path.shift
-      if part =~ /\A\[\d+\]\z/
-        part = part[1..-2].to_i
-      else
-        part = part.to_sym if symbols
-      end
-      if (hash.is_a?(Hash) && hash.include?(part) || hash.is_a?(Array) && hash.size > part.to_i) && !overwrite
-        bail = true if !hash[part].is_a?(Hash) && !hash[part].is_a?(Array)
-        hash = hash[part] unless bail
-      else
-        hash[part] = path.first =~ /\A\[\d+\]\z/ ? Array.new : Hash.new
-        hash = hash[part] unless bail || path.empty?
-      end
-    end
-    hash[part] = value unless bail
-    self
-  end
-
-end
-
-class Array
-
-  def hash_path *path
-    BBLib.hash_path self, *path
-  end
-
-  def hash_path_set *paths
-    BBLib.hash_path_set self, *paths
-  end
-
-  def hash_path_copy *paths
-    BBLib.hash_path_copy self, *paths
-  end
-
-  def hash_path_copy_to to, *paths
-    BBLib.hash_path_copy_to self, to, *paths
-  end
-
-  def hash_path_delete *paths
-    BBLib.hash_path_delete self, *paths
-  end
-
-  def hash_path_move *paths
-    BBLib.hash_path_move self, *paths
-  end
-
-  def hash_path_move_to to, *paths
-    BBLib.hash_path_move_to self, to, *paths
-  end
-
-  def hash_paths
-    BBLib.hash_path_keys self
-  end
-
-  def hash_path_for value
-    BBLib.hash_path_key_for self, value
-  end
-
-  alias_method :hpath, :hash_path
-  alias_method :hpath_set, :hash_path_set
-  alias_method :hpath_move, :hash_path_move
-  alias_method :hpath_move_to, :hash_path_move_to
-  alias_method :hpath_delete, :hash_path_delete
-  alias_method :hpath_copy, :hash_path_copy
-  alias_method :hpath_copy_to, :hash_path_copy_to
-  alias_method :hpaths, :hash_paths
-  alias_method :hpath_for, :hash_path_for
-
-  def dive *keys
-    matches = []
-    self.each do |i|
-      matches+= i.dive(*keys) if i.respond_to?(:dive)
-    end
-    matches
-  end
-
-  # Turns nested values' keys into delimiter separated paths
-  def squish delimiter: '.'
-    sh = Hash.new
-    BBLib.hash_path_nav(self.dup, nil, delimiter){ |k, v| sh[k] = v }
-    sh
-  end
-
-  # Expands keys in a hash using a delimiter. Opposite of squish.
-  def expand **args
-    eh = Hash.new
-    self.dup.each do |k,v|
-      eh.bridge k, args.merge({value:v})
-    end
-    return eh
-  end
-
-end