hash_params 0.0.1

data/hash_params.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/hash_params', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'hash_params'
+  s.license     = 'MIT'
+  s.authors     = ['Tim Uckun']
+  s.email       = 'tim@uckun.com'
+  s.homepage    = 'https://github.com/timuckun/hash_params'
+  s.version     = HashParams::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.summary     = 'Parameter Validation & Type Coercion for parameters passed in as a Hash..'
+  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.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'minitest-spec'
+  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.rb

@@ -0,0 +1,157 @@
+class HashParams < Hash
+  VERSION = '0.0.1'
+  attr :valid, :errors
+
+  def self.ping
+    'ping'
+  end
+  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
+
+      # 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 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

data/spec/hash_params_spec.rb

@@ -0,0 +1,86 @@
+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}, 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
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+unless ENV['CI']
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter 'spec'
+    add_filter '.bundle'
+  end
+end
+
+require_relative '../lib/hash_params'
+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

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: hash_params
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tim Uckun
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+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
+email: tim@uckun.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "./Gemfile"
+- "./Gemfile.lock"
+- "./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/index.html"
+- "./hash_params.gemspec"
+- "./lib/hash_params.rb"
+- spec/hash_params_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/timuckun/hash_params
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Parameter Validation & Type Coercion for parameters passed in as a Hash..
+test_files:
+- spec/hash_params_spec.rb
+- spec/spec_helper.rb
+has_rdoc: