focuslight-validator 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 030827b98f945a997ab1cb763a7eb06eccc056e8
+  data.tar.gz: f82194c2a9738884198a68b2c903a0303f3f5bb9
+SHA512:
+  metadata.gz: 1723f550b4a205fd30f46af70832b638a276d7e0d1b60cf6fd648e454ef9d5276c945ffc4c5e9b9ba9090d6c9e3eda5457f145d639f651478451364d43e19ebd
+  data.tar.gz: 6164367cc18db7cfec3b0fc7e82b130e757060f253f0c0e8e2b9e24c7f3596f220c4c7b6e5f45105a93bd797331857eb71a20dc95c2d477ecd0d65274c0be6b8

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 TAGOMORI Satoshi
+
+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,73 @@
+# Focuslight::Validator
+
+Validate http request parameters (or others) by defined rule, without models.
+
+SYNOPSIS:
+
+    require 'focuslight-validator'
+    
+    result = Validator.validate(params, {
+      :request_param_key_name => { # single key, single value
+        :default => default_value,
+        :rule => [
+          Validator.rule(:not_null),
+          Validator.rule(:int_range, 0..10),
+        ],
+      },
+      :array_value_key_name => { # single key, array value
+        :array => true
+        :size => 1..10 # default is unlimited (empty also allowed)
+        # default cannot be used
+        :rule => [ ... ]
+      }
+      # ...
+      [:param1, :param2, :param3] => { # rule for combination of 2 or more params
+        # default cannot be used
+        :rule => Validator::Rule.new(->(p1, p2, p3){ ... }, "error_message")
+      },
+    }
+    
+    result.has_error? #=> true/false
+    result.errors #=> Hash( { param_name => "error message" } )
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'focuslight-validator'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install focuslight-validator
+
+## Usage
+
+TBD: default/array/size/rule
+
+### Available built-in rules
+
+TBD
+
+### Lambda rule
+
+TBD
+
+### Array value validation
+
+TBD
+
+### Combination validation
+
+TBD
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/focuslight-validator/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/focuslight-validator.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'focuslight/validator/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "focuslight-validator"
+  spec.version       = Focuslight::Validator::VERSION
+  spec.authors       = ["TAGOMORI Satoshi"]
+  spec.email         = ["tagomoris@gmail.com"]
+  spec.summary       = %q{Validate http request parameters (or others) by defined rule, without models.}
+  # spec.description   = %q{TODO: Write a longer description. Optional.}
+  spec.homepage      = "https://github.com/focuslight/focuslight-validator"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/focuslight-validator.rb

@@ -0,0 +1 @@
+require "focuslight/validator"

data/lib/focuslight/validator.rb

@@ -0,0 +1,149 @@
+require "focuslight/validator/version"
+require "focuslight/validator/rule"
+require "focuslight/validator/result"
+
+module Focuslight
+  module Validator
+    def self.validate(params, spec)
+      result = Result.new
+      spec.each do |key, specitem|
+        if key.is_a?(Array)
+          validate_multi_key(result, params, key, specitem)
+        elsif specitem[:array]
+          validate_array(result, params, key, specitem)
+        else
+          validate_single(result, params, key, specitem)
+        end
+      end
+      result
+    end
+
+    def self.validate_single(result, params, key_arg, spec)
+      key = key_arg.to_sym
+
+      value = params[key]
+      if spec.has_key?(:default) && value.nil?
+        value = spec[:default]
+      end
+      if spec[:excludable] && value.nil?
+        result[key] = nil
+        return
+      end
+
+      rules = [spec[:rule]].flatten.compact
+
+      errors = []
+      valid = true
+      formatted = value
+
+      rules.each do |rule|
+        if rule.check(value)
+          formatted = rule.format(value)
+        else
+          result.error(key, rule.message)
+          valid = false
+        end
+      end
+
+      if valid
+        result[key] = formatted
+      end
+    end
+
+    def self.validate_array(result, params, key_arg, spec)
+      key = key_arg.to_sym
+
+      values = params[key]
+      if spec.has_key?(:default)
+        raise ArgumentError, "array parameter cannot have :default"
+      end
+      if spec[:excludable] && value.nil?
+        result[key] = []
+      end
+
+      if spec.has_key?(:size)
+        if (values.nil? || values.size == 0) && !spec[:size].include?(0)
+          result.error(key, "not allowed for empty")
+          return
+        end
+        if !spec[:size].include?(values.size)
+          result.error(key, "doesn't have values specified: #{spec[:size]}")
+          return
+        end
+      end
+
+      unless values.is_a?(Array)
+        values = [values]
+      end
+
+      rules = [spec[:rule]].flatten.compact
+
+      error_values = []
+      valid = true
+      formatted_values = []
+
+      values.each do |value|
+        errors = []
+        formatted = nil
+        rules.each do |rule|
+          if rule.check(value)
+            formatted = rule.format(value)
+          else
+            result.error(key, rule.message)
+            valid = false
+          end
+        end
+        error_values += errors
+        formatted_values.push(formatted) if formatted
+      end
+
+      if valid
+        result[key] = formatted_values
+      end
+    end
+
+    def self.validate_multi_key(result, params, keys, spec)
+      values = keys.map{|key| params[key.to_sym]}
+      if spec.has_key?(:default)
+        raise ArgumentError, "multi key validation spec cannot have :default"
+      end
+
+      rules = [spec[:rule]].flatten.compact
+      errors = []
+
+      rules.each do |rule|
+        unless rule.check(*values)
+          result.error(keys.map{|s| s.to_s}.join(','), rule.message)
+        end
+      end
+    end
+
+    def self.rule(type, *args)
+      args.flatten!
+      case type
+      when :not_blank
+        Rule.new(->(v){not v.nil? and not v.strip.empty?}, "missing or blank", :strip)
+      when :choice
+        Rule.new(->(v){args.include?(v)}, "invalid value")
+      when :int
+        Rule.new(->(v){v =~ /^-?\d+$/}, "invalid integer", :to_i)
+      when :uint
+        Rule.new(->(v){v =~ /^\d+$/}, "invalid integer (>= 0)", :to_i)
+      when :natural
+        Rule.new(->(v){v =~ /^\d+$/ && v.to_i >= 1}, "invalid integer (>= 1)", :to_i)
+      when :float, :double, :real
+        Rule.new(->(v){v =~ /^\-?(\d+\.?\d*|\.\d+)(e[+-]\d+)?$/}, "invalid floating point num", :to_f)
+      when :int_range
+        Rule.new(->(v){args.first.include?(v.to_i)}, "invalid number in range #{args.first}", :to_i)
+      when :bool
+        Rule.new(->(v){v =~ /^(0|1|true|false)$/i}, "invalid bool value", ->(v){!!(v =~ /^(1|true)$/i)})
+      when :regexp
+        Rule.new(->(v){v =~ args.first}, "invalid input for pattern #{args.first.source}")
+      when :lambda
+        Rule.new(*args)
+      else
+        raise ArgumentError, "unknown validator rule: #{type}"
+      end
+    end
+  end
+end

data/lib/focuslight/validator/result.rb

@@ -0,0 +1,32 @@
+module Focuslight
+  module Validator
+    class Result
+      attr_reader :errors
+
+      def initialize
+        @errors = {}
+        @params = {}
+      end
+
+      def hash
+        @params.dup
+      end
+
+      def [](name)
+        @params[name.to_sym]
+      end
+
+      def []=(name, value)
+        @params[name.to_sym] = value
+      end
+
+      def error(param, message)
+        @errors[param.to_sym] = "#{param}: " + message
+      end
+
+      def has_error?
+        not @errors.empty?
+      end
+    end
+  end
+end

data/lib/focuslight/validator/rule.rb

@@ -0,0 +1,27 @@
+module Focuslight
+  module Validator
+    class Rule
+      attr_reader :message
+
+      def initialize(checker, invalid_message, formatter=nil)
+        @checker = checker
+        @message = invalid_message
+        @formatter = formatter
+      end
+
+      def check(*values)
+        @checker.(*values)
+      end
+
+      def format(value)
+        if @formatter && @formatter.is_a?(Symbol)
+          value.send(@formatter)
+        elsif @formatter
+          @formatter.(value)
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/focuslight/validator/version.rb

@@ -0,0 +1,5 @@
+module Focuslight
+  module Validator
+    VERSION = "0.0.1"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'rspec'
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')

data/spec/syntax_spec.rb

@@ -0,0 +1,9 @@
+require_relative './spec_helper'
+
+describe Focuslight do
+  it 'has modules that passes syntax check' do
+    Dir.glob(__dir__ + '/../lib/**/*.rb').each do |file|
+      require file
+    end
+  end
+end

data/spec/validator_predefined_rules_spec.rb

@@ -0,0 +1,177 @@
+require_relative './spec_helper'
+
+require 'focuslight/validator'
+
+describe Focuslight::Validator do
+  describe '.rule' do
+    it 'returns not_blank predefined rule' do
+      r = Focuslight::Validator.rule(:not_blank)
+      expect(r.check(nil)).to be_false
+      expect(r.check("")).to be_false
+      expect(r.check(" ")).to be_false
+      expect(r.check("a")).to be_true
+
+      expect(r.format("a")).to eql("a")
+      expect(r.format(" a ")).to eql("a")
+
+      expect(r.message).to eql("missing or blank")
+    end
+
+    it 'returns choice predefined rule' do
+      r1 = Focuslight::Validator.rule(:choice, "x", "y", "z")
+      expect(r1.check("a")).to be_false
+      expect(r1.check("x")).to be_true
+      expect(r1.check("z")).to be_true
+
+      expect(r1.format("x")).to eql("x")
+
+      expect(r1.message).to eql("invalid value")
+
+      r2 = Focuslight::Validator.rule(:choice, ["x", "y", "z"])
+      expect(r2.check("a")).to be_false
+      expect(r2.check("x")).to be_true
+      expect(r2.check("z")).to be_true
+
+      expect(r2.format("x")).to eql("x")
+    end
+
+    it 'returns int predefined rule' do
+      r = Focuslight::Validator.rule(:int)
+      expect(r.check("0")).to be_true
+      expect(r.check("100")).to be_true
+      expect(r.check("-21")).to be_true
+      expect(r.check("1.0")).to be_false
+      expect(r.check("-3e10")).to be_false
+      expect(r.check("xyz")).to be_false
+
+      expect(r.format("0")).to eql(0)
+      expect(r.format("100")).to eql(100)
+      expect(r.format("-21")).to eql(-21)
+
+      expect(r.message).to eql("invalid integer")
+    end
+
+    it 'returns uint predefined rule' do
+      r = Focuslight::Validator.rule(:uint)
+      expect(r.check("0")).to be_true
+      expect(r.check("100")).to be_true
+      expect(r.check("-21")).to be_false
+      expect(r.check("1.0")).to be_false
+      expect(r.check("-3e10")).to be_false
+      expect(r.check("xyz")).to be_false
+
+      expect(r.format("0")).to eql(0)
+      expect(r.format("100")).to eql(100)
+
+      expect(r.message).to eql("invalid integer (>= 0)")
+    end
+
+    it 'returns natural predefined rule' do
+      r = Focuslight::Validator.rule(:natural)
+      expect(r.check("0")).to be_false
+      expect(r.check("100")).to be_true
+      expect(r.check("-21")).to be_false
+      expect(r.check("1.0")).to be_false
+      expect(r.check("-3e10")).to be_false
+      expect(r.check("xyz")).to be_false
+
+      expect(r.format("0")).to eql(0)
+      expect(r.format("100")).to eql(100)
+
+      expect(r.message).to eql("invalid integer (>= 1)")
+    end
+
+    it 'returns float/double/real predefined rule' do
+      r1 = Focuslight::Validator.rule(:float)
+      r2 = Focuslight::Validator.rule(:double)
+      r3 = Focuslight::Validator.rule(:real)
+      [r1, r2, r3].each do |r|
+        expect(r.check("0")).to be_true
+        expect(r.check("0.0")).to be_true
+        expect(r.check("1.0")).to be_true
+        expect(r.check("1e+10")).to be_true
+        expect(r.check("2e-10")).to be_true
+        expect(r.check("-2e-10")).to be_true
+        expect(r.check("e")).to be_false
+        expect(r.check("xyz")).to be_false
+        expect(r.check("")).to be_false
+
+        expect(r.format("0")).to eql(0.0)
+        expect(r.format("0.0")).to eql(0.0)
+        expect(r.format("1.0")).to eql(1.0)
+        expect(r.format("1e+10")).to eql(1e+10)
+        expect(r.format("2e-10")).to eql(2e-10)
+        expect(r.format("-2e-10")).to eql(-2e-10)
+
+        expect(r.message).to eql("invalid floating point num")
+      end
+    end
+
+    it 'returns int_range predefined rule' do
+      r1 = Focuslight::Validator.rule(:int_range, 0..3)
+      expect(r1.check("0")).to be_true
+      expect(r1.check("1")).to be_true
+      expect(r1.check("3")).to be_true
+      expect(r1.check("-1")).to be_false
+
+      expect(r1.format("0")).to eql(0)
+
+      expect(r1.message).to eql("invalid number in range 0..3")
+
+      r2 = Focuslight::Validator.rule(:int_range, 1..3)
+      expect(r2.check("0")).to be_false
+      expect(r2.check("1")).to be_true
+      expect(r2.check("3")).to be_true
+      expect(r2.check("-1")).to be_false
+
+      expect(r2.format("1")).to eql(1)
+
+      expect(r2.message).to eql("invalid number in range 1..3")
+    end
+
+    it 'returns bool predefined rule, which parse numeric 1/0 as true/false' do
+      r = Focuslight::Validator.rule(:bool)
+      expect(r.check("0")).to be_true
+      expect(r.check("1")).to be_true
+      expect(r.check("true")).to be_true
+      expect(r.check("True")).to be_true
+      expect(r.check("false")).to be_true
+      expect(r.check("nil")).to be_false
+      expect(r.check("maru")).to be_false
+      expect(r.check("")).to be_false
+
+      expect(r.format("0")).to equal(false)
+      expect(r.format("1")).to equal(true)
+      expect(r.format("true")).to equal(true)
+      expect(r.format("True")).to equal(true)
+      expect(r.format("false")).to equal(false)
+
+      expect(r.message).to eql("invalid bool value")
+    end
+
+    it 'return regexp predefined rule' do
+      r = Focuslight::Validator.rule(:regexp, /^[0-9a-f]{4}$/i)
+      expect(r.check("000")).to be_false
+      expect(r.check("0000")).to be_true
+      expect(r.check("00000")).to be_false
+      expect(r.check("a0a0")).to be_true
+      expect(r.check("FFFF")).to be_true
+
+      str = "FfFf"
+      expect(r.format(str)).to equal(str)
+
+      expect(r.message).to eql("invalid input for pattern ^[0-9a-f]{4}$")
+    end
+
+    it 'returns rule instance whatever we want with "lambda" rule name' do
+      r = Focuslight::Validator.rule(:lambda, ->(v){ v == 'kazeburo' }, "kazeburo only permitted", :to_sym)
+      expect(r.check("kazeburo")).to be_true
+      expect(r.check(" ")).to be_false
+      expect(r.check("tagomoris")).to be_false
+
+      expect(r.format("kazeburo")).to eql(:kazeburo)
+
+      expect(r.message).to eql("kazeburo only permitted")
+    end
+  end
+end

data/spec/validator_result_spec.rb

@@ -0,0 +1,27 @@
+require_relative './spec_helper'
+
+require 'focuslight/validator'
+
+describe Focuslight::Validator::Result do
+  it 'indicate that it has errors or not' do
+    r = Focuslight::Validator::Result.new
+    expect(r.has_error?).to be_false
+    r.error(:key, "error 1")
+    expect(r.has_error?).to be_true
+    expect(r.errors).to eql({key: "key: error 1"})
+    r.error(:key2, "error 2")
+    expect(r.has_error?).to be_true
+    expect(r.errors).to eql({key:"key: error 1", key2:"key2: error 2"})
+  end
+
+  it 'can contain values like Hash, but keys are symbolized' do
+    r = Focuslight::Validator::Result.new
+    expect(r[:something]).to be_nil
+    r['something'] = 'somevalue'
+    expect(r[:something]).to eql("somevalue")
+    r[:key1] = "value1"
+    expect(r[:key1]).to eql("value1")
+    r[:key2] = ["value2", "value2alt"]
+    expect(r[:key2]).to eql(["value2", "value2alt"])
+  end
+end

data/spec/validator_rule_spec.rb

@@ -0,0 +1,68 @@
+require_relative './spec_helper'
+
+require 'focuslight/validator'
+
+describe Focuslight::Validator::Rule do
+  it 'can be initialized with 2 or 3 arguments' do
+    expect{ Focuslight::Validator::Rule.new() }.to raise_error(ArgumentError)
+    r1 = Focuslight::Validator::Rule.new(->(v){ v.nil? }, "message")
+    r2 = Focuslight::Validator::Rule.new(->(v){ v.nil? }, "message", ->(v){ nil })
+    expect{ Focuslight::Validator::Rule.new(->(v){ v.nil? }, "message", ->(v){ nil }, "something") }.to raise_error(ArgumentError)
+  end
+
+  describe '#check' do
+    it 'can validate value with first argument lambda' do
+      r1 = Focuslight::Validator::Rule.new(->(v){ v.nil? }, "only nil")
+      expect(r1.check(nil)).to be_true
+      expect(r1.check("str")).to be_false
+
+      r2 = Focuslight::Validator::Rule.new(->(v){ v.to_i == 1 }, "one")
+      expect(r2.check("0")).to be_false
+      expect(r2.check("1.00")).to be_true
+      expect(r2.check("1")).to be_true
+      expect(r2.check("2")).to be_false
+    end
+
+    it 'can receive 2 or more values for lambda arguments if specified' do
+      r1 = Focuslight::Validator::Rule.new(->(v1,v2,v3){ v1.to_i > v2.to_i && v2.to_i > v3.to_i }, "order by desc")
+      expect(r1.check("1","2","3")).to be_false
+      expect(r1.check("3","2","1")).to be_true
+      expect{ r1.check("3") }.to raise_error(ArgumentError)
+
+      r2 = Focuslight::Validator::Rule.new(->(v1){ v1.to_i > 0 }, "greater than zero")
+      expect{ r2.check("1", "2") }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#format' do
+    context 'when formatter not specified' do
+      it 'returns value itself' do
+        r = Focuslight::Validator::Rule.new(->(v){ v.size == 3 }, "3chars")
+        str = "abc"
+        expect(r.format(str)).to equal(str)
+      end
+    end
+    context 'when formatter lambda specified' do
+      it 'returns lambda return value' do
+        r = Focuslight::Validator::Rule.new(->(v){ v == '0' }, 'zero', ->(v){ 0 })
+        expect(r.format("0")).to eql(0)
+      end
+    end
+    context 'when formatter symbol specified' do
+      it 'returns value from Symbol.to_proc' do
+        r = Focuslight::Validator::Rule.new(->(v){ v == '1' || v == '2' }, 'one or two', :to_i)
+        expect(r.format("1")).to eql(1)
+        expect(r.format("2")).to eql(2)
+      end
+    end
+  end
+
+  describe '#message' do
+    it 'returns predefined message' do
+      r = Focuslight::Validator::Rule.new(->(v){ v.nil? }, "nil only allowed")
+      expect(r.message).to eql("nil only allowed")
+      expect(r.message).to eql("nil only allowed")
+      expect(r.message).to eql("nil only allowed")
+    end
+  end
+end

data/spec/validator_spec.rb

@@ -0,0 +1,121 @@
+require_relative './spec_helper'
+
+require 'focuslight/validator'
+
+describe Focuslight::Validator do
+  describe '.validate_single' do
+    it 'returns default value as valid value for params without specified key' do
+      result = Focuslight::Validator::Result.new
+      params = {key1: "1", key2: "2"}
+      spec = {default: "0", rule: Focuslight::Validator.rule(:not_blank)}
+      Focuslight::Validator.validate_single(result, params, :key3, spec)
+
+      expect(result[:key3]).to eql("0")
+    end
+
+    it 'checks and formats about specified single key, that should have single value in params' do
+      params = {key1: "1", key2: "2", keyx: "x"}
+
+      result1 = Focuslight::Validator::Result.new
+      spec1 = {rule: Focuslight::Validator.rule(:not_blank)}
+      Focuslight::Validator.validate_single(result1, params, :key1, spec1)
+      Focuslight::Validator.validate_single(result1, params, :key2, spec1)
+      Focuslight::Validator.validate_single(result1, params, :keyx, spec1)
+      expect(result1.has_error?).to be_false
+      expect(result1[:key1]).to eql("1")
+      expect(result1[:key2]).to eql("2")
+      expect(result1[:keyx]).to eql("x")
+
+      result2 = Focuslight::Validator::Result.new
+      spec2 = {rule: [ Focuslight::Validator.rule(:not_blank), Focuslight::Validator.rule(:uint) ]}
+      Focuslight::Validator.validate_single(result2, params, :key1, spec2)
+      Focuslight::Validator.validate_single(result2, params, :key2, spec2)
+      Focuslight::Validator.validate_single(result2, params, :keyx, spec2)
+      expect(result2.has_error?).to be_true
+      expect(result2[:key1]).to eql(1)
+      expect(result2[:key2]).to eql(2)
+      expect(result2[:keyx]).to be_nil
+      expect(result2.errors).to eql({keyx: "keyx: invalid integer (>= 0)"})
+    end
+  end
+
+  describe '.validate_array' do
+    it 'cannot accept default spec' do
+      params = {key1: ["0", "1", "2"], key2: [], key3: ["kazeburo"]}
+
+      result1 = Focuslight::Validator::Result.new
+      spec1 = {array: true, default: 1, rule: Focuslight::Validator.rule(:not_blank)}
+      expect{ Focuslight::Validator.validate_array(result1, params, :key1, spec1) }.to raise_error(ArgumentError)
+    end
+
+    it 'checks array size' do
+      params = {key1: ["0", "1", "2"], key2: [], key3: ["kazeburo"]}
+
+      result1 = Focuslight::Validator::Result.new
+      spec1 = {array: true, size: 0..3, rule: Focuslight::Validator.rule(:not_blank)}
+      Focuslight::Validator.validate_array(result1, params, :key1, spec1)
+      Focuslight::Validator.validate_array(result1, params, :key2, spec1)
+      Focuslight::Validator.validate_array(result1, params, :key3, spec1)
+      expect(result1.has_error?).to be_false
+      expect(result1[:key1]).to eql(["0", "1", "2"])
+      expect(result1[:key2]).to eql([])
+      expect(result1[:key3]).to eql(["kazeburo"])
+
+      result2 = Focuslight::Validator::Result.new
+      spec2 = {array: true, size: 1...3, rule: Focuslight::Validator.rule(:not_blank)}
+      Focuslight::Validator.validate_array(result2, params, :key1, spec2)
+      Focuslight::Validator.validate_array(result2, params, :key2, spec2)
+      Focuslight::Validator.validate_array(result2, params, :key3, spec2)
+      expect(result2.has_error?).to be_true
+      expect(result2[:key1]).to be_nil
+      expect(result2[:key2]).to be_nil
+      expect(result2[:key3]).to eql(["kazeburo"])
+    end
+
+    it 'formats all elements of valid field' do
+      params = {key1: ["0", "1", "2"], key2: [], key3: ["kazeburo"]}
+
+      result1 = Focuslight::Validator::Result.new
+      spec1 = {array: true, size: 0..3, rule: Focuslight::Validator.rule(:not_blank)}
+      Focuslight::Validator.validate_array(result1, params, :key1, spec1)
+      Focuslight::Validator.validate_array(result1, params, :key2, spec1)
+      Focuslight::Validator.validate_array(result1, params, :key3, spec1)
+      expect(result1.has_error?).to be_false
+      expect(result1[:key1]).to eql(["0", "1", "2"])
+      expect(result1[:key2]).to eql([])
+      expect(result1[:key3]).to eql(["kazeburo"])
+
+      result2 = Focuslight::Validator::Result.new
+      spec2 = {array: true, size: 0..3, rule: [Focuslight::Validator.rule(:not_blank), Focuslight::Validator.rule(:uint)]}
+      Focuslight::Validator.validate_array(result2, params, :key1, spec2)
+      Focuslight::Validator.validate_array(result2, params, :key2, spec2)
+      Focuslight::Validator.validate_array(result2, params, :key3, spec2)
+      expect(result2.has_error?).to be_true
+      expect(result2[:key1]).to eql([0, 1, 2])
+      expect(result2[:key2]).to eql([])
+      expect(result2[:key3]).to be_nil
+    end
+  end
+  describe '.validate_multi_key' do
+    it 'does not accept default keyword' do
+      params = {key1: "10", key2: "1", key3: "0", key4: "5", key5: "3"}
+      result = Focuslight::Validator::Result.new
+      spec = { default: 1, rule: Focuslight::Validator::Rule.new(->(x,y,z){ x.to_i + y.to_i + z.to_i < 15 }, "too large") }
+      expect{ Focuslight::Validator.validate_multi_key(result, params, [:key1, :key2, :key3], spec) }.to raise_error(ArgumentError)
+    end
+
+    it 'checks complex expression with array key (multi field validation)' do
+      params = {key1: "10", key2: "1", key3: "0", key4: "5", key5: "3"}
+      spec = { rule: Focuslight::Validator::Rule.new(->(x,y,z){ x.to_i + y.to_i + z.to_i < 15 }, "too large") }
+
+      r1 = Focuslight::Validator::Result.new
+      Focuslight::Validator.validate_multi_key(r1, params, [:key1, :key2, :key3], spec)
+      expect(r1.has_error?).to be_false
+
+      r2 = Focuslight::Validator::Result.new
+      Focuslight::Validator.validate_multi_key(r2, params, [:key1, :key2, :key4], spec)
+      expect(r2.has_error?).to be_true
+      expect(r2.errors).to eql({:'key1,key2,key4' => "key1,key2,key4: too large"})
+    end
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: focuslight-validator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- TAGOMORI Satoshi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !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: rspec
+  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: 
+email:
+- tagomoris@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- focuslight-validator.gemspec
+- lib/focuslight-validator.rb
+- lib/focuslight/validator.rb
+- lib/focuslight/validator/result.rb
+- lib/focuslight/validator/rule.rb
+- lib/focuslight/validator/version.rb
+- spec/spec_helper.rb
+- spec/syntax_spec.rb
+- spec/validator_predefined_rules_spec.rb
+- spec/validator_result_spec.rb
+- spec/validator_rule_spec.rb
+- spec/validator_spec.rb
+homepage: https://github.com/focuslight/focuslight-validator
+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: Validate http request parameters (or others) by defined rule, without models.
+test_files:
+- spec/spec_helper.rb
+- spec/syntax_spec.rb
+- spec/validator_predefined_rules_spec.rb
+- spec/validator_result_spec.rb
+- spec/validator_rule_spec.rb
+- spec/validator_spec.rb