bblib 1.0.2 → 2.0.0

data/lib/bblib/cron.rb

@@ -0,0 +1,2 @@
+require_relative 'core'
+require_relative 'classes/cron'

data/lib/bblib/fuzzy_matcher.rb

@@ -0,0 +1,2 @@
+require_relative 'core'
+require_relative 'classes/fuzzy_matcher'

data/lib/bblib/html.rb

@@ -0,0 +1,4 @@
+require_relative 'core'
+require_relative 'html/builder'
+require_relative 'html/tag'
+require_relative 'html/tag_set'

data/lib/bblib/system.rb

@@ -0,0 +1,3 @@
+require_relative 'core'
+require_relative 'system/command'
+require_relative 'system/system'

data/lib/bblib/system/command.rb

@@ -0,0 +1,7 @@
+module BBLib
+  module Command
+    def self.quote(arg)
+      arg =~ /\s+/ ? "\"#{arg}\"" : arg.to_s
+    end
+  end
+end

data/lib/bblib/system/system.rb

@@ -0,0 +1,39 @@
+module BBLib
+  module System
+    SPECIAL_PROGRAMS = ['pry', 'irb.cmd', 'irb'].freeze
+
+    # A string representation of the command line that evoked this ruby instance (platform agnostic)
+    def self.cmd_line(*args, include_args: true, include_ruby: true, prefix: nil, suffix: nil)
+      args = ARGV if args.empty?
+      include_ruby = false if special_program?
+      "#{prefix}#{include_ruby ? Command.quote(Gem.ruby) : nil} #{Command.quote($PROGRAM_NAME)}" \
+      " #{include_args ? args.map { |a| Command.quote(a) }.join(' ') : nil}#{suffix}"
+        .strip
+    end
+
+    # EXPERIMENTAL: Reloads the original file that was called
+    # Use at your own risk, this could cause some weird issues
+    def self.reload(include_args: true)
+      return false if special_program?
+      load cmd_line(*args, include_ruby: false, include_args: include_args)
+    end
+
+    # EXPERIMENTAL: Restart the ruby process that is currently running.
+    # Use at your own risk
+    def self.restart(*args, include_args: true, stay_alive: 1)
+      exit(0)
+    rescue SystemExit
+      opts = BBLib::OS.windows? ? { new_pgroup: true } : { pgroup: true }
+      pid = spawn(cmd_line(*args, include_args: include_args, prefix: (BBLib::OS.windows? ? 'start ' : nil)), **opts)
+      Process.detach(pid)
+      sleep(stay_alive)
+      exit(0) if special_program?
+    end
+
+    # Detects whether a console like irb or pry was used to launch this process
+    def self.special_program?
+      SPECIAL_PROGRAMS.include?($PROGRAM_NAME)
+    end
+  end
+
+end

data/lib/bblib/version.rb

@@ -1,3 +1,3 @@
 module BBLib
-  VERSION = '1.0.2'.freeze
+  VERSION = '2.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bblib
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Brandon Black
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-03-28 00:00:00.000000000 Z
+date: 2018-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -84,50 +84,77 @@ files:
 - bblib.gemspec
 - bin/console
 - bin/setup
-- lib/array/bbarray.rb
 - lib/bblib.rb
