bblib 1.0.2 → 2.0.0

data/lib/bblib/cli/options/untoggle.rb

@@ -0,0 +1,18 @@
+module BBLib
+  class OptsParser
+    class Untoggle < Toggle
+
+      def extract(index, args)
+        super
+        false
+      end
+
+      protected
+
+      def simple_setup
+        self.default = true
+      end
+
+    end
+  end
+end

data/lib/bblib/cli/opts_parser.rb

@@ -0,0 +1,65 @@
+require_relative 'option'
+require_relative 'exceptions/opts_parser'
+require_relative 'options/basic_option'
+
+BBLib.scan_files(File.expand_path('../options', __FILE__), '*.rb') do |file|
+  require_relative file
+end
+
+module BBLib
+  class OptsParser
+    include BBLib::Effortless
+
+    attr_ary_of Option, :options, add_rem: true
+    attr_str :usage, default: nil, allow_nil: true
+
+    def usage(text = nil)
+      @usage = text unless text.nil?
+      @usage
+    end
+
+    def on(*flags, **opts, &block)
+      opts[:type] = :string unless opts[:type]
+      add_options(opts.merge(flags: flags, processor: block))
+    end
+
+    def parse(args = ARGV)
+      parse!(args.dup)
+    end
+
+    def parse!(args = ARGV)
+      HashStruct.new.tap do |hash|
+        options.each do |option|
+          option.retrieve(args, hash)
+        end
+      end.merge(arguments: args)
+    end
+
+    def help
+      usage.to_s + "\n\t" +
+      options.join("\n\t")
+    end
+
+    def to_s
+      help
+    end
+
+    protected
+
+    def method_missing(method, *args, &block)
+      if Option.types.include?(method)
+        define_singleton_method(method) do |*flags, **opts, &block|
+          on(*flags, **opts.merge(type: method), &block)
+        end
+        send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      Option.types.include?(method) || super
+    end
+
+  end
+end

data/lib/bblib/core.rb

@@ -0,0 +1,37 @@
+require_relative 'version'
+
+require_relative 'core/exceptions/exception'
+
+require_relative 'core/util/opal'
+require_relative 'core/util/object'
+require_relative 'core/util/hash'
+
+require_relative 'core/mixins/simple_init'
+require_relative 'core/mixins/attrs'
+require_relative 'core/mixins/family_tree'
+require_relative 'core/mixins/hooks'
+require_relative 'core/mixins/serializer'
+require_relative 'core/mixins/logger'
+require_relative 'core/mixins/bridge'
+require_relative 'core/mixins/effortless'
+require_relative 'core/mixins/prototype'
+require_relative 'core/mixins/type_init'
+require_relative 'core/mixins/delegator'
+
+require_relative 'core/hash_path/hash_path'
+
+require_relative 'core/util/string'
+require_relative 'core/util/file'
+require_relative 'core/util/time'
+require_relative 'core/util/number'
+require_relative 'core/util/array'
+require_relative 'core/util/logging'
+require_relative 'core/util/os'
+
+require_relative 'core/classes/hash_struct'
+require_relative 'core/classes/task_timer'
+require_relative 'core/classes/tree_hash'
+require_relative 'core/classes/splitter'
+
+require 'fileutils'
+require 'time'

data/lib/{hash → bblib/core/classes}/hash_struct.rb

@@ -7,10 +7,17 @@ module BBLib
 
     def method_missing(method, *args, &block)
       if args.empty? && ![:to_ary].include?(method)
-        define_singleton_method(method) do
+        if method.to_s.end_with?('?')
+          define_singleton_method(method) do
+            self[method[0..-2].to_sym] ? true : false
+          end
+          send(method)
+        else
+          define_singleton_method(method) do
+            self[method]
+          end
           self[method]
         end
-        self[method]
       elsif method.to_s.end_with?('=')
         define_singleton_method(method) do |arg|
           self[method[0..-2].to_sym] = arg

data/lib/bblib/core/classes/splitter.rb

