active_model_type_validator 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 72c8544aafca46e9293835f295a5a8e87013d4c6
+  data.tar.gz: 9f9b086ba8474d5ed70057371c69f538455ea17a
+SHA512:
+  metadata.gz: b2769e445e21187b1108d9863d5cbbb2dd78996eb396926c14397072d97ff090811aa0f40422365addac2a41ca732fbd319c01eaecc1dcb0c2815e3192f93713
+  data.tar.gz: ae548970359df5bc19f1ab603935d5e50ff139f19b4d0950fabf76d3733fd819410ce0f7f591bf0d0012923dae3e262ad0501f8a3d2c16199e2094cafada4da8

data/.yardopts

@@ -0,0 +1,3 @@
+-
+LICENSE.md
+CHANGELOG.md

data/Appraisals

@@ -0,0 +1,3 @@
+appraise "rails-4.2" do
+  gem "rails", "4.2.4"
+end

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 0.1.0
+
+* Initial development version

data/LICENSE.md

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Todd Knarr
+
+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,74 @@
+# ActiveModelTypeValidator
+
+Provides two ActiveModel validators:
+
+1. One to validate that an attribute is of the correct type. Multiple types are allowed.
+2. One to validate the contents of an attribute by calling `#valid?` on it, performing
+   the same job as ActiveRecord's `validates_associated`.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_model_type_validator'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_model_type_validator
+
+## Usage
+
+The usage is fairly standard. The `object_type` validator takes one option `:type` which
+is either a type name (string, symbol or type) or an array of type names. The `contents`
+validator needs no options. Both take the standard options all validators do, except
+that `object_type` ignores the `:allow_blank` option (you should use `:allow_nil` if you
+need equivalent behavior).
+
+Examples:
+
+```ruby
+class MyClass
+    include ActiveModel::Model
+    include ActiveModel::Validations
+
+    validates :string_field, object_type: { type: String }
+    validates :integer_field, object_type: { type: Integer }
+    validates :numeric_field, object_type: { type: [Integer, Float] }
+    validates :object_field, contents: true, object_type: { type: ChildClass }
+
+    attr_accessor :string_field
+    attr_accessor :integer_field
+    attr_accessor :numeric_field
+    attr_accessor :object_field
+
+    def initialize
+        @string_field = 'my string'
+        @integer_field = 42
+        @numeric_field = 7
+        @object_field = ChildClass.new
+    end
+
+end
+```
+
+The `contents` validator adds what's equivalent to ActiveModel's `associated` validator,
+passing if calling `#valid?` on the attribute returns true.
+  
+The `object_type` validator lets you test ActiveModel objects used in an API to make sure
+they contain objects of the expected types rather than something you aren't expecting. It
+fills in a gap I was annoyed by when I validate incoming API objects immediately upon
+receiving them and go no further if they fail validation.
+
+## Contributing
+
+1. Fork it ( https://github.com/tknarr/active_model_type_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 a new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/gem_tasks'
+require 'yard'
+
+YARD::Rake::YardocTask.new do |t|
+    t.options += ['--title', "Active Model Type Validator #{ActiveModelTypeValidator::VERSION} Documentation"]
+end
+

data/active_model_type_validator.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_model_type_validator/version'
+
+Gem::Specification.new do |spec|
+    spec.name = "active_model_type_validator"
+    spec.version = ActiveModelTypeValidator::VERSION
+    spec.date = Time.now.strftime('%Y-%m-%d')
+    spec.author = 'Todd Knarr'
+    spec.email = 'tknarr@silverglass.org'
+    spec.summary = %q{ActiveModel validators to validate object types and contained/associated objects.}
+    spec.description = %q{ActiveModel validators that validate the type of attributes, and that do recursive validation of contained objects parallel to ActiveRecord's validates_associated.}
+    spec.homepage = 'https://github.com/tknarr/active_model_type_validator'
+    spec.license = "MIT"
+
+    spec.files = Dir.glob('lib/**/*').select { |path| File.file?(path) } +
+        [  __FILE__ ]
+    spec.test_files = Dir.glob('test/**/*').select { |path| File.file?(path) && !File.fnmatch('*.{log,sqlite3}', path, File::FNM_EXTGLOB) } +
+        Dir.glob('gemfiles/*.gemfile') + [ 'Rakefile', 'Appraisals' ]
+    spec.extra_rdoc_files = [ 'README.md', 'CHANGELOG.md', 'LICENSE.md', '.yardopts' ]
+    spec.require_paths = ['lib']
+
+    spec.add_dependency 'rails', '~> 4.2'
+    spec.add_dependency 'activemodel', '~> 4.2'
+
+    # Development
+    spec.add_development_dependency 'bundler', '~> 1.7'
+    spec.add_development_dependency 'rake', '~> 10.0'
+    spec.add_development_dependency 'yard', '~> 0'
+
+    # Testing
+    spec.add_development_dependency 'minitest', '~> 5'
+    spec.add_development_dependency 'appraisal', '~> 2'
+    spec.add_development_dependency 'sqlite3', '~> 1'
+end

data/gemfiles/rails_4.2.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "4.2.4"
+
+gemspec :path => "../"

data/lib/active_model_type_validator.rb

@@ -0,0 +1,3 @@
+require 'active_model_type_validator/version'
+require 'active_model_type_validator/object_type'
+require 'active_model_type_validator/contents'

data/lib/active_model_type_validator/contents.rb

@@ -0,0 +1,30 @@
+module ActiveModel
+
+    module Validations
+
+        # Implements the mechanics of <tt>validates_contents_of</tt>.
+        class ContentsValidator < ActiveModel::EachValidator
+
+            # Standard validation method for an <tt>EachValidator</tt>.
+            def validate_each(object, attribute, value)
+                if Array.wrap(value).reject { |r| r.valid? }.any?
+                    object.errors.add(attribute, :invalid, options.merge(:value => value))
+                end
+            end
+
+        end
+
+        module HelperMethods
+
+            # An implementation of the associated validator from ActiveRecord.
+            # All options and behaviors are identical. It simply calls #valid? on each
+            # of the attributes listed and returns the logical AND of them all.
+            def validates_contents_of(*attr_names)
+                validates_with ContentsValidator, _merge_attributes(attr_names)
+            end
+
+        end
+
+    end
+
+end

data/lib/active_model_type_validator/locale/en.yml

@@ -0,0 +1,4 @@
+en:
+  errors:
+    messages:
+      wrong_type: "cannot be of type %{type}"

data/lib/active_model_type_validator/object_type.rb

@@ -0,0 +1,99 @@
+module ActiveModel
+
+    module Validations
+
+        # Implements the mechanics of <tt>validates_object_type_of</tt>.
+        #
+        # The standard <tt>#initialize</tt> and <tt>#validate_each</tt> methods are implemented.
+        class ObjectTypeValidator < EachValidator
+
+            # Standard initializer for an <tt>EachValidator</tt>.
+            def initialize(options)
+                @types = []
+                # Remove :allow_blank since it's nonsensical when testing types
+                options.delete(:allow_blank)
+                # Set :allow_nil true if it's not present
+                t = options[:allow_nil]
+                options[:allow_nil] = true if t.nil?
+                # Filter out missing or blank type entries and convert others
+                # to class via constantize.
+                t = Array(options.delete(:type))
+                t.each do |te|
+                    if te.is_a?(Class)
+                        @types.append(te)
+                    elsif te.is_a?(String)
+                        begin
+                            @types.append(te.constantize) unless te.blank?
+                        rescue NameError
+                            raise ArgumentError, "Type #{te} is invalid"
+                        end
+                    elsif te.is_a?(Symbol)
+                        begin
+                            @types.append(te.to_s.constantize)
+                        rescue NameError
+                            raise ArgumentError, "Type #{te.to_s} is invalid"
+                        end
+                    else
+                        raise ArgumentError, "Type #{te.to_s} is a #{te.class.name} which is invalid"
+                    end
+                end
+                raise ArgumentError, 'At least one type must be given' if @types.empty?
+                super(options)
+                check_validity!
+            end
+
+            # Standard validation method for an <tt>EachValidator</tt>.
+            def validate_each(record, attr_name, value)
+                errors_options = options.except(:type)
+                errors_options[:type] = value.class
+                right_type = false
+                @types.each do |t|
+                    # Entries in @types are classes, not strings
+                    right_type = true if value.is_a?(t)
+                end
+                record.errors.add(attr_name, (options[:message] || :wrong_type), errors_options) unless right_type
+            end
+
+        end
+
+        module HelperMethods
+
+            # Validates that the specified attributes are of a given type (as defined by <tt>#is_a?</tt>).
+            #
+            #   class Person < ActiveRecord::Base
+            #     validates_type_of :first_name, type: String
+            #   end
+            #
+            # The +first_name+ attribute must be in the object and it must be a X.
+            #
+            # If you want to validate the type of a boolean field (where the real
+            # types are +TrueClass+ and +FalseClass+), you will want to use
+            # both those classes in the list of types and set +:allow_nil+ to false.
+            #
+            # By default this validator sets +:allow_nil+ to true to allow nil values to
+            # pass through validation even though +NilClass+ isn't explicitly listed, and
+            # you're expected to use a presence validator if you want the attribute to have
+            # to be present (non-nil). You can set +:allow_nil+ to false to cause even nil
+            # values to be checked against the type list and fail if NilClass isn't listed,
+            # mimicking the effect of a presence validator.
+            #
+            # Configuration options:
+            # * <tt>:type</tt> - An array of class names (or symbols or strings naming class
+            #   names) which are legal for values of the attribute.
+            # * <tt>:message</tt> - A custom error message (default is: "cannot be of type X").
+            #   Messages can find the offending type name for interpolation in +:type+.
+            #
+            # There is also a list of default options supported by every validator:
+            # +:if+, +:unless+, +:on+, +:allow_nil+, and +:strict+. +:allow_blank+ is
+            # not allowed because it's nonsensical and confusing when applied to type
+            # checking.
+            # See <tt>ActiveModel::Validation#validates</tt> for more information
+            def validates_object_type_of(*attr_names)
+                validates_with ObjectTypeValidator, _merge_attributes(attr_names)
+            end
+
+        end
+
+    end
+
+end

data/lib/active_model_type_validator/version.rb

@@ -0,0 +1,7 @@
+# Exists just for the version number
+module ActiveModelTypeValidator
+
+    # Version number
+    VERSION = '1.0.0'
+
+end

data/test/active_model_type_validator/active_model_type_validator_test.rb

@@ -0,0 +1,11 @@
+require '../test_helper'
+require 'active_model_type_validator'
+
+class ActiveModelTypeValidatorTest < ActiveSupport::TestCase
+
+    test 'API' do
+        assert_not_nil ActiveModelTypeValidator::VERSION
+        assert_kind_of String, ActiveModelTypeValidator::VERSION
+    end
+
+end

data/test/active_model_type_validator/contents_test.rb

@@ -0,0 +1,129 @@
+require '../test_helper'
+require 'active_model_type_validator'
+
+class MyClass1
+    include ActiveModel::Model
+    include ActiveModel::Validations
+    validates :a1, presence: true, numericality: { only_integer: true, greater_than: 0 }
+    validates :b1, presence: true, numericality: { only_integer: true, greater_than: 0 }
+    validates :c1, presence: true, contents: true
+
+    attr_accessor :a1
+    attr_accessor :b1
+    attr_accessor :c1
+
+end
+
+class MyClass1a
+    include ActiveModel::Model
+    include ActiveModel::Validations
+    validates :a1, presence: true, numericality: { only_integer: true, greater_than: 0 }
+    validates :b1, presence: true, numericality: { only_integer: true, greater_than: 0 }
+    validates :c1, presence: true
+
+    attr_accessor :a1
+    attr_accessor :b1
+    attr_accessor :c1
+
+end
+
+class MyClass1b
+    include ActiveModel::Model
+    include ActiveModel::Validations
+    validates :a1, presence: true, numericality: { only_integer: true, greater_than: 0 }
+    validates :b1, presence: true, numericality: { only_integer: true, greater_than: 0 }
+    validates :c1, contents: { allow_nil: true }
+    validates :c2, contents: true
+
+    attr_accessor :a1
+    attr_accessor :b1
+    attr_accessor :c1
+    attr_accessor :c2
+
+end
+
+class MyClass2
+    include ActiveModel::Model
+    include ActiveModel::Validations
+    validates :a2, presence: true, numericality: { only_integer: true, greater_than: 0 }
+    validates :b2, presence: true, numericality: { only_integer: true, greater_than: 0 }
+
+    attr_accessor :a2
+    attr_accessor :b2
+
+end
+
+class RecursiveTest < ActiveSupport::TestCase
+
+    def setup
+        @model = MyClass1.new
+        @model.a1 = 57
+        @model.b1 = nil
+        @model.c1 = MyClass2.new
+        @model.c1.a2 = 99
+        @model.c1.b2 = nil
+
+        @not_validated = MyClass1a.new
+        @not_validated.a1 = 57
+        @not_validated.b1 = nil
+        @not_validated.c1 = MyClass2.new
+        @not_validated.c1.a2 = 99
+        @not_validated.c1.b2 = nil
+
+        @no_child = MyClass1b.new
+        @no_child.a1 = 57
+        @no_child.b1 = nil
+        @no_child.c1 = MyClass2.new
+        @no_child.c1.a2 = 99
+        @no_child.c1.b2 = nil
+        @no_child.c2 = MyClass2.new
+        @no_child.c2.a2 = 99
+        @no_child.c2.b2 = nil
+
+    end
+
+    test 'valid parent valid child' do
+        @model.b1 = 17
+        @model.c1.b2 = 23
+        assert @model.valid?
+    end
+
+    test 'valid parent invalid child' do
+        @model.b1 = 17
+        @model.c1.b2 = -23
+        assert_not @model.valid?
+    end
+
+    test 'invalid parent valid child' do
+        @model.b1 = -17
+        @model.c1.b2 = 23
+        assert_not @model.valid?
+    end
+
+    test 'invalid parent invalid child' do
+        @model.b1 = -17
+        @model.c1.b2 = -23
+        assert_not @model.valid?
+    end
+
+    test 'valid parent invalid child not validated' do
+        @not_validated.b1 = 17
+        @not_validated.c1.b2 = -23
+        assert @not_validated.valid?
+    end
+
+    test 'valid parent without child allow nil' do
+        @no_child.b1 = 17
+        @no_child.c1 = nil
+        @no_child.c2.b2 = 23
+        assert @no_child.valid?
+    end
+
+    test 'valid parent without child no allow nil' do
+        @no_child.b1 = 17
+        @no_child.c1.b2 = 23
+        @no_child.c2 = nil
+        assert_not @model.valid?
+    end
+
+end