bblib 0.2.2 → 0.3.0

data/lib/hash/hash_path_proc.rb

@@ -1,20 +1,23 @@
 require 'time'
 
 class Hash
-  def hash_path_proc action, paths, *args, **params
-    BBLib.hash_path_proc self, action, paths, *args, **params
+  def path_proc action, paths, *args
+    BBLib.hash_path_proc self, action, paths, *args
   end
+
+  alias_method :hash_path_proc, :path_proc
 end
 
 class Array
-  def hash_path_proc action, paths, *args, **params
-    BBLib.hash_path_proc self, action, paths, *args, **params
+  def hash_path_proc action, paths, *args
+    BBLib.hash_path_proc self, action, paths, *args
   end
 end
 
 module BBLib
 
-  def self.hash_path_proc hash, action, paths, *args, **params
+  def self.hash_path_proc hash, action, paths, *args
+    params = BBLib::named_args(*args)
     action = HASH_PATH_PROC_TYPES.keys.find{ |k| k == action || HASH_PATH_PROC_TYPES[k][:aliases].include?(action) }
     return nil unless action
     paths.to_a.each do |path|
@@ -26,91 +29,89 @@ module BBLib
             next
           end
         end
-        HashPath.send(action, hash, path, value, *args, **params)
+        HashPath.send(action, hash, path, value, *args)
       end
     end
     return hash
   end
 
   HASH_PATH_PROC_TYPES = {
-    evaluate: { aliases: [:eval, :equation, :equate]},
-    append: { aliases: [:suffix]},
-    prepend: { aliases: [:prefix]},
-    split: { aliases: [:delimit, :delim, :separate, :msplit]},
-    replace: { aliases: [:swap]},
-    extract: { aliases: [:grab, :scan]},
-    extract_first: {aliases: [:grab_first, :scan_first]},
-    extract_last: {aliases: [:grab_last, :scan_last]},
-    parse_date: { aliases: [:date, :parse_time, :time]},
-    parse_date_unix: { aliases: [:unix_time, :unix_date]},
-    parse_duration: { aliases: [:duration]},
-    parse_file_size: { aliases: [:file_size]},
-    to_string: {aliases: [:to_s, :stringify]},
-    downcase: { aliases: [:lower, :lowercase, :to_lower]},
-    upcase: { aliases: [:upper, :uppercase, :to_upper]},
-    roman: { aliases: [:convert_roman, :roman_numeral, :parse_roman]},
-    remove_symbols: { aliases: [:chop_symbols, :drop_symbols]},
-    format_articles: { aliases: [:articles]},
-    reverse: { aliases: [:invert]},
-    delete: { aliases: [:del]},
-    remove: { aliases: [:rem]},
-    custom: {aliases: [:send]},
-    # TODO
-    # titlecase: { aliases: [:title_case]},
-    encapsulate: {aliases: []},
-    uncapsulate: {aliases: []},
-    extract_integers: {aliases: [:extract_ints]},
-    extract_floats: {aliases: []},
-    extract_numbers: {aliases: []},
-    max_number: {aliases: [:max, :maximum, :maximum_number]},
-    min_number: {aliases: [:min, :minimum, :minimum_number]},
-    avg_number: {aliases: [:avg, :average, :average_number]},
-    sum_number: {aliases: [:sum]},
-    strip: {aliases: [:trim]},
-    # rename: { aliases: [:rename_key]},
-    concat: { aliases: [:join, :concat_with]},
-    reverse_concat: { aliases: [:reverse_join, :reverse_concat_with]}
+    evaluate:         { aliases: [:eval, :equation, :equate]},
+    append:           { aliases: [:suffix]},
+    prepend:          { aliases: [:prefix]},
+    split:            { aliases: [:delimit, :delim, :separate, :msplit]},
+    replace:          { aliases: [:swap]},
+    extract:          { aliases: [:grab, :scan]},
+    extract_first:    { aliases: [:grab_first, :scan_first]},
+    extract_last:     { aliases: [:grab_last, :scan_last]},
+    parse_date:       { aliases: [:date, :parse_time, :time]},
+    parse_date_unix:  { aliases: [:unix_time, :unix_date]},
+    parse_duration:   { aliases: [:duration]},
+    parse_file_size:  { aliases: [:file_size]},
+    to_string:        { aliases: [:to_s, :stringify]},
+    downcase:         { aliases: [:lower, :lowercase, :to_lower]},
+    upcase:           { aliases: [:upper, :uppercase, :to_upper]},
+    roman:            { aliases: [:convert_roman, :roman_numeral, :parse_roman]},
+    remove_symbols:   { aliases: [:chop_symbols, :drop_symbols]},
+    format_articles:  { aliases: [:articles]},
+    reverse:          { aliases: [:invert]},
+    delete:           { aliases: [:del]},
+    remove:           { aliases: [:rem]},
+    custom:           { aliases: [:send]},
+    encapsulate:      { aliases: []},
+    uncapsulate:      {aliases: []},
+    extract_integers: { aliases: [:extract_ints]},
+    extract_floats:   { aliases: []},
+    extract_numbers:  { aliases: []},
+    max_number:       { aliases: [:max, :maximum, :maximum_number]},
+    min_number:       { aliases: [:min, :minimum, :minimum_number]},
+    avg_number:       { aliases: [:avg, :average, :average_number]},
+    sum_number:       { aliases: [:sum]},
+    strip:            { aliases: [:trim]},
+    concat:           { aliases: [:join, :concat_with]},
+    reverse_concat:   { aliases: [:reverse_join, :reverse_concat_with]}
   }
 
   module HashPath
 
