bblib 0.3.0 → 0.4.1

data/lib/number/bbnumber.rb

@@ -1,12 +1,20 @@
 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.
+  # 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
+  def self.keep_between(num, min, max)
+    num = num.to_f unless num.is_a?(Numeric)
+    num = min if min && num < min
+    num = max if max && num > max
+    num
   end
 
+  # Similar to keep between but when a number exceeds max or is less than min
+  # it is looped to the min or max value respectively.
+  def self.loop_between(num, min, max)
+    num = num.to_f unless num.is_a?(Numeric)
+    num = max if min && num < min
+    num = min if max && num > max
+    num
+  end
 end

data/lib/object/bbobject.rb

@@ -1,44 +1,71 @@
-require_relative 'attr'
-require_relative 'hooks'
-require_relative 'simple_serialize'
+# frozen_string_literal: true
+# require_relative 'attr'
+# require_relative 'hooks'
 
 module BBLib
+  def self.are_all?(klass, *vars)
+    vars.all? { |var| var.is_a?(klass) }
+  end
+
+  def self.is_a?(obj, *klasses)
+    klasses.any? { |klass| obj.is_a?(klass) }
+  end
 
-  def self.to_hash obj
-    return {obj => nil} unless !obj.instance_variables.empty?
+  def self.to_hash(obj)
+    return { obj => nil } if obj.instance_variables.empty?
     hash = {}
     obj.instance_variables.each do |var|
       value = obj.instance_variable_get(var)
-      if value.is_a? Array
-        hash[var.to_s.delete("@")] = value.map{ |v| v.respond_to?(:obj_to_hash) && !v.instance_variables.empty? ? v.obj_to_hash : v }
-      elsif value.is_a? Hash
+      if value.is_a?(Array)
+        hash[var.to_s.delete('@')] = value.map { |v| v.respond_to?(:obj_to_hash) && !v.instance_variables.empty? ? v.obj_to_hash : v }
+      elsif value.is_a?(Hash)
         begin
-          if !hash[var.to_s.delete("@")].is_a?(Hash) then hash[var.to_s.delete("@")] = Hash.new end
+          unless hash[var.to_s.delete('@')].is_a?(Hash) then hash[var.to_s.delete('@')] = {} end
         rescue
-          hash[var.to_s.delete("@")] = Hash.new
+          hash[var.to_s.delete('@')] = {}
         end
         value.each do |k, v|
-          hash[var.to_s.delete("@")][k.to_s.delete("@")] = v.respond_to?(:obj_to_hash) && !v.instance_variables.empty? ? v.obj_to_hash : v
+          hash[var.to_s.delete('@')][k.to_s.delete('@')] = v.respond_to?(:obj_to_hash) && !v.instance_variables.empty? ? v.obj_to_hash : v
         end
       elsif value.respond_to?(:obj_to_hash) && !value.instance_variables.empty?
-        hash[var.to_s.delete("@")] = value.obj_to_hash
+        hash[var.to_s.delete('@')] = value.obj_to_hash
       else
-        hash[var.to_s.delete("@")] = value
+        hash[var.to_s.delete('@')] = value
       end
     end
-    return hash
+    hash
   end
 
-  def self.named_args *args
-    args.last.is_a?(Hash) && args.last.keys.all?{|k|k.is_a?(Symbol)} ? args.last : Hash.new
+  def self.named_args(*args)
+    args.last.is_a?(Hash) && args.last.keys.all? { |k| k.is_a?(Symbol) } ? args.last : {}
   end
 
-  def self.named_args! *args
-    if args.last.is_a?(Hash) && args.last.keys.all?{|k|k.is_a?(Symbol)}
+  def self.named_args!(*args)
+    if args.last.is_a?(Hash) && args.last.keys.all? { |k| k.is_a?(Symbol) }
       args.delete_at(-1)
     else
-      Hash.new
+      {}
     end
   end
 
+  def self.hash_args(*args)
+    args.find_all { |a| a.is_a?(Hash) }.each_with_object({}) { |a, h| h.merge!(a) }
+  end
+
+  def self.recursive_send(obj, *methods)
+    methods.each do |args|
+      obj = obj.send(*args)
+    end
+    obj
+  end
+
+  def self.namespace_of(klass)
+    split = klass.to_s.split('::')
+    return klass if split.size == 1
+    Object.const_get(split[0..-2].join('::'))
+  end
+
+  def self.root_namespace_of(klass)
+    Object.const_get(klass.to_s.gsub(/::.*/, ''))
+  end
 end

data/lib/opal/bbopal.rb

@@ -1,16 +1,12 @@
 module BBLib
-
   def self.in_opal?
     RUBY_ENGINE == 'opal'
   end
-
 end
 
 if BBLib.in_opal?
   class Element
-
     alias_native :replace_with, :replaceWith
     alias_native :prepend
-    alias_native :get_context, :getContext
   end
 end

data/lib/os/bbos.rb

@@ -1,9 +1,7 @@
 require_relative 'bbsys'
 
 module BBLib
-
   module OS
-
     def self.os
       return :windows if windows?
       return :mac if mac?
@@ -11,7 +9,7 @@ module BBLib
     end
 
     def self.windows?
-      builds = ['mingw', 'mswin', 'cygwin', 'bccwin']
+      builds = %w(mingw mswin cygwin bccwin)
       !(/#{builds.join('|')}/i =~ RUBY_PLATFORM).nil?
     end
 
@@ -31,13 +29,13 @@ module BBLib
     def self.os_info
       if windows?
         data = `wmic os get manufacturer,name,organization,osarchitecture,version /format:list`
-        data = data.split("\n").reject{ |r| r.strip == '' }.map do |m|
+        data = data.split("\n").reject { |r| r.strip == '' }.map do |m|
           spl = m.split('=')
           [spl.first.to_clean_sym.downcase, spl[1..-1].join('=')]
         end.to_h
         data[:name] = data[:name].split('|').first
         data[:osarchitecture] = data[:osarchitecture].extract_integers.first
-        data.hpath_move( 'osarchitecture' => 'bits' )
+        data.hpath_move('osarchitecture' => 'bits')
         data[:host] = `hostname`.strip
         data[:os] = os
         data
@@ -57,12 +55,12 @@ module BBLib
           # Try finding the release file and parsing it instead of lsb_release
           begin
             release = `cat /etc/*release`
-              .split("\n")
-              .reject{ |l| !(l.include?(':') || l.include?('=')) }
-              .map{|l| l.msplit('=',':') }
-              .map{ |a| [a.first.downcase.to_clean_sym, a[1..-1].join(':').uncapsulate] }
-              .to_h
-          rescue
+                      .split("\n")
+                      .reject { |l| !(l.include?(':') || l.include?('=')) }
+                      .map { |l| l.msplit('=', ':') }
+                      .map { |a| [a.first.downcase.to_clean_sym, a[1..-1].join(':').uncapsulate] }
+                      .to_h
+          rescue StandardError => e
             # Both attempts failed
           end
         end
@@ -78,16 +76,26 @@ module BBLib
     # The following is Windows specific code
     if windows?
 
-      def self.parse_wmic cmd
+      def self.parse_wmic(cmd)
         `#{cmd} /format:list`
           .split("\n\n\n").reject(&:empty?)
-          .map{ |l| l.split("\n\n")
-            .map{ |l| spl = l.split('='); [spl.first.strip.downcase.to_clean_sym, spl[1..-1].join('=').strip ] }.to_h
-          }.reject(&:empty?)
+          .map do |l|
+            l.split("\n\n")
+             .map { |l| spl = l.split('='); [spl.first.strip.downcase.to_clean_sym, spl[1..-1].join('=').strip] }.to_h
+          end.reject(&:empty?)
       end
 
     end
 
+    # Mostly platform agnost way to find the full path of an executable in the current env path.
+    def self.which(cmd)
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        (ENV['PATHEXT']&.split(';') || ['']).each do |ext|
+          executable = File.join(path, "#{cmd}#{ext.downcase}").pathify
+          return executable if File.executable?(executable) && !File.directory?(executable)
+        end
+      end
+      nil
+    end
   end
-
 end

data/lib/os/bbsys.rb

@@ -1,24 +1,21 @@
 
-
-
 module BBLib
   module OS
-
     def self.cpu_usages
       if windows?
-        {
-          total: `wmic cpu get loadpercentage /format:value`.extract_numbers.first.to_f
-        }
+        { total: `wmic cpu get loadpercentage /format:value`.extract_numbers.first.to_f }
       elsif linux? || mac?
         system_stats[:cpu]
-      else
-        nil
       end
     end
 
+    def self.up_since
+      Time.now - uptime
+    end
+
     def self.uptime
       if windows?
-        uptime = `net statistics server`.split("\n").find{|l| l.start_with?('Statistics since ')}.split(/since /i).last.strip
+        uptime = `net statistics server`.split("\n").find { |l| l.start_with?('Statistics since ') }.split(/since /i).last.strip
         Time.now - Time.strptime(uptime, '%m/%d/%Y %l:%M:%S %p')
       else
         `cat /proc/uptime`.extract_numbers.first
@@ -33,13 +30,20 @@ module BBLib
       100 - cpu_used
     end
 
+    def self.current_memory_usage(output = :byte)
+      if windows?
+        `tasklist /FI "PID eq #{$$}" /FO list`
+          .split("\n").find { |l| l =~ /^Mem Usage:/ }&.gsub(',', '').parse_file_size(output: output)
+      else
+        processes.find { |pr| pr[:pid] == $$ }[:memory]
+      end
+    end
+
     def self.mem_total
       if windows?
         `wmic computersystem get TotalPhysicalMemory`.extract_numbers.first / 1024.0
       elsif linux?
         system_stats.hpath('memory.total')
-      else
-        nil
       end
     end
 
@@ -56,8 +60,6 @@ module BBLib
         `wmic os get freephysicalmemory /format:value`.extract_numbers.first
       elsif linux?
         system_stats.hpath('memory.free')
-      else
-        nil
       end
     end
 
@@ -83,16 +85,16 @@ module BBLib
         }
       else
         stats = `top -b -n2 -d 0.1`.split("\n")