+- lib/bblib/all.rb
+- lib/bblib/classes/cron.rb
+- lib/bblib/classes/fuzzy_matcher.rb
+- lib/bblib/cli.rb
+- lib/bblib/cli/color.rb
+- lib/bblib/cli/exceptions/invalid_argument.rb
+- lib/bblib/cli/exceptions/missing_argument.rb
+- lib/bblib/cli/exceptions/missing_required_argument.rb
+- lib/bblib/cli/exceptions/opts_parser.rb
+- lib/bblib/cli/option.rb
+- lib/bblib/cli/options/basic_option.rb
+- lib/bblib/cli/options/bool.rb
+- lib/bblib/cli/options/command.rb
+- lib/bblib/cli/options/date.rb
+- lib/bblib/cli/options/float.rb
+- lib/bblib/cli/options/integer.rb
+- lib/bblib/cli/options/json.rb
+- lib/bblib/cli/options/regexp.rb
+- lib/bblib/cli/options/string.rb
+- lib/bblib/cli/options/symbol.rb
+- lib/bblib/cli/options/time.rb
+- lib/bblib/cli/options/toggle.rb
+- lib/bblib/cli/options/untoggle.rb
+- lib/bblib/cli/opts_parser.rb
+- lib/bblib/core.rb
+- lib/bblib/core/classes/hash_struct.rb
+- lib/bblib/core/classes/splitter.rb
+- lib/bblib/core/classes/task_timer.rb
+- lib/bblib/core/classes/tree_hash.rb
+- lib/bblib/core/exceptions/abstract.rb
+- lib/bblib/core/exceptions/exception.rb
+- lib/bblib/core/hash_path/hash_path.rb
+- lib/bblib/core/hash_path/part.rb
+- lib/bblib/core/mixins/attrs.rb
+- lib/bblib/core/mixins/bbmixins.rb
+- lib/bblib/core/mixins/bridge.rb
+- lib/bblib/core/mixins/delegator.rb
+- lib/bblib/core/mixins/effortless.rb
+- lib/bblib/core/mixins/family_tree.rb
+- lib/bblib/core/mixins/hooks.rb
+- lib/bblib/core/mixins/logger.rb
+- lib/bblib/core/mixins/prototype.rb
+- lib/bblib/core/mixins/serializer.rb
+- lib/bblib/core/mixins/simple_init.rb
+- lib/bblib/core/mixins/type_init.rb
+- lib/bblib/core/util/array.rb
+- lib/bblib/core/util/cases.rb
+- lib/bblib/core/util/file.rb
+- lib/bblib/core/util/hash.rb
+- lib/bblib/core/util/logging.rb
+- lib/bblib/core/util/matching.rb
+- lib/bblib/core/util/number.rb
+- lib/bblib/core/util/object.rb
+- lib/bblib/core/util/opal.rb
+- lib/bblib/core/util/os.rb
+- lib/bblib/core/util/pluralization.rb
+- lib/bblib/core/util/regexp.rb
+- lib/bblib/core/util/roman.rb
+- lib/bblib/core/util/string.rb
+- lib/bblib/core/util/time.rb
+- lib/bblib/cron.rb
+- lib/bblib/fuzzy_matcher.rb
+- lib/bblib/html.rb
+- lib/bblib/html/builder.rb
+- lib/bblib/html/tag.rb
+- lib/bblib/html/tag_set.rb
+- lib/bblib/system.rb
+- lib/bblib/system/command.rb
+- lib/bblib/system/system.rb
 - lib/bblib/version.rb
-- lib/class/effortless.rb
-- lib/error/abstract.rb
-- lib/file/bbfile.rb
-- lib/hash/bbhash.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/html/tag_set.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/prototype.rb
-- lib/mixins/serializer.rb
-- lib/mixins/simple_init.rb
-- lib/mixins/type_init.rb
-- lib/number/bbnumber.rb
-- lib/object/bbobject.rb
-- lib/opal/bbopal.rb
-- lib/os/bbos.rb
-- lib/string/bbstring.rb
-- 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
 homepage: https://github.com/bblack16/bblib-ruby
 licenses:
 - MIT

data/lib/error/abstract.rb

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

data/lib/hash_path/path_hash.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-# This module provides similar functionality as hash path, but instead
-# generates a PathHash object which wraps a Hash or Array. Elements may
-# be accessed via method calls rather than path strings.
-
-module BBLib
-  def self.path_hash(hash)
-    PathHash.new(hash)
-  end
-
-  # Wraps a hash in a PathHash object which allows ActiveRecord-like access to hash parameters.
-  # For example, methods are treated as keys passed in to Hash's [] method and ._ can be used to
-  # indicate that the next element should be searched for recursively.
-  class PathHash < BasicObject
-    attr_reader :hash, :recursive
-
-    def initialize(hash)
-      @hash = hash
-    end
-
-    def [](val)
-      PathHash.new(@hash.map { |h| h[val] })
-    end
-
-    def _val
-      @hash
-    end
-
-    alias _v _val
-
-    def _fval
-      @hash.first
-    rescue
-      @hash
-    end
-
-    alias _f _fval
-
-    def _
-      @recursive = true
-      self
-    end
-
-    def _path(arg, formula = nil)
-      method_missing arg, formula
-    end
-
-    # Does not fall back on super as ALL input is accepted
-    def method_missing(arg, formula = nil)
-      arg = (@recursive ? "..#{arg}" : arg.to_s) +
-            (formula ? "(#{formula})" : '')
-      if @hash.is_a?(::Array)
-        PathHash.new @hash.flat_map { |h| if h.is_a?(::Array) || h.is_a?(::Hash) then h.hash_path(arg) end }
-      else
-        PathHash.new @hash.hpath(arg)
-      end
-    end
-
-    def respond_to_missing?(*args)
-      true || super
-    end
-  end
-end
-
-# Monkey Patches
-class Hash
-  def path_hash
-    BBLib.path_hash(self)
-  end
-
-  alias phash path_hash
-  alias _ph path_hash
-end
-
-# Monkey Patches
-class Array
-  def path_hash
-    BBLib.path_hash(self)
-  end
-
-  alias phash path_hash
-  alias _ph path_hash
-end

