bblib 0.3.0 → 0.4.1

data/lib/hash_path/processors.rb

@@ -0,0 +1,239 @@
+
+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

data/lib/html/bbhtml.rb

@@ -0,0 +1,2 @@
+require_relative 'builder'
+require_relative 'tag'

data/lib/html/builder.rb

@@ -0,0 +1,34 @@
+module BBLib
+  module HTML
+    TAGS = %w{a abbr address area article aside audio b base bdi bdo blockquote body br button canvas caption cite code col colgroup command datalist dd del details dfn div dl dt em embed fieldset figcaption figure footer form h1 h2 h3 h4 h5 h6 head header hgroup hr html i iframe img input ins kbd keygen label legend li link map mark menu meta meter nav noscript object ol optgroup option output p param pre progress q rp rt ruby s samp script section select small source span strong style sub summary sup table tbody td textarea tfoot th thead time title tr track u ul var video wbr}
+
+    SELF_CLOSING_TAGS = %w{area base br col command embed hr img input keygen link meta param source track wbr}
+
+    def self.self_close?(tag)
+      SELF_CLOSING_TAGS.include?(tag.to_s.downcase)
+    end
+
+    module Builder
+
+      BBLib::HTML::TAGS.each do |tag|
+        define_method(tag) do |content = nil, **attributes, &block|
+          context = attributes.delete(:context) || self.context
+          t = Tag.new(type: tag, attributes: attributes, content: content, context: context)
+          children << t
+          t.instance_eval(&block) if block
+        end
+      end
+
+      def build(&block)
+        instance_eval(&block)
+        self
+      end
+
+      def self.build(type, content = nil, **attributes, &block)
+        raise ArgumentError, "Unknown element type '#{type}'." unless TAGS.include?(type.to_s.downcase)
+        context = attributes.delete(:context)
+        Tag.new(type: type, content: content, attributes: attributes, context: context, &block)
+      end
+    end
+  end
+end

data/lib/html/tag.rb