-        cpu   = stats.find_all{|l| l =~ /\A\%?Cpu\(s\)/i }.last.extract_numbers
-        loads = stats.find_all{|l| l =~ / load average\: /i }.last.scan(/load average:.*/i).first.extract_numbers
-        mem   = stats.find_all{|l| l =~ /KiB Mem|Mem\:/i }.last.extract_numbers
+        cpu   = stats.find_all { |l| l =~ /\A\%?Cpu\(s\)/i }.last.extract_numbers
+        loads = stats.find_all { |l| l =~ / load average\: /i }.last.scan(/load average:.*/i).first.extract_numbers
+        mem   = stats.find_all { |l| l =~ /KiB Mem|Mem\:/i }.last.extract_numbers
         time  = `cat /proc/uptime`.extract_numbers
         {
           cpu: {
             user:                cpu[0],
             system:              cpu[1],
             nice:                cpu[2],
-            total:               cpu[0..2].inject(0){ |sum, v| sum += v.to_f },
+            total:               cpu[0..2].inject(0) { |sum, v| sum += v.to_f },
             idle:                cpu[3],
             wait:                cpu[4],
             hardware_interrupts: cpu[5],
@@ -123,39 +125,52 @@ module BBLib
         tasks = `tasklist /v`
         cpu = `wmic path win32_perfformatteddata_perfproc_process get PercentProcessorTime,percentusertime,IDProcess /format:list`
         cpu = cpu.split("\n\n\n\n").reject(&:empty?)
-              .map{ |l| l.scan(/\d+/).map(&:to_i)}
-              .map{ |n|[ n[0], {cpu: n[1], user: n[2] }]}.to_h
-        lines = tasks.split("\n")[3..-1].map{ |l| l.split(/\s{2,}/) }
-        mem = mem_total
-        cmds = `wmic process get processid,commandline /format:csv`.split("\n")[1..-1].reject{ |r| r.strip  == ''}.map{ |l| l.split(',')[1..-1] }.map{ |l| [l.last.to_i, l[0..-2].join(',')]}.to_h
+                 .map { |l| l.scan(/\d+/).map(&:to_i) }
+                 .map { |n| [n[0], { cpu: n[1], user: n[2] }] }.to_h
+        lines = tasks.split("\n")[3..-1].map { |l| l.split(/\s{2,}/) }
+        cmds = `wmic process get processid,commandline /format:csv`.split("\n")[1..-1].reject { |r| r.strip == '' }
+                                                                   .map { |l| l.split(',')[1..-1] }
+                                                                   .map { |l| [l.last.to_i, l[0..-2].join(',')] }.to_h
         lines.map do |l|
           pid = l[1].extract_numbers.first
           {
-            name: l[0],
-            pid:  pid,
-            user: l[4],
-            mem:  (((l[3].gsub(',', '').extract_numbers.first / mem_total) * 100) rescue nil),
-            cpu:  (cpu[pid][:cpu] rescue nil),
-            cmd:  cmds[pid]
+            name:   l[0],
+            pid:    pid,
+            user:   l[4],
+            cpu:    (cpu[pid][:cpu] rescue nil),
+            memory: (((l[3].delete(',').extract_numbers.first / mem_total) * 100) rescue nil),
+            cmd:    cmds[pid]
           }
         end
       else
         t = `ps -e -o comm,pid,ruser,%cpu,%mem,cmd`
-        lines = t.split("\n")[1..-1].map{ |l| l.split(/\s+/) }
-        lines.map{ |l| l.size == 6 ? l : [l[0], l[1], l[2], l[3], l[4], l[5..-1].join(' ')] }
+        lines = t.split("\n")[1..-1].map { |l| l.split(/\s+/) }
+        lines.map { |l| l.size == 6 ? l : [l[0], l[1], l[2], l[3], l[4], l[5..-1].join(' ')] }
         lines.map do |l|
           {
-            name: l[0],
-            pid:  l[1].to_i,
-            user: l[2],
-            cpu:  l[3].to_f,
-            mem:  l[4].to_f,
-            cmd:  l[5]
+            name:   l[0],
+            pid:    l[1].to_i,
+            user:   l[2],
+            cpu:    l[3].to_f,
+            memory: l[4].to_f,
+            cmd:    l[5]
           }
         end
       end
     end
 
+    def self.process_list
+      if windows?
+        tasks = `tasklist /v`
+        lines = tasks.split("\n")[3..-1].map { |l| l.split(/\s{2,}/) }
+      else
+        t = `ps -e -o comm,pid,ruser,%cpu,%mem,cmd`
+        lines = t.split("\n")[1..-1].map { |l| l.split(/\s+/) }
+        lines.map { |l| l.size == 6 ? l : [l[0], l[1], l[2], l[3], l[4], l[5..-1].join(' ')] }
+      end
+      lines.map { |l| l[0] }.sort
+    end
+
     def self.filesystems
       if windows?
         types = {
@@ -184,14 +199,16 @@ module BBLib
               v[:size]   = v[:size].to_i
               v[:used]   = v[:size] - v[:free]
               v[:free_p] = (v[:free] / v[:size].to_f) * 100
+              v[:free_p] = nil if v[:free_p].nan?
               v[:used_p] = (v[:used] / v[:size].to_f) * 100
+              v[:used_p] = nil if v[:used_p].nan?
             end
             v
           end
       else
         `df -aTB 1`
           .split("\n")[1..-1]
-          .map{ |l| l.split(/\s{2,}|(?<=\d)\s|(?<=%)\s|(?<=\-)\s|(?<=\w)\s+(?=\w+\s+\d)/)}
+          .map { |l| l.split(/\s{2,}|(?<=\d)\s|(?<=%)\s|(?<=\-)\s|(?<=\w)\s+(?=\w+\s+\d)/) }
           .map do |i|
             {
               filesystem: i[0],
@@ -200,18 +217,17 @@ module BBLib
               used:       i[3].to_i,
               available:  i[4].to_i,
               used_p:     i[5].extract_integers.first.to_f,
-              mount:      i[6],
+              mount:      i[6]
             }
           end
       end
     end
 
-
     # A mostly platform agnostic call to get root volumes
     def self.root_volumes
       if BBLib.windows?
         begin # For windows
-          `wmic logicaldisk get name`.split("\n").map{ |m| m.strip }[1..-1].reject{ |r| r == '' }
+          `wmic logicaldisk get name`.split("\n").map(&:strip)[1..-1].reject { |r| r == '' }
         rescue
           begin # Windows attempt 2
             `fsutil fsinfo drives`.scan(/(?<=\s)\w\:/)
@@ -221,7 +237,7 @@ module BBLib
         end
       else
         begin
-          `ls /`.split("\n").map{ |m| m.strip }.reject{ |r| r == '' }
+          `ls /`.split("\n").map(&:strip).reject { |r| r == '' }
         rescue # All attempts failed
           nil
         end
@@ -231,8 +247,9 @@ module BBLib
     # Windows only method to get the volume labels of disk drives
     def self.root_volume_labels
       return nil unless BBLib.windows?
-      `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
+      `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
-
   end
 end

data/lib/string/bbstring.rb

@@ -1,41 +1,42 @@
 
+# frozen_string_literal: true
 require_relative 'matching'
 require_relative 'roman'
 require_relative 'fuzzy_matcher'
 require_relative 'cases'
+require_relative 'regexp'
+require_relative 'pluralization'
 
 module BBLib
-
-  ##############################################
-  # General Functions
-  ##############################################
-
   # Quickly remove any symbols from a string leaving only alpha-numeric characters and white space.
-  def self.drop_symbols str
+  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
-    BBLib.extract_numbers(str, convert:false).reject{ |r| r.include?('.') }.map{ |m| convert ? m.to_i : m }
+  def self.extract_integers(str, convert: true)
+    BBLib.extract_numbers(str, convert: false).reject { |r| r.include?('.') }
+         .map { |m| convert ? m.to_i : m }
   end
 
   # Extracts all integers or decimals from a string into an array.
-  def self.extract_floats str, convert: true
-    BBLib.extract_numbers(str, convert:false).reject{ |r| !r.include?('.') }.map{ |m| convert ? m.to_f : m }
+  def self.extract_floats(str, convert: true)
+    BBLib.extract_numbers(str, convert: false).reject { |r| !r.include?('.') }
+         .map { |m| convert ? m.to_f : m }
   end
 
   # Extracts any correctly formed integers or floats from a string
-  def self.extract_numbers str, convert: true
-    str.scan(/\d+\.\d+[^\.]|\d+[^\.]/).map{ |f| convert ? (f.include?('.') ? f.to_f : f.to_i) : f }
+  def self.extract_numbers(str, convert: true)
+    str.scan(/\d+\.\d+(?<=[^\.])|\d+(?<=[^\.])|\d+\.\d+$|\d+$/)
+       .map { |f| convert ? (f.include?('.') ? f.to_f : f.to_i) : f }
   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
+  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)
+    %w(the a an).each do |a|
+      starts = str.downcase.start_with?(a + ' ')
+      ends = str.downcase.end_with?(' ' + a)
       if starts && position != :front
         if position == :none
           str = str[(a.length + 1)..str.length]
@@ -43,41 +44,104 @@ module BBLib
           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
+      next unless 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
-    while str.strip.end_with?(',')
-      str = str.strip
-      str = str.chop
-    end
+    str = str.strip.chop while str.strip.end_with?(',')
     str
   end
 
+  # Displays a portion of an object (as a string) with an ellipse displayed
+  # if the string is over a certain size.
+  # Supported styles:
+  # => front - "for exam..."
+  # => back - "... example"
+  # => middle - "... exam..."
+  # => outter - "for e...ple"
+  # The length of the too_long string is NOT factored into the cap
+  def self.chars_up_to(str, cap, too_long = '...', style: :front)
+    return str if str.to_s.size <= cap
+    str = str.to_s
+    case style
+    when :back
+      "#{too_long}#{str[(str.size - cap)..-1]}"
+    when :outter
+      "#{str[0...(cap / 2).to_i + (cap.odd? ? 1 : 0)]}#{too_long}#{str[-(cap / 2).to_i..-1]}"
+    when :middle
+      "#{too_long}#{str[(str.size / 2 - cap / 2 - (cap.odd? ? 1 : 0)).to_i...(str.size / 2 + cap / 2).to_i]}#{too_long}"
+    else
+      "#{str[0...cap]}#{too_long}"
+    end
+  end
+
+  # Takes two strings and tries to apply the same capitalization from
+  # the first string to the second.
+  # Supports lower case, upper case and capital case
+  def self.copy_capitalization(str_a, str_b)
+    str_a = str_a.to_s
+    str_b = str_b.to_s
+    if str_a.upper?
+      str_b.upcase
+    elsif str_a.lower?
+      str_b.downcase
+    elsif str_a.capital?
+      str_b.capitalize
+    else
+      str_b
+    end
+  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].flatten.each do |d|
-      ar.map!{ |a| a.split d }
-      ar.flatten!
+  def msplit(*delims)
+    ary = [self]
+    return ary if delims.empty?
+    delims.flatten.each do |d|
+      ary = ary.flat_map { |a| a.split d }
     end
-    keep_empty ? ar : ar.reject{ |l| l.empty? }
+    ary
   end
 
-  def move_articles position = :front, capitalize = true
-    BBLib.move_articles self, position, capitalize:capitalize
+  # Split on delimiters
+  def quote_split(*delimiters)
+    encap_split('"\'', *delimiters)
   end
 
-  def move_articles! position = :front, capitalize = true
-    replace BBLib.move_articles(self, position, capitalize:capitalize)
+  alias qsplit quote_split
+
+  # 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| /#{d}(?=(?:[^#{pattern}]|[#{pattern}][^#{pattern}]*[#{pattern}])*$)/}
+    msplit(*patterns)
+  end
+
+  alias esplit encap_split
+
+  def move_articles(position = :front, capitalize = true)
+    BBLib.move_articles self, position, capitalize: capitalize
+  end
+
+  def move_articles!(position = :front, capitalize = true)
+    replace BBLib.move_articles(self, position, capitalize: capitalize)
   end
 
   def drop_symbols
@@ -88,20 +152,20 @@ class String
     replace BBLib.drop_symbols(self)
   end
 
-  def extract_integers convert: true
-    BBLib.extract_integers self, convert:convert
+  def extract_integers(convert: true)
+    BBLib.extract_integers self, convert: convert
   end
 
-  def extract_floats convert: true
-    BBLib.extract_floats self, convert:convert
+  def extract_floats(convert: true)
+    BBLib.extract_floats self, convert: convert
   end
 
-  def extract_numbers convert: true
-    BBLib.extract_numbers self, convert:convert
+  def extract_numbers(convert: true)
+    BBLib.extract_numbers self, convert: convert
   end
 
   def to_clean_sym
-    self.snake_case.to_sym
+    snake_case.to_sym
   end
 
   # Simple method to convert a string into an array containing only itself
@@ -109,44 +173,79 @@ class String
     [self]
   end
 
-  def encap_by? str
+  def encap_by?(str)
     case str
     when '('
-      self.start_with?(str) && self.end_with?(')')
+      start_with?(str) && end_with?(')')
     when '['
-      self.start_with?(str) && self.end_with?(']')
+      start_with?(str) && end_with?(']')
     when '{'
-      self.start_with?(str) && self.end_with?('}')
+      start_with?(str) && end_with?('}')
     when '<'
-      self.start_with?(str) && self.end_with?('>')
+      start_with?(str) && end_with?('>')
     else
-      self.start_with?(str) && self.end_with?(str)
+      start_with?(str) && end_with?(str)
     end
   end
 
-  def uncapsulate char = '"'
-    case char
-    when '('
-      back = ')'
-    when '['
-      back = ']'
-    when '{'
-      back = '}'
-    when '<'
-      back = '>'
-    else
-      back = char
+  def encapsulate(char = '"')
+    back = case char
+           when '('
+             ')'
+           when '['
+             ']'
+           when '{'
+             '}'
+           when '<'
+             '>'
+           else
+             char
+           end
+     "#{char}#{self}#{back}"
+  end
+
+  def uncapsulate(char = '"', limit: nil)
+    back = case char
+           when '('
+             ')'
+           when '['
+             ']'
+           when '{'
+             '}'
+           when '<'
+             '>'
+           else
+             char
+           end
+    temp = dup
+    count = 0
+    while temp.start_with?(char) && temp != char && (limit.nil? || count < limit)
+      temp = temp[(char.size)..-1]
+      count += 1
+    end
+    count = 0
+    while temp.end_with?(back) && temp != char && (limit.nil? || count < limit)
+      temp = temp[0..-(char.size + 1)]
+      count += 1
     end
-    temp = self.dup
-    temp = temp[(char.size)..-1] while temp.start_with?(char) && temp != char
-    temp = temp[0..-(char.size + 1)] while temp.end_with?(back) && temp != char
     temp
   end
 
+  def upper?
+    chars.all? { |letter| /[[:upper:]]|\W/.match(letter) }
+  end
+
+  def lower?
+    chars.all? { |letter| /[[:lower:]]|\W/.match(letter) }
+  end
+
+  def capital?
+    chars.first.upper?
+  end
 end
 
 class Symbol
   def to_clean_sym
-    self.to_s.to_clean_sym
+    to_s.to_clean_sym
   end
 end