-    def self.evaluate hash, path, value, args, params
+    def self.evaluate hash, path, value, args
       exp = args.to_a.first.to_s.gsub('$', value.to_s)
       hash.hash_path_set path => eval(exp)
     end
 
-    def self.append hash, path, value, args, params
+    def self.append hash, path, value, args
       hash.hash_path_set path => "#{value}#{args}"
     end
 
-    def self.prepend hash, path, value, args, params
+    def self.prepend hash, path, value, args
       hash.hash_path_set path => "#{args}#{value}"
     end
 
-    def self.split hash, path, value, args, params
+    def self.split hash, path, value, args
       hash.hash_path_set path => value.msplit(args)
     end
 
-    def self.replace hash, path, value, args, params
+    def self.replace hash, path, value, args
       value = value.dup.to_s
       args.each{ |k,v| value.gsub!(k, v.to_s) }
       hash.hash_path_set path => value
     end
 
-    def self.extract hash, path, value, *args, **params
+    def self.extract hash, path, value, *args
       slice = (Array === args && args[1].nil? ? (0..-1) : args[1])
       hash.hash_path_set path => value.to_s.scan(args.first)[slice]
     end
 
-    def self.extract_first hash, path, value, *args, **params
+    def self.extract_first hash, path, value, *args
       extract(hash, path, value, *args + [0])
     end
 
-    def self.extract_last hash, path, value, *args, **params
+    def self.extract_last hash, path, value, *args
       extract(hash, path, value, *args + [-1])
     end
 
-    def self.parse_date hash, path, value, *args, **params
+    def self.parse_date hash, path, value, *args
+      params = BBLib::named_args(args)
       format = params.include?(:format) ? params[:format] : '%Y-%m-%d %H:%M:%S'
       formatted = nil
       args.each do |pattern|
@@ -127,7 +128,8 @@ module BBLib
       hash.hash_path_set path => formatted
     end
 
-    def self.parse_date_unix hash, path, value, *args, **params
+    def self.parse_date_unix hash, path, value, *args
+      params = BBLib::named_args(args)
       format = params.include?(:format) ? params[:format] : '%Y-%m-%d %H:%M:%S'
       formatted = nil
       args.each do |pattern|
@@ -144,110 +146,108 @@ module BBLib
       hash.hash_path_set path => formatted.to_f
     end
 
-    def self.parse_duration hash, path, value, args, params
+    def self.parse_duration hash, path, value, args
       hash.hash_path_set path => value.to_s.parse_duration(output: args.empty? ? :sec : args )
     end
 
-    def self.parse_file_size hash, path, value, args, params
+    def self.parse_file_size hash, path, value, args
       hash.hash_path_set path => value.to_s.parse_file_size(output: args.empty? ? :bytes : args )
     end
 