@@ -0,0 +1,101 @@
+module BBLib
+  class Splitter
+    include BBLib::Effortless
+
+    attr_hash :expressions, required: true, pre_proc: :process_expressions
+    attr_ary_of [String, Regexp], :delimiters, required: true
+
+    attr_bool :inside, default: false
+    attr_int :current_start, :current_depth, default: 0
+    attr_of [String, Symbol, Regexp], :current_expression, allow_nil: true
+    attr_str :current_match, :current_delimiter_match, :current_expression_match, allow_nil: true, default: nil
+    attr_str :part, default: ''
+    attr_bool :ignore_escaped_chars, default: true
+    attr_bool :escaped, default: false
+    attr_str :escape_char, default: '\\'
+
+    def self.split(string, *delimiters, **opts)
+      new(opts.except(:count).merge(delimiters: delimiters)).split(string, opts.delete(:count))
+    end
+
+    def split(string, count = nil)
+      return string if count == 1
+      index = 0
+      splits = 1
+      [].tap do |array|
+        until index >= string.size
+          sub_string = string[index..-1]
+          escaped    = string[index - 1] == escape_char if ignore_escaped_chars?
+
+          if inside?
+            open_match = match(sub_string, current_expression)
+            close_match = match(sub_string, expressions[current_expression])
+            if current_start != index && close_match && !escaped
+              self.inside = false if (self.current_depth -= 1).zero?
+            elsif open_match && !escaped
+              self.current_depth += 1
+              self.part += open_match
+              index += open_match.size
+              next
+            end
+          elsif expression = check_expressions(sub_string)
+            self.inside = true
+            self.current_start = index
+            self.current_expression = expression
+            self.current_depth += 1
+            self.part += current_expression_match
+            index += current_expression_match.size
+            next
+          elsif !escaped? && (count.nil? || splits < count) && delimiter_check(sub_string)
+            array << self.part
+            splits += 1
+            self.part = ''
+            index += current_delimiter_match.size
+            next
+          end
+          self.part += string[index].to_s
+          index += 1
+        end
+        array << self.part
+      end
+    end
+
+    protected
+
+    def match(sub_string, expression)
+      case expression
+      when Regexp
+        (sub_string =~ expression)&.zero? ? sub_string.scan(expression).first : nil
+      when String, Symbol
+        sub_string.start_with?(expression.to_s) ? expression.to_s : nil
+      else
+        nil
+      end
+    end
+
+    def check_expressions(sub_string)
+      expressions.find do |open_expression, _close_expression|
+        self.current_expression_match = match(sub_string, open_expression)
+      end&.first
+    end
+
+    def delimiter_check(sub_string)
+      delimiters.find do |delimiter|
+        self.current_delimiter_match = match(sub_string, delimiter)
+      end
+    end
+
+    def process_expressions(expressions)
+      case expressions
+      when Array
+        expressions.hmap { |exp| [exp, exp] }
+      when String, Symbol, Regexp
+        { expressions => expressions }
+      when Hash
+        expressions
+      else
+        raise ArgumentError, "Unknown expression format: #{expressions.class}"
+      end
+    end
+  end
+end

data/lib/{hash → bblib/core/classes}/tree_hash.rb

@@ -22,10 +22,10 @@ class TreeHash
   end
 
   def child(key, symbol_sensitive = false)
-    case [node_class]
-    when [Hash]
+    case
+    when Hash >= node_class
       children[key] || (symbol_sensitive ? nil : children[key.to_s.to_sym])
-    when [Array]
+    when Array >= node_class
       children[key.to_i]
     else
       nil
@@ -33,14 +33,14 @@ class TreeHash
   end
 
   def child_exists?(key, symbol_sensitive = false)
-    !case [node_class]
-    when [Hash]
-      children[key] || (!symbol_sensitive && children[key.to_s.to_sym])
-    when [Array]
+    case
+    when Hash >= node_class
+      children.include?(key) || (!symbol_sensitive && children.include?(key.to_s.to_sym))
+    when Array >= node_class
       [0...children.size] === key.to_i
     else
       false
-    end.nil?
+    end
   end
 
   def children?
@@ -197,8 +197,8 @@ class TreeHash
     self
   end
 
-  def process(processor)
-
+  def process(processor, &block)
+    # TODO Add ability to process values or keys in tree hashes
   end
 
   def size
@@ -206,8 +206,8 @@ class TreeHash
   end
 
   def paths
-    case [node_class]
-    when [Array], [Hash]
+    case
+    when Array >= node_class, Hash >= node_class
       value.squish.keys
     else
       []
@@ -258,10 +258,10 @@ class TreeHash
   end
 
   def value
-    case [node_class]
-    when [Hash]
-      children.map { |k, v| [k, v.value] }.to_h
-    when [Array]
+    case
+    when Hash >= node_class
+      children.hmap { |k, v| [k, v.value] }
+    when Array >= node_class
       children.values.map(&:value)
     else
       children
@@ -270,10 +270,10 @@ class TreeHash
 
   def key
     return nil if root?
-    case [parent.node_class]
-    when [Hash]
+    case
+    when Hash >= parent.node_class
       parent.keys[index]
-    when [Array]
+    when Array >= parent.node_class
       index
     else
       nil
@@ -327,11 +327,11 @@ class TreeHash
   end
 
   def delete_child(key, symbol_sensitive = false)
-    case [node_class]
-    when [Hash]
+    case
+    when Hash >= node_class
       child = symbol_sensitive ? nil : children.delete(key.to_s.to_sym)
       child = children.delete(key) unless child