@@ -0,0 +1,49 @@
+module BBLib
+  module HTML
+    class Tag
+      include BBLib::Effortless
+      include Builder
+
+      attr_str :type, required: true, arg_at: 0, arg_at_accept: [String, Symbol]
+      attr_str :content, arg_at: 1, arg_at_accept: [String, Symbol]
+      attr_hash :attributes, default: {}
+      attr_ary_of Tag, :children, default: []
+      attr_of Object, :context, default: nil, allow_nil: true
+
+      def render(pretty: false, tabs: 0)
+        cont = render_content(pretty: pretty, tabs: tabs)
+        tabbing = pretty ? ("\n" + ("\t" * tabs)) : ''
+        "#{tabbing}<#{type}#{render_attributes}" +
+        if cont || !BBLib::HTML.self_close?(type)
+          ">#{cont}#{tabbing}</#{type}>"
+        else
+          "/>"
+        end
+      end
+
+      def to_s
+        render
+      end
+
+      def to_str
+        to_s
+      end
+
+      def render_attributes
+        return nil if attributes.empty?
+        attributes[:style] = attributes[:style].map { |k, v| "#{k}: #{v}" }.join('; ') if attributes[:style] && attributes[:style].is_a?(Hash)
+        ' ' + attributes.map { | k, v| "#{k}=\"#{v.to_s.gsub('"', '&#34;')}\"" }.join(' ')
+      end
+
+      def render_content(pretty: false, tabs: 0)
+        return nil if (content.nil? || content.empty?) && children.empty?
+        tabbing = pretty ? ("\n" + ("\t" * (tabs + 1))) : ''
+        text = if content && !content.empty?
+          "#{tabbing}#{content.gsub("\n", tabbing)}"
+        end
+        html = children.map { |tag| tag.render(pretty: pretty, tabs: tabs + 1) }.join
+        [text, html].compact.join
+      end
+    end
+  end
+end

data/lib/logging/bblogging.rb

@@ -0,0 +1,42 @@
+
+module BBLib
+
+  def self.logger
+    @logger ||= default_logger
+  end
+
+  def self.default_logger
+    log = ::Logger.new(STDOUT)
+    log.level = ::Logger::INFO
+    log.formatter = proc do |severity, datetime, progname, msg|
+      if msg.is_a?(Exception)
+        msg = msg.inspect + "\n\t" + msg.backtrace.join("\n\t")
+      end
+      "[#{datetime}] #{severity} - #{msg}\n"
+    end
+    log.datetime_format = '%Y-%m-%d %H:%M:%S'
+    log
+  end
+
+  def self.logger=(logger)
+    raise ArgumentError, 'Must be set to a valid logger' unless logger.is_a?(Logger)
+    @logger = logger
+  end
+
+  def self.enable_logger(enable = true)
+    @logger_on = enable
+  end
+
+  def self.log_enabled?
+    @logger_on
+  end
+
+  class << self
+    [:fatal, :error, :warn, :info, :debug].each do |sev|
+      define_method(sev) do |*args|
+        logger.send(sev, *args)
+      end
+    end
+  end
+
+end

data/lib/mixins/attrs.rb

@@ -0,0 +1,422 @@
+
+
+module BBLib
+  # Adds type casted attr getters and setters with all kinds of other goodness to ensure
+  # classes accept, set and return data the correct way without requiring piles or boiler plate
+  # code.
+  module Attrs
+
+    def _attrs
+      @_attrs ||= _ancestor_attrs
+    end
+
+    def _ancestor_attrs
+      hash = {}
+      ancestors.reverse.each do |ancestor|
+        next if ancestor == self
+        hash = hash.merge(ancestor._attrs) if ancestor.respond_to?(:_attrs)
+      end
+      # Need to dup to avoid subclasses modifying parents
+      hash.hmap do |k, v|
+        v[:options] = v[:options].dup
+        [k, v.dup]
+      end
+    end
+
+    def attr_set(name, opts = {})
+      return false unless _attrs[name]
+      opts.each do |k, v|
+        _attrs[name][:options][k] = v
+      end
+    end
+
+    # Lists all attr_* getter methods that were created on this class.
+    def instance_readers
+      _attrs.map { |k, v| [:attr_writer].any? { |t| v[:type] == t } ? nil : k }.compact
+    end
+
+    # Lists all attr_* setter methods that were created on this class.
+    def instance_writers
+      _attrs.keys.map { |m| "#{m}=".to_sym }.select { |m| method_defined?(m) }
+    end
+
+    def attr_reader(*args, **opts)
+      args.each do |arg|
+        _register_attr(arg, :attr_reader)
+        serialize_method(arg, opts[:serialize_method], opts[:serialize_opts] || {}) if _attr_serialize?(opts)
+      end
+      super(*args)
+    end
+
+    def attr_writer(*args, **opts)
+      args.each { |arg| _register_attr(arg, :attr_writer) }
+      super(*args)
+    end
+
+    def attr_accessor(*args, **opts)
+      args.each do |arg|
+        _register_attr(arg, :attr_accessor)
+        serialize_method(arg, opts[:serialize_method], opts[:serialize_opts] || {}) if _attr_serialize?(opts)
+      end
+      super(*args)
+    end
+
+    def attr_custom(method, opts = {}, &block)
+      called_by = caller_locations(1, 1)[0].label.gsub('block in ', '') rescue :attr_custom
+      type      = (called_by =~ /^attr_/ ? called_by.to_sym : (opts[:attr_type] || :custom))
+      opts      = opts.dup
+      ivar      = "@#{method}".to_sym
+      mthd_type = opts[:singleton] ? :define_singleton_method : :define_method
+
+      self.send(mthd_type, "#{method}=") do |*args|
+        args = opts[:pre_proc].call(*args) if opts[:pre_proc]
+        instance_variable_set(ivar, (args.is_a?(Array) ? yield(*args) : yield(args)))
+      end
+
+      self.send(mthd_type, method) do
+        if opts[:getter] && opts[:getter].is_a?(Proc)
+          opts[:getter].arity == 0 ? opts[:getter].call : opts[:getter].call(self)
+        elsif instance_variable_defined?(ivar) && !(var = instance_variable_get(ivar)).nil?
+          var
+        elsif opts.include?(:default) || opts.include?(:default_proc)
+          default_value =
+            if opts[:default].respond_to?(:dup) && BBLib.is_a?(opts[:default], Array, Hash)
+              opts[:default].dup rescue opts[:default]
+            elsif opts[:default_proc].is_a?(Proc)
+              prc = opts[:default_proc]
+              prc.arity == 0 ? prc.call : prc.call(self)
+            elsif opts[:default_proc].is_a?(Symbol)
+              send(opts[:default_proc])
+            else
+              opts[:default]
+            end
+          send("#{method}=", default_value)
+        end
+      end
+
+      unless opts[:singleton]
+        protected method if opts[:protected] || opts[:protected_reader]
+        protected "#{method}=".to_sym if opts[:protected] || opts[:protected_writer]
+        private method if opts[:private] || opts[:private_reader]
+        private "#{method}=".to_sym if opts[:private] || opts[:private_writer]
+
+        serialize_method(method, opts[:serialize_method], (opts[:serialize_opts] || {}).merge(default: opts[:default])) if _attr_serialize?(opts)
+        _register_attr(method, type, opts)
+      end
+    end
+
+    def _attr_serialize?(opts)
+      return false unless respond_to?(:serialize_method)
+      (opts[:private] || opts[:protected]) && opts[:serialize] ||
+      (opts.include?(:serialize) && opts[:serialize]) || !opts.include?(:serialize)
+    end
+
+    def attr_of(klasses, *methods, **opts)
+      allowed = [klasses].flatten
+      methods.each do |method|
+        attr_custom(method, opts.merge(_attr_type: :of, classes: klasses)) do |arg|
+          if BBLib.is_a?(arg, *allowed) || (arg.nil? && opts[:allow_nil])
+            arg
+          elsif arg && (!opts.include?(:pack) || opts[:pack]) && arg = _attr_pack(arg, klasses, opts)
+            arg
+          else
+            raise ArgumentError, "#{method} must be set to a class of #{allowed.join_terms(:or)}, NOT #{arg.class}" unless opts[:suppress]
+          end
+        end
+      end
+    end
+
+    def attr_string(*methods, **opts)
+      methods.each do |method|
+        attr_custom(method, opts) { |arg| arg.nil? && opts[:allow_nil] ? arg : arg.to_s }
+      end
+    end
+
+    alias attr_str attr_string
+
+    def attr_integer(*methods, **opts)
+      methods.each do |method|
+        attr_custom(method, opts) { |arg| arg.nil? && opts[:allow_nil] ? arg : arg.to_i }
+      end
+    end
+
+    alias attr_int attr_integer
+
+    def attr_float(*methods, **opts)
+      methods.each do |method|
+        attr_custom(method, opts) { |arg| arg.nil? && opts[:allow_nil] ? arg : arg.to_f }
+      end
+    end
+
+    def attr_symbol(*methods, **opts)
+      methods.each do |method|
+        attr_custom(method, opts) do |arg|
+          if arg.nil?
+            opts[:allow_nil] ? arg : raise(ArgumentError, "#{method} cannot be set to nil.")
+          else
+            arg.to_s.to_sym
+          end
+        end
+      end
+    end
+
+    alias attr_sym attr_symbol
+
+    def attr_boolean(*methods, **opts)
+      methods.each do |method|
+        attr_custom(method, opts) { |arg| arg ? true : false }
+        next if opts[:no_?]
+        if opts[:singleton]
+          singleton_class.send(:alias_method, "#{method}?", method)
+        else
+          alias_method "#{method}?", method
+        end
+      end
+    end
+
+    alias attr_bool attr_boolean
+
+    def attr_integer_between(min, max, *methods, **opts)
+      methods.each do |method|
+        attr_custom(method, opts) { |arg| arg.nil? && opts[:allow_nil] ? arg : BBLib.keep_between(arg, min, max) }
+      end
+    end
+
+    alias attr_int_between attr_integer_between
+    alias attr_float_between attr_integer_between
+
+    def attr_integer_loop(min, max, *methods, **opts)
+      methods.each do |method|
+        attr_custom(method, opts) { |arg| arg.nil? && opts[:allow_nil] ? arg : BBLib.loop_between(arg, min, max) }
+      end
+    end
+
+    alias attr_int_loop attr_integer_loop
+    alias attr_float_loop attr_integer_loop
+
+    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
+          if ls.include?(arg) || (opts[:allow_nil] && arg.nil?)
+            arg
+          else
+            raise ArgumentError, "Invalid option '#{arg}' for #{method}." unless opts.include?(:raise) && !opts[:raise]
+          end
+        end
+      end
+    end
+
+    def attr_elements_of(list, *methods, **opts)
+      methods.each do |method|
+        attr_custom(method, opts.merge(list: list)) do |args|
+          ls = list.is_a?(Proc) ? list.call : list
+          [].tap do |final|
+            [args].flatten(1).each do |arg|
+              if ls.include?(arg) || (opts[:allow_nil] && arg.nil?)
+                final << arg
+              else
+                raise ArgumentError, "Invalid option '#{arg}' for #{method}." unless opts.include?(:raise) && !opts[:raise]
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def attr_array(*methods, **opts)
+      methods.each do |method|
+        attr_custom(method, opts) do |arg|
+          args = arg.is_a?(Array) ? arg : [arg]
+          args = args.uniq if opts[:uniq]
+          args
+        end
+        attr_array_adder(method, opts[:adder_name], singleton: opts[:singleton]) if opts[:add_rem] || opts[:adder]
+        attr_array_remover(method, opts[:remover_name], singleton: opts[:singleton]) if opts[:add_rem] || opts[:remover]
+      end
+    end
+
+    alias attr_ary attr_array
+
+    def attr_array_of(klasses, *methods, **opts)
+      klasses = [klasses].flatten
+      methods.each do |method|
+        attr_custom(method, opts.merge(classes: klasses)) do |args|
+          array = []
+          if args.nil?
+            if opts[:allow_nil]
+              array = nil
+            else
+              raise ArgumentError, "#{method} cannot be set to nil."
+            end
+          else
+            args = [args] unless args.is_a?(Array)
+            args.each do |arg|
+              match = BBLib.is_a?(arg, *klasses)
+              if match
+                array.push(arg) if match
+              elsif arg && (!opts.include?(:pack) || opts[:pack]) && arg = _attr_pack(arg, klasses, opts)
+                array.push(arg)
+              else
+                raise ArgumentError, "Invalid class passed to #{method}: #{arg.class}. Must be a #{klasses.join_terms(:or)}." unless opts[:raise] == false
+              end
+            end
+          end
+          array
+        end
+        attr_array_adder(method, opts[:adder_name], singleton: opts[:singleton]) if opts[:add_rem] || opts[:adder]
+        attr_array_remover(method, opts[:remover_name], singleton: opts[:singleton]) if opts[:add_rem] || opts[:remover]
+      end
+    end
+
+    alias attr_ary_of attr_array_of
+
+    def attr_array_adder(method, name = nil, singleton: false, &block)
+      name = "add_#{method}" unless name
+      mthd_type = singleton ? :define_singleton_method : :define_method
+      send(mthd_type, name) do |*args|
+        array = send(method)
+        args.each do |arg|
+          arg = yield(arg) if block_given?
+          array.push(arg)
+        end
+        send("#{method}=", array)
+      end
+    end
+
+    def attr_array_remover(method, name = nil, singleton: false)
+      name = "remove_#{method}" unless name
+      define_method(name) do |*args|
+        array = instance_variable_get("@#{method}")
+        args.map do |arg|
+          next unless array && !array.empty?
+          array.delete(arg)
+        end
+      end
+    end
+
+    def attr_file(*methods, **opts)
+      methods.each do |method|
+        attr_custom(method, opts) do |arg|
+          exists = File.exist?(arg.to_s)
+          if !exists && opts[:mkfile] && arg
+            FileUtils.touch(arg.to_s)
+            exists = File.exist?(arg.to_s)
+          end
+          raise ArgumentError, "#{method} must be set to a valid file. '#{arg}' cannot be found." unless exists || (opts[:allow_nil] && arg.nil?)
+          arg
+        end
+      end
+    end
+
+    def attr_dir(*methods, **opts)
+      methods.each do |method|
+        attr_custom(method, opts) do |arg|
+          exists = Dir.exist?(arg.to_s)
+          if !exists && (opts[:mkdir] || opts[:mkpath]) && arg
+            FileUtils.mkpath(arg.to_s)
+            exists = Dir.exist?(arg.to_s)
+          end
+          raise ArgumentError, "#{method} must be set to a valid directory. '#{arg}' cannot be found." unless exists || (opts[:allow_nil] && arg.nil?)
+          arg
+        end
+      end
+    end
+
+    def attr_time(*methods, **opts)
+      methods.each do |method|
+        attr_custom(method, **opts) do |arg|
+          if opts[:formats]
+            arg = arg.to_s
+            opts[:format].each do |format|
+              arg = Time.strftime(arg, format) rescue arg
+            end
+          end
+          if arg.is_a?(Time) || arg.nil? && opts[:allow_nil]
+            arg
+          elsif arg.is_a?(Numeric)
+            Time.at(arg)
+          else
+            begin
+              Time.parse(arg.to_s)
+            rescue => e
+              nil
+            end
+          end
+        end
+      end
+    end
+
+    def attr_date(*methods, **opts)
+      methods.each do |method|
+        attr_custom(method, **opts) do |arg|
+          if opts[:formats]
+            arg = arg.to_s
+            opts[:format].each do |format|
+              arg = Date.strftime(arg, format) rescue arg
+            end
+          end
+          if arg.is_a?(Date) || arg.nil? && opts[:allow_nil]
+            arg
+          elsif arg.is_a?(Numeric)
+            Date.parse(Time.at(arg).to_s)
+          else
+            begin
+              Date.parse(arg.to_s)
+            rescue => e
+              nil
+            end
+          end
+        end
+      end
+    end
+
+    def attr_hash(*methods, **opts)
+      methods.each do |method|
+        attr_custom(method, **opts) do |arg|
+          raise ArgumentError, "#{method} must be set to a hash, not a #{arg.class} (for #{self})." unless arg.is_a?(Hash) || arg.nil? && opts[:allow_nil]
+          if opts[:keys] && arg
+            arg.keys.each do |key|
+              if BBLib.is_a?(key, *opts[:keys])
+                next
+              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)}."
+              end
+            end
+          end
+          if opts[:values] && arg
+            arg.each do |key, value|
+              if BBLib.is_a?(value, *opts[:values])
+                next
+              elsif (!opts.include?(:pack_value) || opts[:pack_value]) && value = _attr_pack(value, klasses, opts)
+                arg[key] = arg.delete(value)
+              else
+                raise ArgumentError, "Invalid value type for #{method}: #{value.class}. Must be #{opts[:values].join_terms(:or)}."
+              end
+            end
+          end
+          arg = arg.keys_to_sym if opts[:symbol_keys] && arg
+          arg
+        end
+      end
+    end
+
+    def _attr_pack(arg, klasses, opts = {})
+      klasses = [klasses].flatten
+      unless BBLib.is_a?(arg, *klasses)
+        return klasses.first.new(*[arg].flatten(1))
+      end
+      nil
+    end
+
+    protected
+
+    def _register_attr(method, type, opts = {})
+      _attrs[method] = { type: type.to_s.sub(/^attr_/, '').to_sym, options: opts }
+      method
+    end
+
+  end
+end