bblib 1.0.2 → 2.0.0

data/lib/bblib/core/mixins/delegator.rb

@@ -0,0 +1,90 @@
+
+module BBLib
+  module Delegator
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send(:attr_ary, :instance_delegates)
+    end
+
+    def delegates
+      (instance_delegates + self.class.delegates).uniq
+    end
+
+    protected
+
+    def method_missing(method, *args, &block)
+      delegates.each do |delegate|
+        case delegate
+        when Symbol
+          next unless respond_to?(delegate) && method(delegate).arity == 0
+          object = send(delegate)
+          next unless object.respond_to?(method)
+          return object.send(method, *args, &block)
+        else
+          next unless delegate.respond_to?(method)
+          return delegate.send(method, *args, &block)
+        end
+      end
+      super
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      return super if self.class.delegate_fast
+      super || delegates.any? do |delegate|
+        next if delegate == self # Protection from recursion
+        case delegate
+        when Symbol
+          self.method(delegate)&.arity == 0 &&
+          send(delegate).respond_to?(method)
+        else
+          delegate.respond_to?(method)
+        end
+      end
+    end
+
+    def delegate_to(*mthds)
+      mthds.flatten.each do |method|
+        next if instance_delegates.include?(method)
+        instance_delegates << method
+      end
+      true
+    end
+
+    module ClassMethods
+      # When turned on the respond_to_missing method is left unchanged.
+      # This GREATLY speeds up the instantiation of classes with lots of
+      # calls to respond_to?
+      def delegate_fast(*args)
+        return @delegate_fast ||= _ancestor_delegate_fast if args.empty?
+        @delegate_fast = args.first ? true : false
+      end
+
+      def delegate_to(*mthds)
+        mthds.flatten.each do |method|
+          next if delegates.include?(method)
+          delegates << method
+        end
+        true
+      end
+
+      def _ancestor_delegate_fast
+        ancestors.reverse.find do |anc|
+          next unless anc.respond_to?(:delegate_fast)
+          return anc.delegate_fast
+        end
+        true
+      end
+
+      def delegates
+        @delegates ||= ancestor_delegates
+      end
+
+      def ancestor_delegates
+        ancestors.reverse.flat_map do |anc|
+          next if anc == self || !anc.respond_to?(:delegates)
+          anc.delegates
+        end.compact.uniq
+      end
+    end
+  end
+end

data/lib/{mixins → bblib/core/mixins}/family_tree.rb

@@ -18,7 +18,7 @@ module BBLib
     def direct_descendants(include_singletons = false)
       return _inherited_by if BBLib.in_opal?
       ObjectSpace.each_object(Class).select do |c|
-        (include_singletons || !c.singleton_class?) && c.ancestors[1] == self
+        (include_singletons || !c.singleton_class?) && c.ancestors[1..-1].find { |k| k.is_a?(Class) } == self
       end
     end
 

data/lib/{mixins → bblib/core/mixins}/simple_init.rb

@@ -6,7 +6,11 @@ module BBLib
   module SimpleInit
     attr_reader :_init_type
 
-    INIT_TYPES = [:strict, :loose].freeze
+    # strict - Raise exceptions for unknown named attributes
+    # loose - Ignore unknown named attributes
+    # collect - Put unknown named attributes into the attribute
+    #           configured by collect_attribute
+    INIT_TYPES = [:strict, :loose, :collect].freeze
 
     def self.included(base)
       base.extend ClassMethods
@@ -20,6 +24,8 @@ module BBLib
             result = instance_eval(&block)
             simple_init_block_result(result) if respond_to?(:simple_init_block_result, true)
           end
+          send(:simple_postinit, *args, &block) if respond_to?(:simple_postinit, true)
+          self
         end
       end
 
@@ -39,6 +45,8 @@ module BBLib
               end
               raise ArgumentError, "Unknown #{init_foundation_method} \"#{named[init_foundation_method]}\" for #{self}" unless klass
               klass == self ? __new(*args, &block) : klass.new(*args, &block)
+            elsif named[init_foundation_method].nil? && init_foundation_default_class != self
+              init_foundation_default_class.new(*args, &block)
             else
               __new(*args, &block)
             end
