hash_params 2.0.2 → 2.0.3

data/lib/hash_params/yaml_params.rb

@@ -48,6 +48,9 @@ module YamlParams
     ]
     if defined?(Rails)
       default_roots << Rails.root.join('config')
+      default_roots << Rails.root.join('config', env)
+      default_roots << Rails.root.join('config', 'settings')
+      default_roots << Rails.root.join('config', 'settings', env)
     end
 
 

data/lib/hash_params.rb

@@ -8,7 +8,7 @@ require_relative 'hash_params/binding_validator'
 
 module HashParams
   ENVIRONMENT =  ENV['HASH_PARAMS_ENV'] || (defined?(Rails) && Rails.env) || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
-  VERSION = '2.0.2'
+  VERSION = '2.0.3'
   extend HashParams::Validator
 end
 

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
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hash_params
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.3
 platform: ruby
 authors:
 - Tim Uckun
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-20 00:00:00.000000000 Z
+date: 2016-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -93,12 +93,67 @@ files:
 - "./LICENSE"
 - "./README.md"
 - "./Rakefile"
+- "./coverage/assets/0.8.0/application.css"
+- "./coverage/assets/0.8.0/application.js"
+- "./coverage/assets/0.8.0/colorbox/border.png"
+- "./coverage/assets/0.8.0/colorbox/controls.png"
+- "./coverage/assets/0.8.0/colorbox/loading.gif"
+- "./coverage/assets/0.8.0/colorbox/loading_background.png"
+- "./coverage/assets/0.8.0/favicon_green.png"
+- "./coverage/assets/0.8.0/favicon_red.png"
+- "./coverage/assets/0.8.0/favicon_yellow.png"
+- "./coverage/assets/0.8.0/loading.gif"
+- "./coverage/assets/0.8.0/magnify.png"
+- "./coverage/assets/0.8.0/smoothness/images/ui-bg_flat_0_aaaaaa_40x100.png"
+- "./coverage/assets/0.8.0/smoothness/images/ui-bg_flat_75_ffffff_40x100.png"
+- "./coverage/assets/0.8.0/smoothness/images/ui-bg_glass_55_fbf9ee_1x400.png"
+- "./coverage/assets/0.8.0/smoothness/images/ui-bg_glass_65_ffffff_1x400.png"
+- "./coverage/assets/0.8.0/smoothness/images/ui-bg_glass_75_dadada_1x400.png"
+- "./coverage/assets/0.8.0/smoothness/images/ui-bg_glass_75_e6e6e6_1x400.png"
+- "./coverage/assets/0.8.0/smoothness/images/ui-bg_glass_95_fef1ec_1x400.png"
+- "./coverage/assets/0.8.0/smoothness/images/ui-bg_highlight-soft_75_cccccc_1x100.png"
+- "./coverage/assets/0.8.0/smoothness/images/ui-icons_222222_256x240.png"
+- "./coverage/assets/0.8.0/smoothness/images/ui-icons_2e83ff_256x240.png"
+- "./coverage/assets/0.8.0/smoothness/images/ui-icons_454545_256x240.png"
+- "./coverage/assets/0.8.0/smoothness/images/ui-icons_888888_256x240.png"
+- "./coverage/assets/0.8.0/smoothness/images/ui-icons_cd0a0a_256x240.png"
+- "./coverage/assets/0.9.0/application.css"
+- "./coverage/assets/0.9.0/application.js"
+- "./coverage/assets/0.9.0/colorbox/border.png"
+- "./coverage/assets/0.9.0/colorbox/controls.png"
+- "./coverage/assets/0.9.0/colorbox/loading.gif"
+- "./coverage/assets/0.9.0/colorbox/loading_background.png"
+- "./coverage/assets/0.9.0/favicon_green.png"
+- "./coverage/assets/0.9.0/favicon_red.png"
+- "./coverage/assets/0.9.0/favicon_yellow.png"
+- "./coverage/assets/0.9.0/loading.gif"
+- "./coverage/assets/0.9.0/magnify.png"
+- "./coverage/assets/0.9.0/smoothness/images/ui-bg_flat_0_aaaaaa_40x100.png"
+- "./coverage/assets/0.9.0/smoothness/images/ui-bg_flat_75_ffffff_40x100.png"
+- "./coverage/assets/0.9.0/smoothness/images/ui-bg_glass_55_fbf9ee_1x400.png"
+- "./coverage/assets/0.9.0/smoothness/images/ui-bg_glass_65_ffffff_1x400.png"
+- "./coverage/assets/0.9.0/smoothness/images/ui-bg_glass_75_dadada_1x400.png"
+- "./coverage/assets/0.9.0/smoothness/images/ui-bg_glass_75_e6e6e6_1x400.png"
+- "./coverage/assets/0.9.0/smoothness/images/ui-bg_glass_95_fef1ec_1x400.png"
+- "./coverage/assets/0.9.0/smoothness/images/ui-bg_highlight-soft_75_cccccc_1x100.png"
+- "./coverage/assets/0.9.0/smoothness/images/ui-icons_222222_256x240.png"
+- "./coverage/assets/0.9.0/smoothness/images/ui-icons_2e83ff_256x240.png"
+- "./coverage/assets/0.9.0/smoothness/images/ui-icons_454545_256x240.png"
+- "./coverage/assets/0.9.0/smoothness/images/ui-icons_888888_256x240.png"
+- "./coverage/assets/0.9.0/smoothness/images/ui-icons_cd0a0a_256x240.png"
+- "./coverage/index.html"
+- "./hash_params-2.0.1.gem"
 - "./hash_params.gemspec"
 - "./lib/hash_params.rb"
 - "./lib/hash_params/binding_validator.rb"
 - "./lib/hash_params/hash_validator.rb"
 - "./lib/hash_params/validator.rb"
 - "./lib/hash_params/yaml_params.rb"
+- "./tmp/hash_params.rb"
+- "./tmp/hash_params_spec.rb"
+- "./tmp/module_spec.rb"
+- "./tmp/var_spec.rb"
+- "./tmp/yaml_params.rb"
 - spec/hash_params_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/timuckun/hash_params
@@ -121,7 +176,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Parameter Validation & Type Coercion for parameters passed in as a Hash..