-    def self.to_string hash, path, value, *args, **params
+    def self.to_string hash, path, value, *args
       hash.hash_path_set path => value.to_s
     end
 
-    def self.downcase hash, path, value, *args, **params
+    def self.downcase hash, path, value, *args
       hash.hash_path_set path => value.to_s.downcase
     end
 
-    def self.upcase hash, path, value, *args, **params
+    def self.upcase hash, path, value, *args
       hash.hash_path_set path => value.to_s.upcase
     end
 
-    def self.roman hash, path, value, *args, **params
+    def self.roman hash, path, value, *args
       hash.hash_path_set path => (args[0] == :to ? value.to_s.to_roman : value.to_s.from_roman)
     end
 
-    def self.remove_symbols hash, path, value, *args, **params
+    def self.remove_symbols hash, path, value, *args
       hash.hash_path_set path => value.to_s.drop_symbols
     end
 
-    def self.format_articles hash, path, value, args, **params
+    def self.format_articles hash, path, value, args
       hash.hash_path_set path => value.to_s.move_articles(args.nil? ? :front : args)
     end
 
-    def self.reverse hash, path, value, *args, **params
+    def self.reverse hash, path, value, *args
       hash.hash_path_set path => value.to_s.reverse
     end
 
-    def self.delete hash, path, value, *args, **params
+    def self.delete hash, path, value, *args
       hash.hash_path_delete path
     end
 
-    def self.remove hash, path, value, *args, **params
+    def self.remove hash, path, value, *args
       removed = value.to_s
       args.each{ |a| removed.gsub!(a, '')}
       hash.hash_path_set path => removed
     end
 
-    def self.custom hash, path, value, *args, **params
-      if params.nil? || params.empty?
-        hash.hash_path_set path => value.send(*args)
-      else
-        hash.hash_path_set path => value.send(*args, **params)
-      end
+    def self.custom hash, path, value, *args
+      hash.hash_path_set path => value.send(*args)
     end
 
-    def self.encapsulate hash, path, value, args, **params
+    def self.encapsulate hash, path, value, args
       hash.hash_path_set path => "#{args}#{value}#{args}"
     end
 
-    def self.uncapsulate hash, path, value, args, **params
+    def self.uncapsulate hash, path, value, args
       value = value[args.size..-1] if value.start_with?(args)
       value = value[0..-(args.size)-1] if value.end_with?(args)
       hash.hash_path_set path => value
     end
 
-    def self.max_number hash, path, value, *args, **params
+    def self.max_number hash, path, value, *args
       hash.hash_path_set path => value.to_s.extract_numbers.max
     end
 
-    def self.min_number hash, path, value, *args, **params
+    def self.min_number hash, path, value, *args
       hash.hash_path_set path => value.to_s.extract_numbers.min
     end
 
-    def self.avg_number hash, path, value, *args, **params
+    def self.avg_number hash, path, value, *args
       nums = value.to_s.extract_numbers
       avg = nums.inject{ |s, x| s + x }.to_f / nums.size.to_f
       hash.hash_path_set path => avg
     end
 
-    def self.sum_number hash, path, value, *args, **params
+    def self.sum_number hash, path, value, *args
       hash.hash_path_set path => value.to_s.extract_numbers.inject{ |s,x| s + x }
     end
 
-    def self.strip hash, path, value, args, **params
+    def self.strip hash, path, value, args
       value.map!{ |m| m.respond_to?(:strip) ? m.strip : m } if value.is_a?(Array)
       hash.hash_path_set path => (value.respond_to?(:strip) ? value.strip : value)
     end
 
-    def self.extract_integers hash, path, value, args, **params
+    def self.extract_integers hash, path, value, args
       hash.hash_path_set path => (value.extract_integers)
     end
 
-    def self.extract_floats hash, path, value, args, **params
+    def self.extract_floats hash, path, value, args
       hash.hash_path_set path => (value.extract_floats)
     end
 
-    def self.extract_numbers hash, path, value, args, **params
+    def self.extract_numbers hash, path, value, args
       hash.hash_path_set path => (value.extract_numbers)
     end
 
-    def self.concat hash, path, value, *args, **params
+    def self.concat hash, path, value, *args
+      params = BBLib::named_args(args)
       hash.hash_path_set path => "#{value}#{params[:join]}#{hash.hash_path(args.first)[params[:range].nil? ? 0 : params[:range]]}"
     end
 