@@ -64,6 +72,8 @@ module BBLib
             end
             raise ArgumentError, "Unknown #{init_foundation_method} \"#{named[init_foundation_method]}\"" unless klass
             klass == self ? super : klass.new(*args, &block)
+          elsif named[init_foundation_method].nil? && init_foundation_default_class != self && init_foundation_default_class < self
+            init_foundation_default_class.new(*args, &block)
           else
             super
           end
@@ -99,6 +109,23 @@ module BBLib
         self.init_foundation_compare(&block) if block
       end
 
+      def init_foundation_default_class
+        self
+      end
+
+      def collect_method(name = nil)
+        @collect_method = name if name
+        @collect_method ||= _super_collect_method
+      end
+
+      def _super_collect_method
+          ancestors.each do |ancestor|
+            next if ancestor == self
+            return ancestor.collect_method if ancestor.respond_to?(:collect_method)
+          end
+          :attributes
+      end
+
       def ancestor_init_foundation_method
         anc = ancestors.find do |a|
           next if a == self
@@ -175,16 +202,27 @@ module BBLib
           next unless !set_v_arg.include?(method) && details[:options][:required] && !named.include?(method) && !send(method)
           method
         end.compact
-        raise ArgumentError, "You are missing the following required #{BBLib.pluralize('argument', missing.size)}: #{missing.join_terms}" unless missing.empty?
+        raise ArgumentError, "You are missing the following required #{BBLib.pluralize('argument', missing.size)} for #{self.class}: #{missing.join_terms}" unless missing.empty?
       end
       named.each do |method, value|
         next if method == self.class.init_foundation_method
         setter = "#{method}="
         exists = respond_to?(setter)
-        raise ArgumentError, "Undefined attribute #{setter} for class #{self.class}." if !exists && self.class.init_type == :strict
+        if !exists && self.class.init_type == :strict
+          raise ArgumentError, "Undefined attribute #{setter} for class #{self.class}."
+        elsif !exists && self.class.init_type == :collect
+          _collect_attribute(method, value)
+        end
         next unless exists
         send(setter, value)
       end
     end
+
+    def _collect_attribute(method, value)
+      inst_name = "@#{self.class.collect_method}"
+      hash = instance_variable_get(inst_name)
+      hash = instance_variable_set(inst_name, {}) unless hash.is_a?(Hash)
+      hash[method] = value
+    end
   end
 end

data/lib/{file/bbfile.rb → bblib/core/util/file.rb}

@@ -14,7 +14,7 @@ module BBLib
   # @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.
   # @param [Array] exclude Can be an array of regular expressions or strings that should be ignored when scanning. * in a string is expanded into .*, but all other characters are literal.
