input_sanitizer 0.1.8

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+/bin

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--order random

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+script: bundle exec rspec spec
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-18mode
+  
+  # keeps failing
+  #- rbx-19mode

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in input_sanitizer.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Tomek Paczkowski, Tomasz Werbicki, Michal Bugno
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,70 @@
+# InputSanitizer [![Build Status](https://secure.travis-ci.org/futuresimple/input_sanitizer.png?branch=master)](http://travis-ci.org/futuresimple/input_sanitizer)
+
+Gem to sanitize hash of incoming data
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'input_sanitizer'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install input_sanitizer
+
+## Usage
+
+```ruby
+
+class PersonSanitizer < InputSanitizer::Sanitizer
+  string :name
+  string :address
+  integer :height
+  float :weight
+  date :birthday
+end
+
+# filters unwanted parameters
+sanitizer = PersonSanitizer.new({:account_id => 1, :name => "John"})
+sanitizer.cleaned() # => {:name => "John"}
+
+# provides key access
+sanitizer[:name] # => "John"
+
+# also provides shortcut method, same as new({}).cleaned
+PersonSanitizer.clean({:account_id => 1})
+
+# supports inheritance
+class PrivilegedSanitizer < PersonSanitizer
+  integer :account_id
+end
+
+PrivilegedSanitizer.clean({:account_id => 1})
+# => {:account_id => 1}
+
+# handles type conversions
+PrivilegedSanitizer.clean({:account_id => '1'})
+# => {:account_id => 1}
+
+PrivilegedSanitizer.clean({:birthday => '1986-10-06'})
+# => {:birthday => Date.new(1986, 10, 6)}
+
+# it prevents obvious errors
+data = PrivilegedSanitizer.clean({:account_id => 3})
+data[:account] # instead of :account_id
+# => InputSanitizer::KeyNotAllowedError: Key not allowed: account
+# => ...
+```
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/input_sanitizer.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'input_sanitizer/version'
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Tomek Paczkowski", "Tomasz Werbicki", "Michal Bugno"]
+  gem.email         = ["tom@futuresimple.com", "tomasz@futuresimple.com", "michal@futuresimple.com"]
+  gem.description   = %q{Gem to sanitize hash of incoming data}
+  gem.summary       = %q{Gem to sanitize hash of incoming data}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "input_sanitizer"
+  gem.require_paths = ["lib"]
+  gem.version       = InputSanitizer::VERSION
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "simplecov"
+end

data/lib/input_sanitizer/default_converters.rb

@@ -0,0 +1,81 @@
+require 'time'
+
+module InputSanitizer
+  class ConversionError < Exception
+  end
+
+  class IntegerConverter
+    def call(value)
+      cast = value.to_i
+      if cast.to_s != value.to_s
+        raise ConversionError.new("invalid integer")
+      end
+      cast
+    end
+  end
+
+  class StringConverter
+    def call(value)
+      value.to_s
+    end
+  end
+
+  class DateConverter
+    ISO_RE = /\A\d{4}-?\d{2}-?\d{2}/
+
+    def call(value)
+      raise ConversionError.new("invalid time") unless value =~ ISO_RE
+      Date.parse(value)
+    rescue ArgumentError
+      raise ConversionError.new("invalid iso8601 date")
+    end
+  end
+
+  class TimeConverter
+    ISO_RE = /\A\d{4}-?\d{2}-?\d{2}([T ]?\d{2}(:?\d{2}(:?\d{2})?)?)?\Z/
+
+    def call(value)
+      if value =~ ISO_RE
+        strip_timezone(Time.parse(value))
+      else
+        raise ConversionError.new("invalid time")
+      end
+    rescue ArgumentError
+      raise ConversionError.new("invalid time")
+    end
+
+    def strip_timezone(time)
+      Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec)
+    end
+  end
+
+  class BooleanConverter
+    BOOLEAN_MAP = {
+      true => true,
+      false => false,
+      'true' => true,
+      'false' => false,
+      '1' => true,
+      '0' => false,
+      'yes' => true,
+      'no' => false,
+    }
+
+    def call(value)
+      if BOOLEAN_MAP.has_key?(value)
+        BOOLEAN_MAP[value]
+      else
+        truthy, falsy = BOOLEAN_MAP.partition { |_, value| value }
+        truthy = truthy.map { |e| "'#{e[0]}'" }.uniq
+        falsy = falsy.map { |e| "'#{e[0]}'" }.uniq
+
+        message = "Invalid boolean: use "
+        message += truthy.join(", ")
+        message += " for true, or "
+        message += falsy.join(", ")
+        message += " for false."
+        raise ConversionError.new(message)
+      end
+    end
+  end
+end