-    def self.reverse_concat hash, path, value, *args, **params
+    def self.reverse_concat hash, path, value, *args
+      params = BBLib::named_args(args)
       hash.hash_path_set path => "#{hash.hash_path(args.first)[params[:range].nil? ? 0 : params[:range]]}#{params[:join]}#{value}"
     end
 

data/lib/hash/path_hash.rb

@@ -0,0 +1,81 @@
+
+# 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
+
+  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_method :_v, :_val
+
+    def _fval
+      @hash.first rescue @hash
+    end
+
+    alias_method :_f, :_fval
+
+    def _
+      @recursive = true
+      self
+    end
+
+    def _path arg, formula = nil
+      method_missing arg, formula
+    end
+
+    private
+
+    def method_missing arg, formula = nil
+      arg = (@recursive ? "..#{arg}" : arg.to_s) +
+            (formula ? "(#{formula})" : '')
+      if @hash.is_a?(::Array)
+        PathHash.new @hash.map{ |h| if h.is_a?(::Array) || h.is_a?(::Hash) then h.hash_path(arg) end }.flatten(1)
+      else
+        PathHash.new @hash.hpath(arg)
+      end
+    end
+
+  end
+
+end
+
+
+class Hash
+
+  def path_hash
+    BBLib::path_hash(self)
+  end
+
+  alias_method :phash, :path_hash
+  alias_method :_ph, :path_hash
+
+end
+
+class Array
+
+  def path_hash
+    BBLib::path_hash(self)
+  end
+
+  alias_method :phash, :path_hash
+  alias_method :_ph, :path_hash
+
+end

data/lib/object/attr.rb

