bblib 0.3.0 → 0.4.1

data/lib/hash/hash_path_proc.rb

@@ -1,256 +0,0 @@
-require 'time'
-
-class Hash
-  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
-    BBLib.hash_path_proc self, action, paths, *args
-  end
-end
-
-module BBLib
-
-  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|
-      hash.hash_path(path).each do |value|
-        if params.include?(:condition) && params[:condition]
-          begin
-            next unless eval(params[:condition].gsub('$', value.to_s))
-          rescue StandardError, SyntaxError => e
-            next
-          end
-        end
-        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]},
-    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
-      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
-      hash.hash_path_set path => "#{value}#{args}"
-    end
-
-    def self.prepend hash, path, value, args
-      hash.hash_path_set path => "#{args}#{value}"
-    end
-
-    def self.split hash, path, value, args
-      hash.hash_path_set path => value.msplit(args)
-    end
-
-    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
-      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
-      extract(hash, path, value, *args + [0])
-    end
-
-    def self.extract_last hash, path, value, *args
-      extract(hash, path, value, *args + [-1])
-    end
-
-    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|
-        next unless formatted.nil?
-        begin
-          formatted = Time.strptime(value.to_s, pattern.to_s).strftime(format)
-        rescue
-        end
-      end
-      begin
-        if formatted.nil? then formatted = Time.parse(value) end
-      rescue
-      end
-      hash.hash_path_set path => formatted
-    end
-
-    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|
-        next unless formatted.nil?
-        begin
-          formatted = Time.strptime(value.to_s, pattern.to_s).strftime(format)
-        rescue
-        end
-      end
-      begin
-        if formatted.nil? then formatted = Time.parse(value) end
-      rescue
-      end
-      hash.hash_path_set path => formatted.to_f
-    end
-
-    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
-      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
-      hash.hash_path_set path => value.to_s
-    end
-
-    def self.downcase hash, path, value, *args
-      hash.hash_path_set path => value.to_s.downcase
-    end
-
-    def self.upcase hash, path, value, *args
-      hash.hash_path_set path => value.to_s.upcase
-    end
-
-    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
-      hash.hash_path_set path => value.to_s.drop_symbols
-    end
-
-    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
-      hash.hash_path_set path => value.to_s.reverse
-    end
-
-    def self.delete hash, path, value, *args
-      hash.hash_path_delete path
-    end
-
-    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
-      hash.hash_path_set path => value.send(*args)
-    end
-
-    def self.encapsulate hash, path, value, args
-      hash.hash_path_set path => "#{args}#{value}#{args}"
-    end
-
-    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
-      hash.hash_path_set path => value.to_s.extract_numbers.max
-    end
-
-    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
-      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
-      hash.hash_path_set path => value.to_s.extract_numbers.inject{ |s,x| s + x }
-    end
-
-    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
-      hash.hash_path_set path => (value.extract_integers)
-    end
-
-    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
-      hash.hash_path_set path => (value.extract_numbers)
-    end
-
-    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 = BBLib::named_args(args)
-      hash.hash_path_set path => "#{hash.hash_path(args.first)[params[:range].nil? ? 0 : params[:range]]}#{params[:join]}#{value}"
-    end
-
-  end
-
-end

data/lib/hash/path_hash.rb

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

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