hash_params 0.0.2 → 2.0.0

data/spec/hash_params_spec.rb

@@ -2,85 +2,122 @@ require_relative 'spec_helper'
 
 
 describe HashParams do
+  let(:v) { HashParams }
 
-  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
+  it 'raises error if required and missing' do
+    proc {
+      v.validate(nil, nil, required: true)
+    }.must_raise HashParams::Validator::ValidationError
+  end
+  it 'runs multiple coersions' do
+    v.validate('1aaa2', Float, coerce: [lambda { |o| o.gsub('a', '') }, :to_i]).must_equal(12.0)
+  end
+
+  it 'defaults missing values' do
+    v.validate(nil, Integer, default: 1).must_equal(1)
+    v.validate(nil, Integer, default: lambda { 2 * 5 }).must_equal(10)
+  end
+
+  it 'validates with lambdas' do
+    v.validate(nil, Integer, :validate => lambda { |v| v = 60 * 60 }).must_equal(60 * 60)
+  end
+
+  it 'validates with procs' do
+    v.validate('is_this_valid?', String) do |v|
+      v = 'Validated with Proc'
+    end.must_equal('Validated with Proc')
+  end
+
+  it 'verifies numbers with common params' do
+    v.validate(122, Integer, min: 120, max: 500, in: (100..200), is: 122).must_equal(122)
+  end
+
+  it 'verifies strings with common params' do
+    v.validate('this is a test string', String, min_length: 21, max_length: 30, format: /^t.*g$/).must_equal 'this is a test string'
+  end
+
+  it 'coerces true' do
+    v.validate('t', :boolean).must_equal true
+    v.validate('true', :boolean).must_equal true
+    v.validate('yes', :boolean).must_equal true
+    v.validate('1', :boolean).must_equal true
+    v.validate(1, :boolean).must_equal true
+  end
+
+  it 'coerces false' do
+    v.validate('f', :boolean).must_equal false
+    v.validate('false', :boolean).must_equal false
+    v.validate('no', :boolean).must_equal false
+    v.validate('0', :boolean).must_equal false
+    v.validate(0, :boolean).must_equal false
+  end
+
+
+  it 'coerces array' do
+    v.validate('1|2|3', Array, delimiter: '|').must_equal ["1", "2", "3"]
+  end
+
+  it 'coerces hash' do
+    v.validate('{a => 1,b => 2,c => d}', Hash, delimiter: ',', separator: '=>').must_equal({"a" => "1", "b" => "2", "c" => "d"})
+  end
+
+  it 'validates a hash using a block' do
+    h = {
+        ignored:           "this will be ignored because it's not mentioned",
+        to_be_renamed:     :renamed_value,
+        'integer_coercion': "1",
+        proc_validation:   "is_this_valid?",
+        recursive:         {}
+    }
+    r = v.validate(h, Hash, symbolize_keys: true) do
+      key :doesnt_exist, nil, required: true
+      key :to_be_renamed, Symbol, as: :renamed
+      #Default Lambdas take no parameters
+      key :proc_default, Integer, default: lambda { 1 * 5 }
+      key :proc_validation, String, validate: lambda { |v| v = 'Validated in proc' }
       #recursive
-      param :recursive do
-        param :wasnt_here_before, default: true
+      key :recursive, Hash do
+        key :wasnt_here_before, :boolean, 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
-
+    # r[:proc_default].must_equal 5
+    r[:renamed].must_equal :renamed_value
     #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'
+    r[:proc_validation].must_equal 'Validated in proc'
+
+    r.validation_errors.size.must_equal 1
+    r.validation_errors[0].must_equal "Error processing key 'doesnt_exist': Required Parameter missing and has no default specified"
 
   end
 
-  it 'injects into current class' do
-    r = HashParams.new({will_be_injected: 12345}, self) do
-      param :will_be_injected
+  it 'validates variables in the local binding' do
+
+    x='10'
+    y='this is a test string'
+    z={}
+    will_be_int='100'
+
+    HashParams.with_binding do
+      var :x, Integer, min: 10, max: 100
+      var :y, String, min_length: 21, max_length: 30, format: /^t.*g$/
+      var :z, Hash, raise_errors: true, symbolize_keys: true, make_methods: true do
+        key :blah, String, default: 1
+      end
+      var :will_be_int, :to_i
     end
-    r[:will_be_injected].must_equal 12345
-    @will_be_injected.must_equal 12345
-    will_be_injected.must_equal 12345
+    x.must_equal 10
+    y.must_equal 'this is a test string'
+    z[:blah].must_equal '1'
+    z.blah.must_equal '1'
+    will_be_int.must_equal 100
   end
 
+
 end

data/spec/spec_helper.rb

@@ -11,14 +11,3 @@ require 'minitest/spec'
 require 'minitest/autorun'
 require 'pry'
 
-#require 'minitest/mock'
-
-# require 'rack/test'
-#
-# require 'dummy/app'
-#
-# def app
-#   App
-# end
-#
-# #include Rack::Test::Methods

data/tmp/hash_params.rb

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

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

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

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

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