-  def self.scan_dir(path, *filters, recursive: false, files: true, dirs: true, exclude: [], &block)
+  def self.scan_dir(path, *filters, recursive: false, files: true, dirs: true, exclude: [], filter_base: true, &block)
     return [] unless Dir.exist?(path)
     filters = filters.map { |filter| filter.is_a?(Regexp) ? filter : /^#{Regexp.quote(filter).gsub('\\*', '.*')}$/ }
     exclude = exclude ? [exclude].flatten.map { |exp| exp.is_a?(Regexp) ? exp : /^#{Regexp.quote(exp).gsub('\\*', '.*')}$/ } : []
@@ -22,12 +22,12 @@ module BBLib
       next if item =~ /^\.{1,2}$/ || (!exclude.empty? && exclude.any? { |exp| item =~ exp })
       item = "#{path}/#{item}".gsub('\\', '/')
       if File.file?(item)
-        if files && (filters.empty? || filters.any? { |filter| item =~ filter })
+        if files && (filters.empty? || filters.any? { |filter| item =~ filter || filter_base && item.file_name =~ filter })
           block_given? ? yield(item) : item
         end
       elsif File.directory?(item)
         recur = recursive ? scan_dir(item, *filters, recursive: recursive, exclude: exclude, files: files, dirs: dirs, &block) : []
-        if dirs && (filters.empty? || filters.any? { |filter| item =~ filter })
+        if dirs && (filters.empty? || filters.any? { |filter| item =~ filter || filter_base && item.file_name =~ filter })
           (block_given? ? yield(item) : [item] + recur)
         elsif recursive
           recur
@@ -37,13 +37,13 @@ module BBLib
   end
 
   # Uses BBLib.scan_dir but returns only files
-  def self.scan_files(path, *filters, recursive: false, exclude: [], &block)
-    scan_dir(path, *filters, recursive: recursive, dirs: false, exclude: exclude, &block)
+  def self.scan_files(path, *filters, recursive: false, exclude: [], filter_base: true, &block)
+    scan_dir(path, *filters, recursive: recursive, dirs: false, exclude: exclude, filter_base: filter_base, &block)
   end
 
   # Uses BBLib.scan_dir but returns only directories.
-  def self.scan_dirs(path, *filters, recursive: false, exclude: [], &block)
-    scan_dir(path, *filters, recursive: recursive, files: false, exclude: exclude, &block)
+  def self.scan_dirs(path, *filters, recursive: false, exclude: [], filter_base: true, &block)
+    scan_dir(path, *filters, recursive: recursive, files: false, exclude: exclude, filter_base: filter_base, &block)
   end
 
   # Shorthand method to write a string to disk. By default the
@@ -104,6 +104,30 @@ module BBLib
     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
+
+  # Basic detection for whether or not a file is binary or not
+  def self.binary?(file, bytes: 1024, ctrl_threshold: 0.5, binary_threshold: 0.05)
+    ascii  = 0
+    ctrl   = 0
+    binary = 0
+
+    read_bytes = File.open(file, 'rb') { |io| io.read(bytes) }
+
+    return false if read_bytes.nil? || read_bytes.empty?
+
+    read_bytes.each_byte do |byte|
+      case byte
+      when 0..31
+        ctrl += 1
+      when 32..127
+        ascii += 1
+      else
+        binary += 1
+      end
+    end
+
+    ctrl.to_f / ascii > ctrl_threshold || binary.to_f / ascii > binary_threshold
+  end
 end
 
 # Monkey patches for the Numeric class

data/lib/{hash/bbhash.rb → bblib/core/util/hash.rb}

@@ -1,7 +1,4 @@
 
-require_relative 'tree_hash'
-require_relative 'hash_struct'
-
 class Hash
   # Merges with another hash but also merges all nested hashes and arrays/values.
   def deep_merge(with, merge_arrays: true, overwrite: true, uniq: false)

data/lib/{logging/bblogging.rb → bblib/core/util/logging.rb}

@@ -10,10 +10,11 @@ module BBLib
     log = ::Logger.new(STDOUT)
     log.level = ::Logger::INFO
     log.formatter = proc do |severity, datetime, progname, msg|
+      severity = severity.to_s.to_color(severity) if BBLib.color_logs
       if msg.is_a?(Exception)
         msg = msg.inspect + "\n\t" + msg.backtrace.join("\n\t")
       end
-      "[#{datetime}] #{severity} - #{msg.to_s.chomp}\n"
+      "#{datetime} [#{severity}] #{msg.to_s.chomp}\n"
     end
     log.datetime_format = '%Y-%m-%d %H:%M:%S'
     log
@@ -32,10 +33,18 @@ module BBLib
     @logger_on
   end
 
+  def self.color_logs
+    @color_logs
+  end
+
+  def self.color_logs=(toggle)
+    @color_logs = (toggle ? true : false)
+  end
+
   class << self
     [:fatal, :error, :warn, :info, :debug].each do |sev|
       define_method(sev) do |*args|
-        logger.send(sev, *args)
+        logger.send(sev, *args) if logger
       end
     end
   end

data/lib/{object/bbobject.rb → bblib/core/util/object.rb}

@@ -7,6 +7,8 @@ module BBLib
     klasses.any? { |klass| obj.is_a?(klass) }
   end
 
+  # Takes any type of object and converts it into a hash based on its instance
+  # variables.
   def self.to_hash(obj)
     return { obj => nil } if obj.instance_variables.empty?
     hash = {}

data/lib/{string/bbstring.rb → bblib/core/util/string.rb}

@@ -1,8 +1,5 @@
-
-# frozen_string_literal: true
 require_relative 'matching'
 require_relative 'roman'
-require_relative 'fuzzy_matcher'
 require_relative 'cases'
 require_relative 'regexp'
 require_relative 'pluralization'
@@ -25,9 +22,12 @@ module BBLib
          .map { |m| convert ? m.to_f : m }
   end
 
+  EXTRACT_NUMBER_REGEXP = /(?<=[^\.]|^)\d+\.\d+(?=[^\.]|$)|(?<=[^\.\d]|^)\d+(?=[^\.\d]|$)/
+  EXTRACT_NUMBER_REGEXP_NO_INNER = /(?<=[^\.]|^)\d+\.\d+(?=[^\.]|$)|(?<=[^\.\d\w]|^)\d+(?=[^\.\d\w]|$)/
+
   # Extracts any correctly formed integers or floats from a string
-  def self.extract_numbers(str, convert: true)
-    str.scan(/\d+\.\d+(?<=[^\.])|\d+(?<=[^\.])|\d+\.\d+$|\d+$/)
+  def self.extract_numbers(str, convert: true, include_inner: true)
+    str.scan(include_inner ? EXTRACT_NUMBER_REGEXP : EXTRACT_NUMBER_REGEXP_NO_INNER)
        .map { |f| convert ? (f.include?('.') ? f.to_f : f.to_i) : f }
   end
 
@@ -99,15 +99,18 @@ module BBLib
   # a context (either a Hash or Object) to then interpolate in placeholders.
   # The default pattern looks for {{method_name}} within the string but can be
   # customized to a different pattern by setting the pattern named argument.
-  def self.pattern_render(text, context = {}, pattern: /\{{2}.*?\}{2}/, field_pattern: /(?<=^\{{2}).*(?=\}{2})/)
+  def self.pattern_render(text, context = {})
     raise ArgumentError, "Expected text argument to be a String, got a #{text.class}" unless text.is_a?(String)
-    txt = text.dup
+    # TODO Make patterns customizable
+    pattern       = /\{{2}.*?\}{2}/
+    field_pattern = /(?<=^\{{2}).*(?=\}{2})/
+    txt           = text.dup
     txt.scan(pattern).each do |match|
       field = match.scan(field_pattern).first
       next unless field
       value = case context
       when Hash
-        context[field.to_sym] || context[field]
+        context.hpath(field).first
       else
         context.send(field) if context.respond_to?(field)
       end.to_s
@@ -130,7 +133,7 @@ class String
 
   # Split on delimiters
   def quote_split(*delimiters)
-    encap_split('"\'', *delimiters)
+    encap_split(%w{" '}, *delimiters)
   end
 
   alias qsplit quote_split
@@ -138,21 +141,12 @@ class String
   # Split on only delimiters not between specific encapsulators
   # Various characters are special and automatically recognized such as parens
   # which automatically match anything between a begin and end character.
-  def encap_split(encapsulator, *delimiters)
-    pattern = case encapsulator
-              when '('
-                '\\(\\)'
-              when '['
-                '\\[\\]'
-              when '{'
-                '\\{\\}'
-              when '<'
-                '\\<\\>'
-              else
-                encapsulator
-              end
-    patterns = delimiters.map { |d| /#{Regexp.escape(d)}(?=(?:[^#{pattern}]|[#{pattern}][^#{pattern}]*[#{pattern}])*$)/}
-    msplit(*patterns)
+  #
+  # Regex below is no longer used because of how inefficient it is.
+  # Comment is left in case it is ever useful again
+  # /(?<group>\((?:[^\(\)]*|\g<group>)*\)[^\(\)]*?),|,(?<=[^\(\)|$])/
+  def encap_split(expressions, *delimiters, **opts)
+    BBLib::Splitter.split(self, *delimiters, **opts.merge(expressions: expressions))
   end
 
   alias esplit encap_split

data/lib/{time/bbtime.rb → bblib/core/util/time.rb}

@@ -1,7 +1,3 @@
-# frozen_string_literal: true
-require_relative 'task_timer'
-require_relative 'cron'
-
 module BBLib
   # Parses known time based patterns out of a string to construct a numeric duration.
   def self.parse_duration(str, output: :sec, min_interval: :sec)
@@ -173,7 +169,7 @@ end
 
 class Numeric
   include BBLib::Durations
-  
+
   def to_duration(input: :sec, stop: :milli, style: :medium)
     BBLib.to_duration self, input: input, stop: stop, style: style
   end