@@ -0,0 +1,182 @@
+module BBLib::Attr
+
+  private
+
+  def attr_type method, opts, &block
+    define_method("#{method}=", &block)
+    define_method(method){ instance_variable_get("@#{method}")}
+    if defined?(:before) && opts.include?(:default)
+      define_method("__reset_#{method}".to_sym){ send("#{method}=", opts[:default]) }
+    end
+  end
+
+  def attr_sender call, *methods, **opts
+    methods.each do |m|
+      attr_type(
+        m,
+        opts,
+        &attr_set(
+          m,
+          opts.merge(sender: true)
+        ){ |x| x.nil? && opts[:allow_nil] ? nil : x.send(call) }
+      )
+    end
+  end
+
+  def attr_of klass, *methods, **opts
+    methods.each{ |m| attr_type(m, opts, &attr_set(m, opts){ |x|
+        if x.is_a?(klass)
+          instance_variable_set("@#{m}", x)
+        else
+          raise ArgumentError, "#{method} must be set to a #{klass}!"
+        end
+      }
+    )
+  }
+  end
+
+  def attr_boolean *methods, **opts
+    methods.each{ |m|
+      attr_type(m, opts) { |x| instance_variable_set("@#{m}", !!x && x.to_s != 'false') }
+      alias_method "#{m}?", m unless opts[:no_q]
+    }
+  end
+
+  alias_method :attr_bool, :attr_boolean
+
+  def attr_string *methods, **opts
+    attr_sender :to_s, *methods, opts
+  end
+
+  alias_method :attr_str, :attr_string
+  alias_method :attr_s, :attr_string
+
+  def attr_integer *methods, **opts
+    attr_sender :to_i, *methods, opts
+  end
+
+  alias_method :attr_int, :attr_integer
+  alias_method :attr_i, :attr_integer
+
+  def attr_float *methods, **opts
+    attr_sender :to_f, *methods, opts
+  end
+
+  alias_method :attr_f, :attr_float
+
+  def attr_integer_between min, max, *methods, **opts
+    methods.each{ |m| attr_type(m, opts, &attr_set(m, opts){ |x| BBLib::keep_between(x, min, max) })}
+  end
+
+  alias_method :attr_int_between, :attr_integer_between
+  alias_method :attr_i_between, :attr_integer_between
+  alias_method :attr_float_between, :attr_integer_between
+  alias_method :attr_f_between, :attr_float_between
+
+  def attr_symbol *methods, **opts
+    methods.each{ |m| attr_type(m, opts, &attr_set(m, opts){ |x| x.to_s.to_sym } )}
+  end
+
+  alias_method :attr_sym, :attr_symbol
+
+  def attr_clean_symbol *methods, **opts
+    methods.each{ |m| attr_type(m, opts, &attr_set(m, opts){ |x| x.to_s.to_clean_sym } )}
+  end
+
+  alias_method :attr_clean_sym, :attr_clean_symbol
+
+  def attr_array *methods, **opts
+    methods.each{ |m| attr_type(m, opts, &attr_set(m, opts){ |*x| instance_variable_set("@#{m}", x) } )}
+  end
+
+  alias_method :attr_ary, :attr_array
+
+  def attr_element_of list, *methods, **opts
+    methods.each do |m|
+      attr_type(m, opts, &attr_set(m, opts) do |x|
+          if !list.include?(x)
+            raise ArgumentError, "#{m} only accepts the following (first 10 shown) #{list[0...10]}"
+          else
+            instance_variable_set("@#{m}", x)
+          end
+        end
+      )
+    end
+  end
+
+  def attr_array_of klass, *methods, raise: false, **opts
+    methods.each do |m|
+      attr_type(m, opts, &attr_set(m, opts) do |*x|
+          if raise && x.any?{ |i| klass.is_a?(Array) ? !klass.any?{ |k| i.is_a?(k) } : !i.is_a?(klass) }
+            raise ArgumentError, "#{m} only accepts items of class #{klass}."
+          end
+          instance_variable_set("@#{m}", x.reject{|i| klass.is_a?(Array) ? !klass.any?{ |k| i.is_a?(k) } : !i.is_a?(klass) })
+        end
+      )
+    end
+  end
+
+  alias_method :attr_ary_of, :attr_array_of
+
+  def attr_hash *methods, **opts
+    methods.each{ |m| attr_type(m, opts, &attr_set(m, opts) do |*a|
+          begin
+            hash = a.find_all{ |i| i.is_a?(Hash) }.inject({}){ |m, h| m.merge(h) } || Hash.new
+            instance_variable_set("@#{m}", hash)
+          rescue ArgumentError => e
+            raise ArgumentError, "#{m} only accepts a hash for its parameters"
+          end
+        end
+      )
+    }
+  end
+
+  def attr_valid_file *methods, raise: true, **opts
+    methods.each{ |m| attr_type(m, opts, &attr_set(m, opts){ |x| File.exists?(x.to_s) ? x.to_s : (raise ? raise(ArgumentError, "File '#{x}' does not exist. @#{m} must be set to a valid file location!") : nil)} )}
+  end
+
+  def attr_valid_dir *methods, raise: true, **opts
+    methods.each{ |m| attr_type(m, opts, &attr_set(m, opts){ |x| Dir.exists?(x.to_s) ? x.to_s : (raise ? raise(ArgumentError, "Dir '#{x}' does not exist. @#{m} must be set to a valid directory location!") : nil)} )}
+  end
+
+  def attr_time *methods, **opts
+    methods.each do |m|
+      attr_type(
+        m,
+        opts,
+        &attr_set(m, opts){ |x|
+          if x.is_a?(Time) || x.nil? && opt[:allow_nil]
+            x
+          elsif x.is_a?(Numeric)
+            Time.at(x)
+          elsif x.is_a?(String)
+            Time.parse(x)
+          else
+            raise "#{x} is an invalid Time object and could not be converted into a Time object."
+          end
+        }
+      )
+    end
+  end
+
+  def attr_set method, allow_nil: false, fallback: :_nil, sender: false, default: nil, &block
+    proc{ |x|
+      if x.nil? && !allow_nil && fallback == :_nil && !sender
+        raise ArgumentError, "#{method} cannot be set to nil!"
+      elsif x.nil? && !allow_nil && fallback != :_nil && !sender
+        instance_variable_set("@#{method}", fallback)
+      else
+        begin
+          instance_variable_set("@#{method}", x.nil? && !sender ? x : yield(x) )
+        rescue Exception => e
+          if fallback != :_nil
+            instance_variable_set("@#{method}", fallback)
+          else
+            raise e
+          end
+        end
+      end
+    }
+  end
+
+end