validates-structure 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fabdbd7d01016e5ded1f1cfe683c8e8f998ef94d
+  data.tar.gz: f2dc477eb6004acdac22e983e914b677f2929778
+SHA512:
+  metadata.gz: 0d74f74ac673327c6f134370c86ecfb210f8056974773d44c3fc43c71d164e5939c74a43cd70723a3857aa307403fb6dd020ce9b1ba3937e7309ee4428db2fe2
+  data.tar.gz: 8b790670773538b6890270f04d4ae621a2fa5e4c0bf36d49e5661bb11177f7956ea0d15ff9d07b1897a367b4580b2bc79264a563780e389dfb050552ca578b25

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright 2013 PugglePay
+
+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,202 @@
+Validates Structure
+===================
+
+Validates Structure allows you to easily validate hash-structures using ActiveModel::Validations.
+
+
+Dependencies
+------------
+The gem works for ActiveModel 4 and above.
+
+
+Installation
+------------
+Simply add the gem to your gemfile:
+
+```ruby
+gem 'validates-structure'
+```
+
+and make sure your activemodel version is at least 4.0.0:
+
+```ruby
+gem 'activemodel', '>=4.0.0'
+```
+
+Remember to
+
+```ruby
+require 'validates-structure'
+```
+
+at the top of the file when defining a new structure.
+
+Canonical Usage Example
+------------
+
+```ruby
+require 'validates-structure'
+
+class MyCanonicalValidator < ValidatesStructure::Validator
+  key 'foo', Hash do
+    key 'bar', Array do
+      value Integer, allow_nil: true
+    end
+    key 'baz', String, format: /\A[0-f]\z/
+  end
+end
+
+validator = MyCanonicalValidator.new({foo: {bar: [1, 2, nil, 'invalid']}})
+validator.valid?
+# => false
+puts validator.errors.full_messages
+# => /foo/bar[3] has class "String" but should be a "Integer"
+# => /foo/baz is invalid
+# => /foo/baz must not be nil
+```
+
+Quick facts about Validates Structure
+-------------------------------------
+* Validates Structure uses ActiveModel::Validations to validate your hash.
+* Validates Structure automatically validates the type of each declared entry and will also give an error when undeclared keys are present.
+* You can validate that a value are true or false by using the `Boolean` class (even though there are no Boolean class i Ruby).
+* You can make compound hashes by setting a subclass to ValidatesStructure::Validator as the class in a key or value declaration.
+* It doesn't matter if your structure uses symbols or strings as hash keys.
+* Just like when validating attributes in a model, you can use your own custom validations.
+
+Examples
+--------
+
+### Minimal example
+
+```ruby
+class MySimpleValidator < ValidatesStructure::Validator
+  key 'apa', Integer
+end
+
+MySimpleValidator.new(apa: 3).valid?
+# => true
+```
+
+### Boolean example
+
+```ruby
+class MyBooleanValidator < ValidatesStructure::Validator
+  key 'apa', Boolean
+end
+
+MyBooleanValidator.new(apa: true).valid?
+# => true
+```
+
+### Nested example
+
+```ruby
+class MyNestedValidator < ValidatesStructure::Validator
+  key 'apa', Hash do
+    key 'bepa', String, presence: true
+  end
+end
+
+validator = MyNestedValidator.new(apa: { bepa: "" })
+validator.valid?
+# => false
+puts validator.errors.full_messages
+# => /apa/bepa can't be blank
+```
+
+### Array example
+
+```ruby
+class MyArrayValidator < ValidatesStructure::Validator
+  key 'apa', Hash do
+    key 'bepa', Array do
+      value Integer
+    end
+  end
+end
+
+validator = MyArrayValidator.new(apa: { bepa: [1, 2, "3"] })
+validator.valid?
+# => true
+puts validator.errors.full_messages
+# => /apa/bepa[2] has class "String" but should be a "Integer"
+```
+
+### Compound example
+
+```ruby
+class MyInnerValidator < ValidatesStructure::Validator
+  key 'bepa', Integer
+end
+
+class MyOuterValidator < ValidatesStructure::Validator
+  key 'apa', MyInnerValidator
+end
+
+MyOuterValidator.new(apa: { bepa: 3 }).valid?
+# => true
+```
+
+### Custom validator example
+
+```ruby
+class OddValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    record.errors.add attribute, "can't be even." if value.even?
+  end
+end
+
+class MyCustomValidator < ValidatesStructure::Validator
+  key 'apa', Integer, odd: true
+end
+
+MyCustomValidator.new(apa: 3).valid?
+# => true
+```
+
+
+Documentation
+-------------
+This documentation is about the modules, classes, methods and options of ValidatesStructure. For documentation on ActiveModel::Validations see [the ActiveModel documentation.](http://apidock.com/rails/ActiveModel/Validations/ClassMethods/validates)
+
+### ValidatesStructure::Validator
+
+#### self.key(index, klass, validations={}, &block)
+Sets up a requirement on the form ```'index' => klass``` that are validated with _validations_ and containing children on the form specified in _&block_.
+
+**Parameters**
+
+_index_ - The string or symbol by which to retrieve the value
+
+_klass_ - The required class of the value. If klass is a subclass of ValidatesStructure::Validator then the value is validated as specified in its definition.
+
+_validations_ - A hash with [ActiveModel:Validations](http://api.rubyonrails.org/classes/ActiveModel/Validations/HelperMethods.html) on the same format as for the [validates](http://apidock.com/rails/ActiveModel/Validations/ClassMethods/validates) method.
+
+_&block_ - A block of nested _key_ and/or _value_ declarations. Only applicable if klass is an Array or Hashe.
+
+
+#### self.value(klass, validations={},&block)
+Sets up a requirement like self.key but without an index. Useful for structures that are accessed by a numeric index such as Arrays.
+
+**Parameters**
+
+_klass_ - The required class of the value. If klass is a subclass of ValidatesStructure::Validator then the value is validated as specified in its definition.
+
+_validations_ - A hash with [ActiveModel:Validations](http://api.rubyonrails.org/classes/ActiveModel/Validations/HelperMethods.html) on the same format as for the [validates](http://apidock.com/rails/ActiveModel/Validations/ClassMethods/validates) method.
+
+_&block_ - A block of nested _key_ and/or _value_ declarations. Only applicable if klass is an Array or Hashe.
+
+
+Some History
+------------
+This project was initiated by the good fellows at [PugglePay](https://github.com/PugglePay) who felt there should be some easy, familiar way of validating their incoming json requests and wanted to share their solution with the world.
+
+
+Contributing
+------------
+1. Fork the project
+2. Create a feature branch (git checkout -b my-new-feature)
+3. Commit your changes (git commit -am 'Add some feature')
+4. Push branch to remote (git push origin my-new-feature)
+5. Make a Pull Request

data/Rakefile

@@ -0,0 +1,38 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ValidatesStructure'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/lib/validates-structure.rb

@@ -0,0 +1,206 @@
+require 'active_model'
+require 'securerandom'
+
+module ValidatesStructure
+
+  class Validator
+    include ActiveModel::Validations
+
+    class_attribute :keys, instance_writer: false
+    class_attribute :values, instance_writer: false
+    class_attribute :nested_validators, instance_writer: false
+
+    attr_accessor :keys
+
+    def initialize(hash)
+      self.class.initialize_class_attributes
+      self.keys = []
+
+      return unless hash.is_a?(Hash)
+
+      hash.each do |key, value|
+        self.keys << key.to_s
+        send "#{key}=", value if respond_to? "#{key}="
+      end
+    end
+
+    def self.key(key, klass, validations={}, &block)
+      initialize_class_attributes
+      key = key.to_s
+
+      if klass.class != Class
+        raise ArgumentError.new("Types must be given as classes")
+      end
+      unless @nested_array_key.nil?
+        raise ArgumentError.new("Key can not only appear within a block of a key of type Array")
+      end
+      if keys.include?(key)
+        raise ArgumentError.new("Dublicate key \"#{key}\"")
+      end
+
+      keys << key
+      attr_accessor key
+
+      validations = prepare_validations(klass, validations, &block)
+      validates key, validations
+
+      nest_dsl(klass, key, &block)
+    end
+
+    def self.value(klass, validations={}, &block)
+      initialize_class_attributes
+
+      if klass.class != Class
+        raise ArgumentError.new("Types must be given as classes")
+      end
+      if @nested_array_key.nil?
+        raise ArgumentError.new("Value can only appear within the block of a key of Array type")
+      end
+      if values[@nested_array_key]
+        raise ArgumentError.new("Value can only appear once within a block")
+      end
+      values[@nested_array_key] = klass
+
+      validations = prepare_validations(klass, validations, &block)
+      validates @nested_array_key, enumerable: validations
+      nest_dsl(klass, @nested_array_key, &block)
+    end
+
+    def self.human_attribute_name(attr, *)
+      "/#{attr}"
+    end
+
+    validate do
+      (keys - self.class.keys).each do |key|
+        errors.add(key, "is not a known key")
+      end
+    end
+
+  protected
+
+    def self.initialize_class_attributes
+      self.keys ||= []
+      self.values ||= {}
+      self.nested_validators ||= {}
+    end
+
+    def self.prepare_validations(klass, validations, &block)
+      validations = validations.dup
+      validations[:klass] = { klass: (klass.ancestors.include?(Validator) ? Hash : klass) }
+      unless validations[:allow_nil] == true || validations[:allow_blank] == true
+        if klass == String
+          validations[:not_blank] = true
+        else
+          validations[:not_nil] = true
+        end
+      end
+      validations[:nested] = true if block_given? || klass.ancestors.include?(Validator)
+      validations
+    end
+
+    def self.nest_dsl(klass, key, &block)
+      if klass.ancestors.include?(Validator)
+        self.nested_validators[key] = klass
+      elsif block_given?
+        case
+        when klass == Hash
+          klass_name = "Annonimous#{ key.to_s.camelize }Validator#{SecureRandom.uuid.tr('-','')}"
+          const_set(klass_name, Class.new(self.superclass))
+          validator = const_get(klass_name)
+          validator.instance_eval(&block)
+          self.nested_validators[key] = validator
+        when klass == Array
+          @nested_array_key = key
+          yield
+          @nested_array_key = nil
+        else
+          raise ArgumentError.new("Didn't expect a block for the type \"#{klass}\"")
+        end
+      end
+    end
+
+    def self.model_name
+      ActiveModel::Name.new(self, nil, "temp")
+    end
+
+    class Boolean
+    end
+
+    class KlassValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        return if value.nil?
+        klass = options[:klass]
+        if klass == Boolean
+          unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
+            record.errors.add attribute, "has class \"#{value.class}\" but should be boolean"
+          end
+        elsif !(value.is_a?(klass))
+          record.errors.add attribute, "has class \"#{value.class}\" but should be a \"#{klass}\""
+        end
+      end
+    end
+
+    class NotNilValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        if value.nil?
+          record.errors.add attribute, "must not be nil"
+        end
+      end
+    end
+
+    class NotBlankValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        if value.blank?
+          record.errors.add attribute, "must not be empty"
+        end
+      end
+    end
+
+    class NestedValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        return unless value.is_a?(Hash)
+        return if record.errors.keys.map(&:to_s).include?(attribute)
+
+        validator = record.class.nested_validators[attribute]
+        return if validator.nil?
+
+        nested = validator.new(value)
+        nested.valid?
+        nested.errors.each do |nested_attribute, message|
+          record.errors.add("#{attribute}/#{nested_attribute}", message)
+        end
+      end
+    end
+
+    class EnumerableValidator < ActiveModel::EachValidator
+      # Validates each value in an enumerable class using ActiveModel validations.
+      # Adapted from a snippet by Milovan Zogovic (http://stackoverflow.com/a/12744945)
+      def validate_each(record, attribute, values)
+        return unless values.respond_to?(:each_with_index)
+        values.each_with_index do |value, index|
+          options.each do |key, args|
+            validator_options = { attributes: attribute }
+            validator_options.merge!(args) if args.is_a?(Hash)
+
+            next if value.nil? && validator_options[:allow_nil]
+            next if value.blank? && validator_options[:allow_blank]
+            next if key.to_s == "allow_nil"
+            next if key.to_s == "allow_blank"
+
+            validator_class_name = "#{key.to_s.camelize}Validator"
+            validator_class = self.class.parent.const_get(validator_class_name)
+            validator = validator_class.new(validator_options)
+
+            # TODO: There should be a better way!
+            tmp_record = record.dup
+            validator.validate_each(tmp_record, attribute, value)
+            tmp_record.errors.each do |nested_attribute, error|
+              indexed_attribute = nested_attribute.to_s.sub(/^#{attribute}/, "#{attribute}[#{index}]")
+              record.errors.add(indexed_attribute, error)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/validates-structure/version.rb

@@ -0,0 +1,3 @@
+module ValidatesStructure
+  VERSION = "0.2.0"
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: validates-structure
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Magnus Rex
+- Daniel Ström
+- Jean-Louis Giordano
+- Patrik Kårlin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.1.1
+- !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'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  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: guard
+  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: guard-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: Uses the power and familiarity of ActiveModel::Validations to validate
+  hash structures. Designed for detecting and providing feedback on bad requests to
+  your RESTful Web Service.
+email:
+- dev@pugglepay.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/validates-structure/version.rb
+- lib/validates-structure.rb
+- LICENSE.txt
+- Rakefile
+- README.md
+homepage: https://github.com/PugglePay/validates-structure
+licenses: []
+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.0.3
+signing_key: 
+specification_version: 4
+summary: ActiveModel validations for nested structures like params.
+test_files: []
+has_rdoc: