hash_params 2.0.1 → 2.0.2

data/tmp/hash_params.rb

@@ -1,181 +0,0 @@
-class HashParams < Hash
-  VERSION = '0.0.3'
-
-  attr :errors
-
-  def initialize(incoming_hash={}, opts={})
-    @opts          = opts
-    @incoming_hash = incoming_hash
-    @errors        =[]
-    # @parent                = code.binding.eval 'self'
-
-    #@opts[:injection_target] = self if @opts[:injection_target] == :self
-
-    #binding.pry
-
-    if block_given?
-      instance_eval(&Proc.new)
-    else
-      #no proc was given. This means pass all values
-      @incoming_hash.each do |k, v|
-        set_key_value k, v
-      end
-    end
-  end
-
-  def valid?
-    @errors.empty?
-  end
-
-  def param(key, h = {})
-    begin
-      #What happens if value is  FalseClass ?  Need something a little better
-      val = @incoming_hash[key] || @incoming_hash[key.to_sym] || @incoming_hash[key.to_s]
-      if val.nil? && h[:default]
-        val = h[:default].respond_to?(:call) ? h[:default].call(self) : h[:default]
-      end
-      #don't bother with the rest if required parameter is missing
-      raise "Parameter #{key} is required and missing" if h[:required] && val.nil?
-      #do all coercion and transformation first there could be an array of coersions they will be run in order
-      Array(h[:coerce]).each do |c|
-        begin
-          val = HashParams.coerce(val, c, h)
-        rescue => e
-          @errors << e.to_s
-        end
-      end
-      binding.pry if key == :integer_coercion
-      #coersion could return a nil which won't validate, it could return a false which will attempt to validate
-      begin
-        if HashParams.validate(val, h)
-          #The value is valid add it
-          set_key_value key, val, h[:as]
-        end
-      rescue => e
-        @errors << e.to_s
-      end
-
-      #after all that see if a block is given and process that
-      if block_given? && val.is_a?(Hash)
-        #Proc.new references the implict block
-        val = HashParams.new(val, {}, &Proc.new)
-        set_key_value key, val, h[:as]
-      end
-      val
-    rescue => e
-      @errors << e.to_s
-    end
-     if @errors.length > 0 && @opts[:raise_errors]
-       raise @errors.join("\n")
-     end
-    val
-  end
-
-  def inject_into_target(target, var_name, val)
-    if target
-      #for read write methods
-      target.singleton_class.class_eval do
-        attr_accessor var_name;
-      end
-      target.send("#{var_name}=", val)
-    end
-  end
-
-  def self.validate(param, options ={})
-    return false if param.nil?
-    is_valid = true
-    errors   =[]
-    options.each do |key, value|
-
-      error = case key
-                when :validate
-                  "#{param.to_s} failed validation using proc" if value.respond_to?(:call) && !value.call(param)
-                when :blank
-                  'Parameter cannot be blank' if !value && blank?(param)
-                when :format
-                  'Parameter must be a string if using the format validation' && next unless param.kind_of?(String)
-                  "Parameter must match format #{value}" unless param =~ value
-                when :is
-                  "Parameter must be #{value}" unless param === value
-                when :in, :within, :range
-                  "Parameter must be within #{value}" unless value.respond_to?(:include) ? value.include?(param) : Array(value).include?(param)
-                when :min
-                  "Parameter cannot be less than #{value}" unless value <= param
-                when :max
-                  "Parameter cannot be greater than #{value}" unless value >= param
-                when :min_length
-                  "Parameter cannot have length less than #{value}" unless value <= param.length
-                when :max_length
-                  "Parameter cannot have length greater than #{value}" unless value >= param.length
-                else
-                  nil
-              end
-      if error
-        errors << error
-        is_valid = false
-      end
-    end
-
-    #return true or false depending on if it validated
-    unless errors.empty?
-      raise errors.join("\n")
-    end
-    is_valid
-  end
-
-
-  def self.coerce(val, type, h)
-
-    # exceptions bubble up
-    #order is important
-    return val if type.nil? || val.nil?
-
-    #two special types of transforms
-    #There is no Boolean type so we handle them special
-    if type == :boolean || type =='boolean'
-      return val if (val == true || val == false)
-      return false if /(false|f|no|n|0)$/i === val.to_s.downcase
-      return true if /(true|t|yes|y|1)$/i === val.to_s.downcase
-
-      # if we can't parse we return a nil
-      # maybe !!val is a better return?
-      return nil
-    end
-    #they have given us a coercion which is a string or symbol which is not "boolean", we are going to cast this into a proc and run it
-
-    return type.to_proc.call(val) if type.is_a?(Symbol) || type.is_a?(String)
-    #could be a proc
-
-    return type.call(val) if type.respond_to?(:call)
-    #nothing but simple types left
-    return val if val.is_a?(type)
-    return Integer(val) if type == Integer
-    return Float(val) if type == Float
-    return String(val) if type == String
-    return Date.parse(val) if type == Date
-    return Time.parse(val) if type == Time
-    return DateTime.parse(val) if type == DateTime
-    return Array(val.split(h[:delimiter] || ',')) if type == Array
-    return Hash[val.gsub(/[{}]/, '').gsub('}', '').split(h[:delimiter] || ',').map { |c| c.split(h[:separator] ||':').map { |i| i.strip } }] if type == Hash
-
-    nil
-  end
-
-  def present?(object)
-    !blank?(object)
-  end
-
-  def blank?(object)
-    object.nil? || (object.respond_to?(:empty) && object.empty)
-  end
-
-  def set_key_value(key, value, as = nil)
-    key = as unless as.nil?
-    key = key.to_s.to_sym if @opts[:symbolize_keys]
-    inject_into_target(@opts[:injection_target], key, value) if @opts[:injection_target]
-    inject_into_target(self, key, value) if @opts[:make_methods]
-    self[key]=value
-  end
-
-
-end

data/tmp/hash_params_spec.rb

@@ -1,102 +0,0 @@
-require_relative 'spec_helper'
-
-
-describe HashParams do
-
-  let (:r) {
-    HashParams.new(
-        {
-            ignored:          "this will be ignored because it's not mentioned",
-            to_be_renamed:    :to_be_renamed,
-            integer_coercion: "1",
-            bad_number:       '1aaa2',
-            array_with_delim: '1|2|3',
-            hash_as_string:   "{a => 1,b => 2,c => d}",
-            proc_validation:  "is_this_valid?",
-            some_number:      122,
-            some_string:      'this is a test string'  ,
-            is_true:           'true',
-            is_false:          'f',
-            recursive:     {}
-        }
-    ) do
-      param :doesnt_exist, required: true
-      param :to_be_renamed, as: :renamed
-      param :no_value, default: 1
-      #proc default relying on previously set value
-      param :proc_default, default: lambda { |o| o[:no_value] * 5 }
-      param :integer_coercion, coerce: Integer
-      #chained coersions of various types
-      param :bad_number, coerce: [lambda { |o| o.gsub('a', '') }, :to_i, Float]
-      #arrays and hashes
-      param :array_with_delim, coerce: Array, delimiter: '|'
-      param :hash_as_string, coerce: Hash, delimiter: ',', separator: '=>'
-      param :proc_validation, validate: lambda { |v| v == 'Failed_proc_validation' }
-      #validations
-      param :some_number, min: 120, max: 500, in: (100..200), is: 122
-      param :some_string, min_length: 21, max_length: 30, format: /^t.*g$/
-      #combinations
-      param :missing_with_validation, coerce: Integer, :default => 60 * 60, :validate => lambda { |v| v >= 60 * 60 }
-      param :is_true, coerce: :boolean
-      param :is_false, coerce: :boolean
-      #recursive
-      param :recursive do
-        param :wasnt_here_before, default: true
-      end
-    end
-  }
-
-
-  it 'does amazing things' do
-    (r.valid?).must_equal false
-    r[:ignored].must_be_nil
-    r[:no_value].must_equal 1
-    r[:proc_default].must_equal 5
-    r[:renamed].must_equal :to_be_renamed
-    r[:integer_coercion].must_equal 1
-    r[:bad_number].must_equal 12.0
-
-    r[:array_with_delim].must_equal ["1", "2", "3"]
-    r[:hash_as_string].must_equal ({ "a" => "1", "b" => "2", "c" => "d" })
-    r[:missing_with_validation].must_equal 60 * 60
-    r[:is_true].must_equal true
-    r[:is_false].must_equal false
-
-    #recursive checking
-    r[:recursive][:wasnt_here_before].must_equal true
-
-    #failed items don't show up
-    r.errors.size.must_equal 2
-    r[:doesnt_exist].must_be_nil
-    r[:proc_validation].must_be_nil
-    r.errors[0].must_equal 'Parameter doesnt_exist is required and missing'
-    r.errors[1].must_equal 'is_this_valid? failed validation using proc'
-
-  end
-
-  it 'injects into current class' do
-    r = HashParams.new({will_be_injected: 12345}, injection_target: self) do
-      param :will_be_injected
-    end
-    r[:will_be_injected].must_equal 12345
-    @will_be_injected.must_equal 12345
-    will_be_injected.must_equal 12345
-  end
-
-  it 'passes through without alteration' do
-    r=HashParams.new(test: 1, two: {three: :four})
-    r[:test].must_equal 1
-    r[:two][:three].must_equal :four
-  end
-
-  it 'validates plain objects' do
-    HashParams.validate(1, min: 0, max: 10, is: 1).must_equal true
-  end
-  it 'coerces plain objects' do
-    hash_as_string =   "{a => 1,b => 2,c => d}"
-    h=HashParams.coerce(hash_as_string, Hash,  delimiter: ',', separator: '=>' )
-    h.must_be_instance_of Hash
-
-
-  end
-end

data/tmp/module_spec.rb

@@ -1,27 +0,0 @@
-require 'pry'
-module M1
-  def im
-    puts 'm1 im'
-  end
-end
-
-module M2
-  def self.cm
-    puts 'm2 cm'
-  end
-end
-
-
-module T1
-  include M1
-end
-module T2
-  extend M1
-end
-module T3
-  include M2
-end
-module T4
-  extend M2
-end
-

data/tmp/var_spec.rb

@@ -1,9 +0,0 @@
-require_relative 'spec_helper'
-
-describe HashParams do
-  let(:v) { HashParams }
-  it 'does things' do
-    HashParams::BindingValidator("test")
-    binding.pry
-  end
-end

data/tmp/yaml_params.rb

@@ -1,109 +0,0 @@
-class YamlParams < HashParams
-
-  ENVIRONMENT = ENV['HASH_PARAMS_ENV'] || (defined?(Rails) && Rails.env) || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
-
-  def initialize(file_name=nil, opts={})
-
-    env       ||= opts[:env] || opts[:environment] || ENVIRONMENT
-
-    file_name = nil if [:defaults, :default, :auto].include?(file_name)
-
-    h =if file_name
-         hash_from_yaml_file(file_name)
-       else
-         hash_from_default_yaml_files(opts[:app_name], env, opts[:roots], opts[:file_separator], opts[:file_extension])
-       end
-
-    if block_given?
-      # warn '[DEPRECATION] Passing blocks into the constructor is deprecated. Please use validate or strictly validate in the future'
-      super(h, opts, &Proc.new)
-    else
-      super(h, opts)
-    end
-  end
-
-
-  def hash_from_yaml_file(filename, env=ENVIRONMENT)
-    r = File.exists?(filename) ? YAML::load(ERB.new(File.read(filename)).result) : {}
-    r[env] || r
-  end
-
-
-  def hash_from_default_yaml_files(app_name=nil, env=nil, roots=nil, file_separator=nil, file_extension=nil)
-    #if a nil is passed in we still use the defaults
-    app_name       ||= ''
-    env            ||= ENVIRONMENT
-    roots          ||= nil
-    file_separator ||= '_'
-    file_extension ||= 'yml'
-
-    h        = {}
-    home_dir = File.expand_path('~')
-    hostname = Socket.gethostname
-
-    base_file_names = %W(
-        settings.#{file_extension}
-        default.#{file_extension}
-
-    #{env}.#{file_extension}
-
-    #{hostname}.#{file_extension}
-    #{hostname}#{file_separator}#{env}.#{file_extension}
-
-        local.#{file_extension}
-        local#{file_separator}#{env}.#{file_extension}
-        settings.local.#{file_extension}
-        settings.local#{file_separator}#{env}.#{file_extension}
-        config.local.#{file_extension}
-        config.local#{file_separator}#{env}.#{file_extension}
-    #{app_name}#{file_separator}settings.#{file_extension}
-    #{app_name}#{file_separator}config.#{file_extension}
-    #{app_name}#{file_separator}default.#{file_extension}
-    #{app_name}#{file_separator}#{env}.#{file_extension}
-    #{app_name}#{file_separator}#{hostname}.#{file_extension}
-    #{app_name}#{file_separator}#{hostname}#{file_separator}#{env}.#{file_extension}
-    #{app_name}#{file_separator}local.#{file_extension}
-    #{app_name}#{file_separator}local#{file_separator}#{env}.#{file_extension}
-    #{app_name}#{file_separator}settings.local.#{file_extension}
-    #{app_name}#{file_separator}settings.local#{file_separator}#{env}.#{file_extension}
-    #{app_name}#{file_separator}config.local.#{file_extension}
-    #{app_name}#{file_separator}config.local#{file_separator}#{env}.#{file_extension}
-
-    )
-
-    all_roots       = Array(roots) if roots
-    all_roots       ||= [
-        Dir.pwd,
-        File.join('/etc', app_name.to_s),
-        File.join('/usr', 'local', 'etc', app_name.to_s),
-        File.join(home_dir, 'etc', app_name.to_s),
-        File.join(home_dir, ".#{app_name}"),
-        File.join(home_dir, '.hash_params', app_name.to_s),
-        File.join(Dir.pwd, 'config'),
-        File.join(Dir.pwd, 'settings')
-    ]
-    if defined?(Rails)
-      all_roots << Rails.root.join('config')
-    end
-
-    all_roots.each do |root|
-      base_file_names.each do |fname|
-        file = File.join(root, fname)
-        h    = deep_merge(h, hash_from_yaml_file(file)) if File.exists?(file)
-      end
-    end
-    h
-  end
-
-  def deep_merge(hash, other_hash)
-    if other_hash.is_a?(::Hash) && hash.is_a?(::Hash)
-      other_hash.each do |k, v|
-        hash[k] = hash.key?(k) ? deep_merge(hash[k], v) : v
-      end
-      hash
-    else
-      other_hash
-    end
-  end
-end
-