data/lib/input_sanitizer/extended_converters.rb

@@ -0,0 +1,42 @@
+module InputSanitizer
+  class PositiveIntegerConverter < IntegerConverter
+    def call(value)
+      val = super
+      raise ConversionError.new("invalid integer (neagtive or zero)") if val <= 0
+      val
+    end
+  end
+
+  class CommaJoinedIntegersConverter
+    def call(value)
+      non_valid = value.gsub(/[0-9,]/, "")
+      if non_valid.empty?
+        parts = value.split(",").map(&:to_i)
+      else
+        invalid_chars = non_valid.split(//)
+        invalid_chars_desc = invalid_chars.join(", ")
+        raise InputSanitizer::ConversionError.new("Invalid chars: #{invalid_chars_desc}")
+      end
+    end
+  end
+
+  class SpecificValuesConverter
+    def initialize(values)
+      @valid_values = values
+    end
+
+    def call(value)
+      found = @valid_values.include?(value) ? value : nil
+      if !found
+        found = @valid_values.include?(value.to_sym) ? value.to_sym : nil
+      end
+      if !found
+        values_joined = @valid_values.join(", ")
+        error_message = "Possible values: #{values_joined}"
+        raise InputSanitizer::ConversionError.new(error_message)
+      else
+        found
+      end
+    end
+  end
+end

data/lib/input_sanitizer/restricted_hash.rb

@@ -0,0 +1,24 @@
+module InputSanitizer
+  class KeyNotAllowedError < ArgumentError; end
+
+  class RestrictedHash < Hash
+    def initialize(allowed_keys)
+      @allowed_keys = allowed_keys
+      super() { |hash, key| default_for_key(key) }
+    end
+
+    def key_allowed?(key)
+      @allowed_keys.include?(key)
+    end
+
+    private
+    def default_for_key(key)
+      key_allowed?(key) ? nil : raise_not_allowed(key)
+    end
+
+    def raise_not_allowed(key)
+      msg = "Key not allowed: #{key}"
+      raise KeyNotAllowedError.new(msg)
+    end
+  end
+end

data/lib/input_sanitizer/sanitizer.rb

@@ -0,0 +1,147 @@
+require 'input_sanitizer/restricted_hash'
+require 'input_sanitizer/default_converters'
+
+class InputSanitizer::Sanitizer
+  def initialize(data)
+    @data = symbolize_keys(data)
+    @performed = false
+    @errors = []
+    @cleaned = InputSanitizer::RestrictedHash.new(self.class.fields.keys)
+  end
+
+  def self.clean(data)
+    new(data).cleaned
+  end
+
+  def [](field)
+    cleaned[field]
+  end
+
+  def cleaned
+    return @cleaned if @performed
+    self.class.fields.each do |field, hash|
+      type = hash[:type]
+      required = hash[:options][:required]
+      clean_field(field, type, required)
+    end
+    @performed = true
+    @cleaned.freeze
+  end
+
+  def valid?
+    cleaned
+    @errors.empty?
+  end
+
+  def errors
+    cleaned
+    @errors
+  end
+
+  def self.converters
+    {
+      :integer => InputSanitizer::IntegerConverter.new,
+      :string => InputSanitizer::StringConverter.new,
+      :date => InputSanitizer::DateConverter.new,
+      :time => InputSanitizer::TimeConverter.new,
+      :boolean => InputSanitizer::BooleanConverter.new,
+    }
+  end
+
+  def self.inherited(subclass)
+    subclass.fields = self.fields.dup
+  end
+
+  def self.string(*keys)
+    set_keys_to_type(keys, :string)
+  end
+
+  def self.integer(*keys)
+    set_keys_to_type(keys, :integer)
+  end
+
+  def self.boolean(*keys)
+    set_keys_to_type(keys, :boolean)
+  end
+
+  def self.date(*keys)
+    set_keys_to_type(keys, :date)
+  end
+
+  def self.time(*keys)
+    set_keys_to_type(keys, :time)
+  end
+
+  def self.custom(*keys)
+    options = keys.pop
+    converter = options.delete(:converter)
+    keys.push(options)
+    raise "You did not define a converter for a custom type" if converter == nil
+    self.set_keys_to_type(keys, converter)
+  end
+
+  protected
+  def self.fields
+    @fields ||= {}
+  end
+
+  def self.fields=(new_fields)
+    @fields = new_fields
+  end
+
+  private
+  def self.extract_options!(array)
+    array.last.is_a?(Hash) ? array.pop : {}
+  end
+
+  def self.extract_options(array)
+    array.last.is_a?(Hash) ? array.last : {}
+  end
+
+  def clean_field(field, type, required)
+    if @data.has_key?(field)
+      begin
+        @cleaned[field] = convert(field, type)
+      rescue InputSanitizer::ConversionError => ex
+        add_error(field, :invalid_value, @data[field], ex.message)
+      end
+    elsif required
+      add_missing(field)
+    end
+  end
+
+  def add_error(field, error_type, value, description = nil)
+    @errors << {
+      :field => field,
+      :type => error_type,
+      :value => value,
+      :description => description
+    }
+  end
+
+  def add_missing(field)
+    add_error(field, :missing, nil, nil)
+  end
+
+  def convert(field, type)
+    converter(type).call(@data[field])
+  end
+
+  def converter(type)
+    type.respond_to?(:call) ? type : self.class.converters[type]
+  end
+
+  def symbolize_keys(data)
+    data.inject({}) do |memo, kv|
+      memo[kv.first.to_sym] = kv.last
+      memo
+    end
+  end
+
+  def self.set_keys_to_type(keys, type)
+    opts = extract_options!(keys)
+    keys.each do |key|
+      fields[key] = { :type => type, :options => opts }
+    end
+  end
+end

data/lib/input_sanitizer/version.rb

@@ -0,0 +1,3 @@
+module InputSanitizer
+  VERSION = "0.1.8"
+end

data/lib/input_sanitizer.rb

@@ -0,0 +1,5 @@
+module InputSanitizer
+end
+
+require "input_sanitizer/version"
+require 'input_sanitizer/sanitizer'

data/spec/default_converters_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe InputSanitizer::IntegerConverter do
+  let(:converter) { InputSanitizer::IntegerConverter.new }
+
+  it "casts string to integer" do
+    converter.call("42").should == 42
+  end
+
+  it "casts integer to integer" do
+    converter.call(42).should == 42
+  end
+
+  it "raises error if cannot cast" do
+    lambda { converter.call("f") }.should raise_error(InputSanitizer::ConversionError)
+  end
+end
+
+describe InputSanitizer::DateConverter do
+  let(:converter) { InputSanitizer::DateConverter.new }
+
+  it "casts dates in iso format" do
+    converter.call("2012-05-15").should == Date.new(2012, 5, 15)
+  end
+
+  it "raises error if cannot cast" do
+    lambda { converter.call("2012-02-30") }.should raise_error(InputSanitizer::ConversionError)
+  end
+end
+
+describe InputSanitizer::BooleanConverter do
+  let(:converter) { InputSanitizer::BooleanConverter.new }
+
+  it "casts 'true' to true" do
+    converter.call('true').should be_true
+  end
+
+  it "casts true to true" do
+    converter.call(true).should be_true
+  end
+
+  it "casts '1' to true" do
+    converter.call('1').should be_true
+  end
+
+  it "casts 'yes' to true" do
+    converter.call('yes').should be_true
+  end
+
+  it "casts 'false' to false" do
+    converter.call('false').should be_false
+  end
+
+  it "casts false to false" do
+    converter.call(false).should be_false
+  end
+
+  it "casts '0' to false" do
+    converter.call('0').should be_false
+  end
+
+  it "casts 'no' to false" do
+    converter.call('no').should be_false
+  end
+
+  it "raises error if cannot cast" do
+    lambda { converter.call("notboolean") }.should raise_error(InputSanitizer::ConversionError)
+  end
+end
+
+
+describe InputSanitizer::TimeConverter do
+  let(:converter) { InputSanitizer::TimeConverter.new }
+
+  it "raises if timezone part given" do
+    lambda { converter.call("2012-05-15 13:42:54 +01:00") }.should raise_error(InputSanitizer::ConversionError)
+  end
+
+  it "casts date time in iso format" do
+    t = Time.utc(2012, 5, 15, 13, 42, 54)
+    converter.call("2012-05-15 13:42:54").should == t
+    converter.call("2012-05-15T13:42:54").should == t
+    converter.call("20120515134254").should == t
+
+  end
+
+  it "does not require time part" do
+    converter.call("2012-05-15 13:42").should == Time.utc(2012, 5, 15, 13, 42)
+    converter.call("2012-05-15 13").should == Time.utc(2012, 5, 15, 13)
+    converter.call("2012-05-15").should == Time.utc(2012, 5, 15)
+
+  end
+
+  it "raises error if can format is wrong" do
+    lambda { converter.call("2/10/2031 13:44:22") }.should raise_error(InputSanitizer::ConversionError)
+  end
+
+  it "raises error if date is wrong" do
+    lambda { converter.call("2012-02-32") }.should raise_error(InputSanitizer::ConversionError)
+  end
+end

data/spec/extended_converters_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'input_sanitizer/extended_converters'
+
+describe InputSanitizer::PositiveIntegerConverter do
+  let(:converter) { InputSanitizer::PositiveIntegerConverter.new }
+
+  it "raises error if integer less than zero" do
+    lambda { converter.call("-3") }.should raise_error(InputSanitizer::ConversionError)
+  end
+
+  it "raises error if integer equals zero" do
+    lambda { converter.call("0") }.should raise_error(InputSanitizer::ConversionError)
+  end
+end
+
+describe InputSanitizer::CommaJoinedIntegersConverter do
+  let(:converter) { InputSanitizer::CommaJoinedIntegersConverter.new }
+
+  it "parses to array of ids" do
+    converter.call("1,2,3,5").should == [1, 2, 3, 5]
+  end
+
+  it "raises on invalid character" do
+    lambda { converter.call(":") }.should raise_error(InputSanitizer::ConversionError)
+  end
+end
+
+describe InputSanitizer::SpecificValuesConverter do
+  let(:converter) { InputSanitizer::SpecificValuesConverter.new([:a, :b]) }
+
+  it "converts valid value to symbol" do
+    converter.call("b").should == :b
+  end
+
+  it "raises on invalid value" do
+    lambda { converter.call("c") }.should raise_error(InputSanitizer::ConversionError)
+  end
+
+  it "converts valid value to string" do
+    converter = InputSanitizer::SpecificValuesConverter.new(["a", "b"])
+    converter.call("a").should == "a"
+  end
+end

data/spec/restricted_hash_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe InputSanitizer::RestrictedHash do
+  let(:hash) { InputSanitizer::RestrictedHash.new([:a, :b]) }
+  subject { hash }
+
+  it "does not allow bad keys" do
+    lambda{hash[:c]}.should raise_error(InputSanitizer::KeyNotAllowedError)
+  end
+
+  it "does allow correct keys" do
+    hash[:a].should be_nil
+  end
+
+  it "returns value for correct key" do
+    hash[:a] = 'stuff'
+    hash[:a].should == 'stuff'
+  end
+end

data/spec/sanitizer_spec.rb

@@ -0,0 +1,237 @@
+require 'spec_helper'
+
+class BasicSanitizer < InputSanitizer::Sanitizer
+  string :x, :y, :z
+  integer :num
+  date :birthday
+  time :updated_at
+  custom :cust1, :cust2, :converter => lambda { |v| v.reverse }
+end
+
+class BrokenCustomSanitizer < InputSanitizer::Sanitizer
+
+end
+
+class ExtendedSanitizer < BasicSanitizer
+  boolean :is_nice
+end
+
+class OverridingSanitizer < BasicSanitizer
+  integer :is_nice
+end
+
+class RequiredParameters < BasicSanitizer
+  integer :is_nice, :required => true
+end
+
+class RequiredCustom < BasicSanitizer
+  custom :c1, :required => true, :converter => lambda { |v| v }
+end
+
+describe InputSanitizer::Sanitizer do
+  let(:sanitizer) { BasicSanitizer.new(@params) }
+
+  describe ".clean" do
+    it "returns cleaned data" do
+      clean_data = mock()
+      BasicSanitizer.any_instance.should_receive(:cleaned).and_return(clean_data)
+      BasicSanitizer.clean({}).should be(clean_data)
+    end
+  end
+
+  describe "#cleaned" do
+    let(:cleaned) { sanitizer.cleaned }
+    let(:required) { RequiredParameters.new(@params) }
+
+    it "includes specified params" do
+      @params = {"x" => 3, "y" => "tom", "z" => "mike"}
+
+      cleaned.should have_key(:x)
+      cleaned.should have_key(:y)
+      cleaned.should have_key(:z)
+    end
+
+    it "strips not specified params" do
+      @params = {"d" => 3}
+
+      cleaned.should_not have_key(:d)
+    end
+
+    it "freezes cleaned hash" do
+      @params = {}
+
+      cleaned.should be_frozen
+    end
+
+    it "uses RestrictedHash" do
+      @params = {}
+
+      lambda{cleaned[:does_not_exist]}.should raise_error(InputSanitizer::KeyNotAllowedError)
+    end
+
+    it "includes specified keys and strips rest" do
+      @params = {"d" => 3, "x" => "ddd"}
+
+      cleaned.should have_key(:x)
+      cleaned.should_not have_key(:d)
+    end
+
+    it "works with symbols as input keys" do
+      @params = {:d => 3, :x => "ddd"}
+
+      cleaned.should have_key(:x)
+      cleaned.should_not have_key(:d)
+    end
+
+    it "silently discards cast errors" do
+      @params = {:num => "f"}
+
+      cleaned.should_not have_key(:num)
+    end
+
+    it "inherits converters from superclass" do
+      sanitizer = ExtendedSanitizer.new({:num => "23", :is_nice => 'false'})
+      cleaned = sanitizer.cleaned
+
+      cleaned.should have_key(:num)
+      cleaned[:num].should == 23
+      cleaned[:is_nice].should be_false
+    end
+
+    it "overrides inherited fields" do
+      sanitizer = OverridingSanitizer.new({:is_nice => "42"})
+      cleaned = sanitizer.cleaned
+
+      cleaned.should have_key(:is_nice)
+      cleaned[:is_nice].should == 42
+    end
+
+  end
+
+  describe ".custom" do
+    let(:sanitizer) { BasicSanitizer.new(@params) }
+    let(:cleaned) { sanitizer.cleaned }
+
+    it "converts using custom converter" do
+      @params = {:cust1 => "cigam"}
+
+      cleaned.should have_key(:cust1)
+      cleaned[:cust1].should == "magic"
+    end
+
+    it "raises an error when converter is not defined" do
+      expect do
+        BrokenCustomSanitizer.custom(:x)
+      end.should raise_error
+    end
+  end
+
+  describe ".converters" do
+    let(:sanitizer) { InputSanitizer::Sanitizer }
+
+    it "includes :integer type" do
+      sanitizer.converters.should have_key(:integer)
+      sanitizer.converters[:integer].should be_a(InputSanitizer::IntegerConverter)
+    end
+
+    it "includes :string type" do
+      sanitizer.converters.should have_key(:string)
+      sanitizer.converters[:string].should be_a(InputSanitizer::StringConverter)
+    end
+
+    it "includes :date type" do
+      sanitizer.converters.should have_key(:date)
+      sanitizer.converters[:date].should be_a(InputSanitizer::DateConverter)
+    end
+
+    it "includes :boolean type" do
+      sanitizer.converters.should have_key(:boolean)
+      sanitizer.converters[:boolean].should be_a(InputSanitizer::BooleanConverter)
+    end
+  end
+
+  describe '.extract_options' do
+
+    it "extracts hash from array if is last" do
+      options = { :a => 1}
+      array = [1,2, options]
+      BasicSanitizer.extract_options(array).should == options
+      array.should == [1,2, options]
+    end
+
+    it "does not extract the last element if not a hash and returns default empty hash" do
+      array = [1,2]
+      BasicSanitizer.extract_options(array).should_not == 2
+      BasicSanitizer.extract_options(array).should == {}
+      array.should == [1,2]
+    end
+
+  end
+
+  describe '.extract_options!' do
+
+    it "extracts hash from array if is last" do
+      options = { :a => 1}
+      array = [1,2, options]
+      BasicSanitizer.extract_options!(array).should == options
+      array.should == [1,2]
+    end
+
+    it "leaves other arrays alone" do
+      array = [1,2]
+      BasicSanitizer.extract_options!(array).should == {}
+      array.should == [1,2]
+    end
+
+  end
+
+  describe "#valid?" do
+    it "is valid when params are ok" do
+      @params = {:num => "3"}
+
+      sanitizer.should be_valid
+    end
+
+    it "is not valid when missing params" do
+      @params = {:num => "mike"}
+
+      sanitizer.should_not be_valid
+    end
+  end
+
+  describe "#[]" do
+    it "accesses cleaned data" do
+      @params = {:num => "3"}
+
+      sanitizer[:num].should == 3
+    end
+  end
+
+  describe "#errors" do
+    it "returns array containing hashes describing error" do
+      @params = {:num => "mike"}
+
+      errors = sanitizer.errors
+      errors.size.should == 1
+      errors[0][:field].should == :num
+      errors[0][:type].should == :invalid_value
+      errors[0][:description].should == "invalid integer"
+      errors[0][:value].should == "mike"
+    end
+
+    it "returns error type missing if value is missing" do
+      sanitizer = RequiredParameters.new({})
+      error = sanitizer.errors[0]
+      error[:type].should == :missing
+    end
+
+    it "handles required custom params" do
+      sanitizer = RequiredCustom.new({})
+
+      sanitizer.should_not be_valid
+      error = sanitizer.errors[0]
+      error[:type].should == :missing
+      error[:field].should == :c1
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler.setup(:test)
+
+require 'simplecov'
+SimpleCov.start unless ENV['CI'] == 'true'
+
+require 'input_sanitizer'

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: input_sanitizer
+version: !ruby/object:Gem::Version
+  version: 0.1.8
+  prerelease: 
+platform: ruby
+authors:
+- Tomek Paczkowski
+- Tomasz Werbicki
+- Michal Bugno
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Gem to sanitize hash of incoming data
+email:
+- tom@futuresimple.com
+- tomasz@futuresimple.com
+- michal@futuresimple.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- input_sanitizer.gemspec
+- lib/input_sanitizer.rb
+- lib/input_sanitizer/default_converters.rb
+- lib/input_sanitizer/extended_converters.rb
+- lib/input_sanitizer/restricted_hash.rb
+- lib/input_sanitizer/sanitizer.rb
+- lib/input_sanitizer/version.rb
+- spec/default_converters_spec.rb
+- spec/extended_converters_spec.rb
+- spec/restricted_hash_spec.rb
+- spec/sanitizer_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Gem to sanitize hash of incoming data
+test_files:
+- spec/default_converters_spec.rb
+- spec/extended_converters_spec.rb
+- spec/restricted_hash_spec.rb
+- spec/sanitizer_spec.rb
+- spec/spec_helper.rb
+has_rdoc: