hash_params 0.0.2 → 2.0.0

data/hash_params.gemspec

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../lib/hash_params', __FILE__)
+require  File.dirname(__FILE__) + '/lib/hash_params'
 
 Gem::Specification.new do |s|
   s.name        = 'hash_params'
@@ -13,6 +13,17 @@ Gem::Specification.new do |s|
   s.description = 'hash-param allows you to declare, validate, and transform endpoint parameters as you would in frameworks like ActiveModel or DataMapper without the overhead.
                   This gem is a variation of the sinatra-param gem https://github.com/mattt/sinatra-param modified to be more generic and with some additional features'
 
+  s.files         = Dir["./**/*"].reject { |file| file =~ /\.\/(bin|log|pkg|script|spec|test|vendor)/ }
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # gem.require_paths = ['lib']
+  # gem.files         = %w(.yardopts CHANGELOG.md CONTRIBUTING.md LICENSE README.md UPGRADING.md Rakefile hashie.gemspec)
+  # gem.files         += Dir['lib/**/*.rb']
+  # gem.files         += Dir['spec/**/*.rb']
+  # gem.test_files    = Dir['spec/**/*.rb']
+
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'minitest'
@@ -20,8 +31,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'simplecov'
   s.add_development_dependency 'pry'
 
-  s.files         = Dir["./**/*"].reject { |file| file =~ /\.\/(bin|log|pkg|script|spec|test|vendor)/ }
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+
+
 end

data/lib/hash_params/binding_validator.rb

@@ -0,0 +1,26 @@
+module HashParams
+  class BindingValidator
+
+    def with_binding (&code)
+      @binding = code.binding
+      instance_eval(&code)
+    end
+
+
+    def var(var_name, type, opts={})
+      raise 'Variable name must be a string or symbol' unless (var_name.is_a?(String) || var_name.is_a?(Symbol))
+      value    = @binding.local_variable_get var_name
+      new_value = if value.is_a?(Hash)
+                    if block_given?
+                      #if the param is a hash then the validations are actually options
+                      HashParams::HashValidator.new.validate_hash(value, opts, &Proc.new)
+                    else
+                      HashParams::HashValidator.new.validate_hash(value, opts)
+                    end
+                  else
+                    HashParams.validate value, type,  opts
+                  end
+      @binding.local_variable_set var_name, new_value
+    end
+  end
+end

data/lib/hash_params/hash_validator.rb

@@ -0,0 +1,71 @@
+module HashParams
+
+
+  class HPHash < Hash
+    attr_accessor :validation_errors
+
+    def initialize(args=nil)
+      @validation_errors=[]
+      super(args)
+    end
+
+    def valid?
+      @validation_errors.empty?
+    end
+
+    def set_key_value(key, value, symbolize_key, make_method)
+      key = key.to_s.to_sym if symbolize_key
+      if make_method
+        singleton_class.module_eval do
+          define_method key.to_s.to_sym do
+            value
+          end
+        end
+      end
+      self[key]=value
+    end
+  end
+
+  class HashValidator
+
+    def validate_hash(h, options={})
+      #Hash Validation has to be stateful
+
+      @incoming = h
+      @outgoing = HPHash.new
+      @options  = options
+
+      if block_given?
+        instance_eval(&Proc.new)
+      else
+        #no proc was given this means just pass the hash back as is
+        @outgoing = @incoming
+      end
+      @outgoing
+    end
+
+    def key(hash_key, type, opts={})
+      value     = @incoming[hash_key] || @incoming[hash_key.to_s]
+      # if a block is given to the param then it's a recursive call
+      # recursive calls can only be done with a hash
+      new_value = if value.is_a?(Hash)
+                    if block_given?
+                      #if the param is a hash then the validations are actually options
+                      HashParams::HashValidator.new.validate_hash(value, @options, &Proc.new)
+                    else
+                      HashParams::HashValidator.new.validate_hash(value, opts)
+                    end
+                  else
+                    HashParams.validate value, type, opts
+                  end
+      hash_key  = opts[:as] if opts[:as]
+      @outgoing.set_key_value(hash_key, new_value, @options[:symbolize_keys], @options[:make_methods])
+      new_value
+    rescue => e
+      @outgoing.validation_errors << "Error processing key '#{hash_key}': #{e}" # [e.to_s, e.backtrace].join("\n")
+      raise e if @options[:raise_errors]
+      nil
+    end
+    alias_method :param, :key
+  end
+end

data/lib/hash_params/validator.rb

@@ -0,0 +1,119 @@
+module HashParams
+  module Validator
+
+    class ValidationError < StandardError
+    end
+
+    class CoercionError < StandardError
+    end
+
+    def with_binding(&code)
+      BindingValidator.new.with_binding(&code)
+    end
+
+    def validate(param, type, validations={})
+
+      coercions = Array(validations[:coerce]) << type
+
+      if param.nil? && validations[:default]
+        param = validations[:default].respond_to?(:call) ? validations[:default].call() : validations[:default]
+      end
+
+      #if there is a :validate lambda run that too
+      if validations[:validate] && validations[:validate].respond_to?(:call)
+        param = validations.delete(:validate).call(param)
+      end
+
+      if block_given? && !param.is_a?(Hash)
+        param = yield(param, validations)
+      end
+
+      #  do all coercion and transformation first there could be an array of coersions they will be run in order
+      coercions.each do |c|
+        param = coerce(param, c, validations)
+      end
+
+      if param.is_a?(Hash)
+        param = if block_given?
+                  HashParams::HashValidator.new.validate_hash(param, validations, &Proc.new)
+                else
+                  HashParams::HashValidator.new.validate_hash(param, validations)
+                end
+      end
+
+      #don't bother with the rest if required parameter is missing
+      if validations[:required] && param.nil?
+        raise ValidationError.new('Required Parameter missing and has no default specified')
+      end
+
+      error = nil
+      validations.each do |key, value|
+        error = case key
+                  when :blank
+                    'Parameter cannot be blank' if !value && (param.nil? || (param.respond_to?(:empty) && param.empty)) #)!value && blank?(value)
+                  when :format
+                    "#{param} must be a string if using the format validation" && next unless param.kind_of?(String)
+                    "#{param} must match format #{value}" unless param =~ value
+                  when :is
+                    "#{param} must be #{value}" unless param === value
+                  when :in, :within, :range
+                    "#{param} must be within #{value}" unless value.respond_to?(:include) ? value.include?(param) : Array(value).include?(param)
+                  when :min
+                    "#{param} cannot be less than #{value}" unless value <= param
+                  when :max
+                    "#{param} cannot be greater than #{value}" unless value >= param
+                  when :min_length
+                    "#{param} cannot have length less than #{value}" unless value <= param.length
+                  when :max_length
+                    "#{param} cannot have length greater than #{value}" unless value >= param.length
+                  else
+                    nil
+                end
+      end
+
+      raise ValidationError.new(error) if error
+      param
+    end
+
+    private
+
+    def coerce(val, type, opts={})
+
+      # exceptions bubble up
+      #order is important
+
+      #if type is nil just return the object
+      return val if type.nil?
+
+      #two special types of transforms
+      #There is no Boolean type so we handle them special
+      if type.to_s == '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?
+        raise CoercionError.new("Unable to coerce #{val} to boolean")
+      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(opts[:delimiter] || ',')) if type == Array
+      return Hash[val.gsub(/[{}]/, '').gsub('}', '').split(opts[:delimiter] || ',').map { |c| c.split(opts[:separator] ||':').map { |i| i.strip } }] if type == Hash
+
+      raise CoercionError("Unable to  coerce #{val} to #{type}")
+    end
+  end
+end

data/lib/hash_params/yaml_params.rb

@@ -0,0 +1,93 @@
+module YamlParams
+
+  ENVIRONMENT = ENV['YAML_PARAMS_ENV'] || (defined?(HashParams) && HashParams::ENVIRONMENT) || 'development'
+
+  def self.autoconfig(opts={})
+
+    script_name        = File.basename($0)
+    script_dir         = File.dirname($0)
+    home_dir           = File.expand_path('~')
+    host_name          = Socket.gethostname
+    special_file_names = opts.delete(:files)
+    special_file_names = Array(special_file_names && special_file_names.is_a?(String) && special_file_names.split(','))
+    special_roots      = opts.delete(:roots)
+    special_roots      = Array(special_roots && special_roots.is_a?(String) && special_roots.split(','))
+    app_name           = opts.delete(:app_name) || script_name
+    env                = opts.delete(:env) || opts.delete(:environment) || ENVIRONMENT
+    generated_hash     = {}
+    all_file_names     = []
+
+
+    #Sequence is important when constructing this list as later files will override the earlier ones
+    generic_file_names = %W(
+                  settings.yml
+                  config.yml
+                   default.yml
+                  #{env}.yml
+                  #{host_name}.yml
+                  #{host_name}_#{env}.yml
+                  local.yml
+                  local_#{env}.yml
+                  settings.local.yml
+                  settings.local_#{env}.yml
+                  config.local.yml
+                  config.local_#{env}.yml
+    )
+    #prepend the app name to the default file names
+    app_file_names     = generic_file_names.map { |f| "#{app_name}_#{f}" }
+
+    default_roots = [
+        script_dir,
+        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(script_dir, 'config'),
+        File.join(script_dir, 'settings')
+    ]
+    if defined?(Rails)
+      default_roots << Rails.root.join('config')
+    end
+
+
+    #process the  /etc/app_name* files
+    app_file_names.each do |fname|
+      all_file_names << File.join('/etc', fname)
+    end
+    #now process the default roots which will override the above
+    (default_roots + special_roots).each do |root|
+      (generic_file_names + app_file_names + special_file_names).each do |fname|
+        all_file_names << File.join(root, fname)
+      end
+    end
+
+    all_file_names.each do |file|
+      generated_hash = deep_merge(generated_hash, hash_from_yaml_file(file)) if File.exists?(file)
+    end
+
+    if block_given?
+      HashParams::HashValidator.new.validate_hash(generated_hash, opts, &Proc.new)
+    else
+      HashParams::HashValidator.new.validate_hash(generated_hash, opts)
+    end
+  end
+
+  def self.hash_from_yaml_file(filename, env=nil)
+    env ||= ENVIRONMENT
+    r   = File.exists?(filename) ? YAML::load(ERB.new(File.read(filename)).result) : {}
+    r[env] || r
+  end
+
+  def self.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

data/lib/hash_params.rb

@@ -1,148 +1,21 @@
-class HashParams < Hash
-  VERSION = '0.0.2'
-  attr :valid, :errors
-
-  def initialize(opts={}, injection_target =nil, &code)
-    @incoming_hash   = opts
-    @errors =[]
-    # @parent                = code.binding.eval 'self'
-    @target =injection_target
-    instance_eval(&code)
-    @valid = (@errors.size == 0)
-  end
-
-  def param(key, h = {})
-
-    #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
-    return @errors << "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|
-      val = coerce(val, c, h)
-    end
-
-    #coersion could return a nil which won't validate, it could return a false which will attempt to validate
-    if  validate!(val, h)
-      #The value is valid add it
-      var_name      = h[:as] ? h[:as] : key
-      self[var_name]=val
-      inject_into_target(@target, var_name, val)
-    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, nil, &Proc.new)
-    end
-
-    val
-  rescue => e
-    @errors << e.to_s
-  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 validate!(param, options ={})
-    return false if param.nil?
-    is_valid = true
-
-    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
-    is_valid
-  end
-
-
-  def 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
+require 'yaml'
+require 'erb'
+require 'socket'
+
+require_relative 'hash_params/hash_validator'
+require_relative 'hash_params/validator'
+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.0'
+  extend HashParams::Validator
+end
 
-      # 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
+require_relative 'hash_params/yaml_params'
+require 'pry' if HashParams::ENVIRONMENT == 'development'
 
-    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 valid?
-    @valid
-  end
-  def present?(object)
-    !blank?(object)
-  end
 
-  def blank?(object)
-    return true if object.nil?
-    return true if object.respond_to?(:empty) && object.empty
-    return false
-  end
-end