-    when [Array]
+    when Array >= node_class
       children.delete(key.to_i)
     else
       nil

data/lib/bblib/core/exceptions/abstract.rb

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

data/lib/bblib/core/exceptions/exception.rb

@@ -0,0 +1,5 @@
+module BBLib
+  class Exception < StandardError; end
+end
+
+require_relative 'abstract'

data/lib/{hash_path → bblib/core/hash_path}/hash_path.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 require_relative 'part'
-require_relative 'proc'
-require_relative 'path_hash'
 
 # This classes parses dot delimited hash path strings and wraps the corresponding parts. Then hashes or arrays can be
 # passed to the find method to find all matching elements for the path.

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

@@ -100,6 +100,14 @@ module BBLib
         end
       end
 
+      if opts[:aliases]
+        [opts[:aliases]].flatten.each do |als|
+          obj = opts[:singleton] ? self.singleton_class : self
+          obj.send(:alias_method, als, method)
+          obj.send(:alias_method, "#{als}=", "#{method}=")
+        end
+      end
+
       unless opts[:singleton]
         protected method if opts[:protected] || opts[:protected_reader]
         protected "#{method}=".to_sym if opts[:protected] || opts[:protected_writer]
@@ -126,7 +134,7 @@ module BBLib
           elsif arg && (!opts.include?(:pack) || opts[:pack]) && arg = _attr_pack(arg, klasses, opts)
             arg
           else
-            raise TypeError, "#{method} must be set to a class of #{allowed.join_terms(:or)}, not #{arg.class}" unless opts[:suppress]
+            raise TypeError, "#{method} must be set to a class of #{allowed.join_terms(:or)}, not #{arg.class} (#{self})" unless opts[:suppress]
           end
         end
       end
@@ -208,9 +216,11 @@ module BBLib
     def attr_element_of(list, *methods, **opts)
       methods.each do |method|
         attr_custom(method, opts.merge(list: list)) do |arg|
-          ls = list.is_a?(Proc) ? list.call : list
+          ls = list.is_a?(Proc) ? list.call(self) : list
           if ls.include?(arg) || (opts[:allow_nil] && arg.nil?)
             arg
+          elsif opts[:fallback]
+            opts[:fallback]
           else
             raise ArgumentError, "Invalid option '#{arg}' for #{method}." unless opts.include?(:raise) && !opts[:raise]
           end
@@ -222,7 +232,7 @@ module BBLib
       opts[:default] = [] unless opts.include?(:default) || opts.include?(:default_proc)
       methods.each do |method|
         attr_custom(method, opts.merge(list: list)) do |args|
-          ls = list.is_a?(Proc) ? list.call : list
+          ls = list.is_a?(Proc) ? list.call(self) : list
           [].tap do |final|
             [args].flatten(1).each do |arg|
               if ls.include?(arg) || (opts[:allow_nil] && arg.nil?)
@@ -272,7 +282,7 @@ module BBLib
               elsif arg && (!opts.include?(:pack) || opts[:pack]) && arg = _attr_pack(arg, klasses, opts)
                 array.push(arg)
               else
-                raise TypeError, "Invalid class passed to #{method} on #{self}: #{arg.class}. Must be a #{klasses.join_terms(:or)}." unless opts[:raise] == false
+                raise TypeError, "Invalid class passed to #{method} on #{self}: #{arg.class}. Must be a #{klasses.join_terms(:or)}." unless opts[:suppress]
               end
             end
           end
@@ -397,7 +407,7 @@ module BBLib
               elsif (opts.include?(:pack_key) && opts[:pack_key]) && new_key = _attr_pack(key, klasses, opts)
                 arg[new_key] = arg.delete(key)
               else
-                raise ArgumentError, "Invalid key type for #{method}: #{key.class}. Must be #{opts[:keys].join_terms(:or)}."
+                raise ArgumentError, "Invalid key type for #{method}: #{key.class}. Must be #{[opts[:keys]].flatten.join_terms(:or)}."
               end
             end
           end
@@ -418,10 +428,10 @@ module BBLib
       end
     end
 
-    def _attr_pack(arg, klasses, opts = {})
+    def _attr_pack(arg, klasses, opts = {}, &block)
       klasses = [klasses].flatten
       unless BBLib.is_any?(arg, *klasses)
-        return klasses.first.new(*[arg].flatten(1)) if klasses.first.respond_to?(:new)
+        return klasses.first.new(*[arg].flatten(1), &block) if klasses.first.respond_to?(:new)
       end
       nil
     end

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

@@ -7,3 +7,4 @@ require_relative 'logger'
 require_relative 'bridge'
 require_relative 'prototype'
 require_relative 'type_init'
+require_relative 'delegator'