data/lib/hash_path/proc.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-require_relative 'processors'
-
-module BBLib
-  # This class wraps around a hash path or set of paths and maps a set of actions for modifying elements at the matching
-  # path.
-  class HashPathProc
-    include BBLib::Effortless
-
-    attr_ary_of String, :paths, default: [''], serialize: true, uniq: true
-    attr_of [String, Symbol], :action, default: nil, allow_nil: true, serialize: true, pre_proc: proc { |arg| HashPathProc.map_action(arg.to_s.to_sym) }
-    attr_ary :args, default: [], serialize: true
-    attr_hash :options, default: {}, serialize: true
-    attr_of [String, Proc], :condition, default: nil, allow_nil: true, serialize: true
-    attr_bool :recursive, default: false, serialize: true
-    attr_bool :class_based, default: true, serialize: true
-
-    def process(hash)
-      return hash unless @action && hash
-      tree = hash.to_tree_hash
-      paths.each do |path|
-        children = recursive ? tree.find(path).flat_map(&:descendants) : tree.find(path)
-        children.each do |child|
-          next unless check_condition(child.value)
-          HashPathProcs.send(find_action(action), child, *full_args, class_based: class_based)
-        end
-      end
-      hash.replace(tree.value) rescue tree.value
-    end
-
-    def check_condition(value)
-      return true unless condition
-      if condition.is_a?(String)
-        eval(condition)
-      else
-        condition.call(value)
-      end
-    rescue => e
-      false
-    end
-
-    protected
-
-    USED_KEYWORDS = [:action, :args, :paths, :recursive, :condition].freeze
-
-    def find_action(action)
-      (HashPathProcs.respond_to?(action) ? action : :custom)
-    end
-
-    def full_args
-      (HASH_PATH_PROC_TYPES.include?(action) ? [] : [action]) +
-      args +
-      (options.empty? || options.nil? ? [] : [options])
-    end
-
-    def self.map_action(action)
-      clean = HASH_PATH_PROC_TYPES.find { |k, v| action == k || v.include?(action) }
-      clean ? clean.first : action
-    end
-
-    def simple_init(*args)
-      options = BBLib.named_args(*args)
-      options.merge(options.delete(:options)) if options[:options]
-      USED_KEYWORDS.each { |k| options.delete(k) }
-      self.options = options
-      if args.first.is_a?(Symbol) && @action.nil?
-        self.action = args.shift
-        self.paths = args.shift if args.first.is_a?(String)
-      elsif action && args.first.is_a?(String)
-        self.paths = args.first
-      end
-      self.args += args.find_all { |arg| !arg.is_a?(Hash) } unless args.empty?
-    end
-  end
-end
-
-# Monkey patches
-class Hash
-  def hash_path_proc(*args)
-    BBLib::HashPathProc.new(*args).process(self)
-  end
-
-  alias hpath_proc hash_path_proc
-end
-
-# Monkey patches
-class Array
-  def hash_path_proc(*args)
-    BBLib::HashPathProc.new(*args).process(self)
-  end
-
-  alias hpath_proc hash_path_proc
-end

data/lib/hash_path/processors.rb

@@ -1,239 +0,0 @@
-
-module BBLib
-  def self.hash_path_proc(hash, *args)
-    HashPathProc.new(*args).process(hash)
-  end
-
-  HASH_PATH_PROC_TYPES = {
-    evaluate:         [:eval, :equation, :equate],
-    debug:            [:puts],
-    append:           [:suffix],
-    prepend:          [:prefix],
-    split:            [:delimit, :delim, :separate, :msplit],
-    replace:          [:swap],
-    replace_with:     [],
-    extract:          [:grab, :scan],
-    extract_first:    [:grab_first, :scan_first],
-    extract_last:     [:grab_last, :scan_last],
-    parse_date:       [:date, :parse_time, :time],
-    parse_date_unix:  [:unix_time, :unix_date],
-    parse_duration:   [:duration],
-    parse_file_size:  [:file_size],
-    to_string:        [:to_s, :stringify],
-    downcase:         [:lower, :lowercase, :to_lower],
-    upcase:           [:upper, :uppercase, :to_upper],
-    roman:            [:convert_roman, :roman_numeral, :parse_roman],
-    remove_symbols:   [:chop_symbols, :drop_symbols],
-    format_articles:  [:articles],
-    reverse:          [:invert],
-    delete:           [:del],
-    remove:           [:rem],
-    custom:           [:send],
-    encapsulate:      [],
-    uncapsulate:      [],
-    extract_integers: [:extract_ints, :extract_i],
-    extract_floats:   [:extract_f],
-    extract_numbers:  [:extract_nums],
-    max_number:       [:max, :maximum, :maximum_number],
-    min_number:       [:min, :minimum, :minimum_number],
-    avg_number:       [:avg, :average, :average_number],
-    sum_number:       [:sum],
-    strip:            [:trim],
-    concat:           [:join, :concat_with],
-    reverse_concat:   [:reverse_join, :reverse_concat_with]
-  }.freeze
-
-  module HashPathProcs
-    def self.class_based_proc(child, class_based, *methods)
-      child.replace_with(
-        if class_based && child.node_class == Hash
-          child.value.map { |k, v| [BBLib.recursive_send(k, *methods), v] }.to_h
-        elsif class_based && child.node_class == Array
-          child.children.values.flat_map { |v| class_based_proc(v, true, *methods) }
-        else
-          BBLib.recursive_send(child.value, *methods)
-        end
-      )
-    end
-
-    def self.evaluate(child, *args, class_based: true)
-      value = child.value
-      if args.first.is_a?(String)
-        child.replace_with(eval(args.first))
-      else
-        child.replace_with(args.first.call(value))
-      end
-    end
-
-    def self.debug(child, *args, class_based: true)
-      puts "DEBUG: #{child.value}" + (args.empty? ? '' : "(#{args.join(', ')})")
-      child
-    end
-
-    def self.append(child, *args, class_based: true)
-      class_based_proc(child, class_based, :to_s, :dup, [:concat, args.first])
-    end
-
-    def self.prepend(child, *args, class_based: true)
-      class_based_proc(child, class_based, :to_s, :dup, [:prepend, args.first])
-    end
-
-    def self.split(child, *args, class_based: true)
-      class_based_proc(child, class_based, [:msplit, args])
-    rescue => e
-      class_based_proc(child, class_based, :to_s, [:msplit, args])
-    end
-
-    def self.replace(child, *args, class_based: true)
-      methods = [:to_s]
-      BBLib.hash_args(*args).each { |k, v| methods << [:gsub, (k ? k : k.to_s), v.to_s] }
-      class_based_proc(child, class_based, *methods)
-    end
-
-    def self.replace_with(child, *args, class_based: true)
-      child.replace_with(args.first)
-    end
-
-    def self.extract(child, *args, class_based: true)
-      class_based_proc(child, class_based, [:scan, args.first], [:[], BBLib.named_args(*args)[:slice] || (0..-1)])
-    end
-
-    def self.extract_first(child, *args, class_based: true)
-      class_based_proc(child, class_based, [:scan, args.first], :first)
-    end
-
-    def self.extract_last(child, *args, class_based: true)
-      class_based_proc(child, class_based, [:scan, args.first], :last)
-    end
-
-    def self.parse_date(child, *args, class_based: true)
-      format = BBLib.named_args(*args)[:format]
-      child.replace_with(
-        if class_based && child.node_class == Hash
-          child.value.map do |k, v|
-            [_parse_date(k, args, format), v]
-          end.to_h
-        elsif class_based && child.node_class == Array
-          child.value.map do |v|
-            _parse_date(v, args, format)
-          end
-        else
-          _parse_date(child.value, args, format)
-        end
-      )
-    end
-
-    def self._parse_date(value, patterns, format)
-      formatted = nil
-      patterns.each do |pattern|
-        next unless formatted.nil?
-        formatted = Time.strptime(value.to_s, pattern.to_s) rescue nil
-        formatted = formatted.strftime(format) if format
-      end
-      formatted
-    end
-
-    def self.parse_date_unix(child, *args, class_based: true)
-      child.replace_with(parse_date(child, *args, class_based: class_based).to_f)
-    end
-
-    def self.parse_duration(child, *args, class_based: true)
-      class_based_proc(child, class_based, :to_s, [:parse_duration, BBLib.named_args(*args)])
-    end
-
-    def self.parse_file_size(child, *args, class_based: true)
-      class_based_proc(child, class_based, :to_s, [:parse_file_size, BBLib.named_args(*args)])
-    end
-
-    def self.to_string(child, *args, class_based: true)
-      class_based_proc(child, class_based, :to_s)
-    end
-
-    def self.downcase(child, *args, class_based: true)
-      class_based_proc(child, class_based, :to_s, :downcase)
-    end
-
-    def self.upcase(child, *args, class_based: true)
-      class_based_proc(child, class_based, :to_s, :upcase)
-    end
-
-    def self.roman(child, *args, class_based: true)
-      class_based_proc(child, class_based, :to_s, (args.first == :to ? :to_roman : :from_roman))
-    end
-
-    def self.remove_symbols(child, *args, class_based: true)
-      class_based_proc(child, class_based, :to_s, :drop_symbols)
-    end
-
-    def self.format_articles(child, *args, class_based: true)
-      class_based_proc(child, class_based, :to_s, [:format_articles, args.first || :front])
-    end
-
-    def self.reverse(child, *args, class_based: true)
-      class_based_proc(child, class_based, :reverse)
-    end
-
-    def self.delete(child, *args, class_based: true)
-      child.kill
-    end
-
-    def self.remove(child, *args, class_based: true)
-      methods = args.map { |a| [:gsub, a, ''] }
-      methods.shift(:to_s)
-      class_based_proc(child, class_based, *methods )
-    end
-
-    def self.custom(child, *args, class_based: true)
-      class_based_proc(child, class_based, *args)
-    end
-
-    def self.encapsulate(child, *args, class_based: true)
-      class_based_proc(child, class_based, :to_s, [:concat, args.first.to_s], [:prepend, args.first.to_s])
-    end
-
-    def self.uncapsulate(child, *args, class_based: true)
-      class_based_proc(child, class_based, [:uncapsulate, args.first])
-    end
-
-    def self.max(child, *args, class_based: true)
-      class_based_proc(child, class_based, :max)
-    end
-
-    def self.min(child, *args, class_based: true)
-      class_based_proc(child, class_based, :min)
-    end
-
-    def self.avg(child, *args, class_based: true)
-      nums = child.value.to_s.extract_numbers
-      child.replace_with(nums.inject { |s, x| s + x }.to_f / nums.size.to_f)
-    end
-
-    def self.sum(child, *args, class_based: true)
-      child.replace_with(value.to_s.extract_numbers.inject { |s, x| s + x })
-    end
-
-    def self.strip(child, *args, class_based: true)
-      class_based_proc(child, class_based, :to_s, :strip)
-    end
-
-    def self.extract_integers(child, *args, class_based: true)
-      class_based_proc(child, class_based, :to_s, :extract_integers)
-    end
-
-    def self.extract_floats(child, *args, class_based: true)
-      class_based_proc(child, class_based, :to_s, :extract_floats)
-    end
-
-    def self.extract_numbers(child, *args, class_based: true)
-      class_based_proc(child, class_based, :to_s, :extract_numbers)
-    end
-
-    def self.concat(child, *args, class_based: true)
-      child.replace_with(([child.value] + child.root.find(args.first)).map { |v| v.to_s }.join)
-    end
-
-    def self.reverse_concat(child, *args, class_based: true)
-      child.replace_with(([child.value] + child.root.find(args.first)).map { |v| v.to_s }.reverse.join)
-    end
-  end
-end