validates_type 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 095e33afbb9a0aebd616f77ee2be6a6c6f44598b
+  data.tar.gz: 27aa41f31c5dd6935ce8ccc41c5fde70ac54844f
+SHA512:
+  metadata.gz: e4996fa85a21db804072016958f327f6831e9a4dd34c9702b483467f62411d713b5cbb034a53eb5e309674751eb8a8e6a51f5f988337412c46429e44e703d5de
+  data.tar.gz: 0ba9a4f043b605d20bed49fc6b7a6d78c77614d34af5bdd20cf9f60f5b851332a015c0c0acbaae252a3123cc9bf265bf9b1bd25a3e20179d46af64d1618cfe57

data/.gitignore

@@ -0,0 +1,2 @@
+.ruby*
+*.gem

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm: 2.2.1
+script: bundle exec rspec spec

data/Gemfile

@@ -0,0 +1,11 @@
+source 'http://rubygems.org'
+
+gem 'activemodel'
+gem 'ruby-boolean'
+
+group :test do
+  gem 'rspec'
+  gem 'pry'
+  gem 'activerecord'
+  gem 'sqlite3'
+end

data/Gemfile.lock

@@ -0,0 +1,58 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (4.2.1)
+      activesupport (= 4.2.1)
+      builder (~> 3.1)
+    activerecord (4.2.1)
+      activemodel (= 4.2.1)
+      activesupport (= 4.2.1)
+      arel (~> 6.0)
+    activesupport (4.2.1)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    arel (6.0.0)
+    builder (3.2.2)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    i18n (0.7.0)
+    json (1.8.2)
+    method_source (0.8.2)
+    minitest (5.6.1)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.3)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+    ruby-boolean (1.3.3)
+    slop (3.6.0)
+    sqlite3 (1.3.10)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemodel
+  activerecord
+  pry
+  rspec
+  ruby-boolean
+  sqlite3

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Jake Yesbeck
+
+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,90 @@
+## validates_type
+
+![Build Status](https://travis-ci.org/yez/validates_type.svg?branch=master)
+
+### Rails type validation
+
+#### Purpose
+
+Most Rails applications will have types coerced by their ORM connection adapters (like the `pg` gem or `mysql2`). However, this only useful for applications with very well defined schemas. If your application has a legacy storage layer that you can no longer modify or a lot of `store_accessor` columns, this solution is a nice middle ground to ensure your data is robust.
+
+This also prevents your data from being coerced into values that you did not intend by ActiveRecord adapters.
+
+#### Usage
+
+##### With ActiveRecord
+
+```ruby
+class Foo < ActiveRecord::Base
+
+  # validate that attribute :bar is a String
+  validates_type :bar, :string
+
+  # validate that attribute :baz is an Integer with a custom error message
+  validates_type :baz, :integer, message: 'Baz must be an Integer'
+
+  # validate that attribute :qux is an Array, allow blank
+  validates_type :qux, :array, allow_blank: true
+
+  # validate that attribute :whatever is a Boolean
+  validates_type :whatever, :boolean
+
+  # validate that attribute :thing is a Float or nil
+  validates_type :thing, :float, allow_nil: true
+end
+```
+
+##### With ActiveModel
+
+```ruby
+class Bar
+  include ActiveModel::Validations
+
+  attr_accessor :foo, :qux
+
+  validates_type :foo, :string
+
+  # Custom error message support
+  validates_type :qux, :boolean, message: 'Attribute qux must be a boolean!'
+end
+```
+
+##### With shortcut syntax
+
+```ruby
+class Banana < ActiveRecord::Base
+
+  # The banana's peel attribute must be a string
+  validates :peel, type: { type: :string }
+
+  # Custom error message for ripeness of banana
+  validates :ripe, type: { type: :boolean, message: 'Only ripe bananas allowed' }
+end
+```
+
+##### With multiple modifiers
+
+```ruby
+class Foo < ActiveRecord::Base
+  # validate that attribute :baz is an Integer with a custom error message
+  #   only if :conditional_method evaluates to true
+  validates_type :baz, :integer, message: 'Baz must be an Integer', if: :conditional_method
+
+  def conditional_method
+    # some kind of logic that is important to pass
+  end
+
+  # validate that attribute :baz is a Float and is included in a specific array
+  validates_type :foo, :float, in: [1.0, 2.5, 3.0]
+end
+```
+
+#### Supported types
+
+- `:array`
+- `:boolean`
+- `:float`
+- `:hash`
+- `:integer`
+- `:string`
+- `:symbol`

data/errors/unsupported_type.rb

@@ -0,0 +1,4 @@
+# Error class to raise if unsupported type given to validates_url
+module ValidatesType
+  class UnsupportedType < StandardError; end
+end

data/lib/arguments.rb

@@ -0,0 +1,44 @@
+module ValidatesType
+  # Wrapper class for arguments consumed by validates_with
+  class Arguments
+    # @initialize
+    #   param: attribute_name <Symbol> - name of attribute that will be validated
+    #   param: attribute_type <Symbol> - type for which to validate the attribute against
+    #   param: options <Hash> - extra options to pass along to the validator
+    #                           i.e. allow_nil: true, message: 'my custom message'
+    #   return: nil
+    def initialize(attribute_name, attribute_type, options)
+      @attribute_name = attribute_name
+      @attribute_type = attribute_type
+      @options        = options.is_a?(Hash) ? options : {}
+    end
+
+    # format expected by _merge_attributes
+    #
+    # @to_validation_attributes
+    # return: <Array> - cardinality of 2
+    def to_validation_attributes
+      [@attribute_name, merged_options]
+    end
+
+    private
+
+    # helper method to compact all the options together along
+    #   with the type for validation
+    #
+    # @merged_options
+    #   return: <Hash>
+    def merged_options
+      type.merge(@options)
+    end
+
+    # helper method to impose the type for validation into an option
+    #  that will be merged later
+    #
+    # @type
+    #   return: <Hash>
+    def type
+      { :type => @attribute_type }
+    end
+  end
+end

data/lib/validates_type.rb

@@ -0,0 +1,138 @@
+require 'ruby-boolean'
+require 'active_model'
+
+require_relative '../errors/unsupported_type'
+require_relative './arguments'
+
+module ActiveModel
+  module Validations
+    class TypeValidator < ActiveModel::EachValidator
+      # Set default message for failure here
+      #
+      # @initialize
+      #   param: options <Hash> - options hash of how to validate this attribute
+      #                           including custom messaging due to failures, specifying
+      #                           the type of the attribute to validate against, etc.
+      #   return: result of ActiveModel::Validations::EachValidator initialize
+      def initialize(options)
+        merged_options = {
+          :message => "is expected to be a #{ symbol_class(options[:type]) } and is not."
+        }.merge(options)
+
+        super(merged_options)
+      end
+
+      # Validate that the value is the type we expect
+      #
+      # @validate_each
+      #   param: record <Object>    - subject containing attribute to validate
+      #   param: attribute <Symbol> - name of attribute to validate
+      #   param: value <Variable>   - value of attribute to validate
+      #   return: nil
+      def validate_each(record, attribute, value)
+        value_to_test = type_before_coercion(record, attribute, value)
+        expected_type = symbol_class(options[:type])
+
+        add_errors_or_raise(options, record, attribute) unless value_to_test.is_a?(expected_type)
+      end
+
+      private
+
+      # Helper method to either add messages to the errors object
+      # or raise an exception in :strict mode
+      #
+      # @add_errors_or_raise
+      #   param: options <Hash>     - options hash with strict flag or class
+      #   param: record <Object>    - subject containg attribute to validate
+      #   param: attribute <Symbol> - name of attribute under validation
+      #   return: nil
+      def add_errors_or_raise(options, record, attribute)
+        error = options_error(options[:strict])
+
+        raise error unless error.nil?
+
+        record.errors.add(attribute, options[:message])
+      end
+
+      # Helper method to return the base expected error:
+      # ActiveModel::StrictValidationFailed, a custom error, or nil
+      #
+      # @options_error
+      #   param: strict_error <true or subclass of Exception> - either the flag
+      #           to raise an error or the actual error to raise
+      #   return: custom error, ActiveModel::StrictValidationFailed, or nil
+      def options_error(strict_error)
+        if strict_error == true
+          ActiveModel::StrictValidationFailed
+        elsif strict_error.try(:ancestors).try(:include?, Exception)
+          strict_error
+        end
+      end
+
+      # Helper method to convert a symbol into a class constant
+      #
+      # ex:
+      #  symbol_class(:string)  -> String
+      #  symbol_class(:boolean) -> Boolean
+      #  symbol_class(:hash)    -> Hash
+      #
+      # @symbol_class
+      #   param: symbol <Symbol> - symbol to turn into a classconstant
+      #   return: class constant of supported types or raises UnsupportedType
+      def symbol_class(symbol)
+        @symbol_class ||= {
+          :array   => Array,
+          :boolean => Boolean,
+          :float   => Float,
+          :hash    => Hash,
+          :integer => Integer,
+          :string  => String,
+          :symbol  => Symbol,
+        }[symbol] || fail(ValidatesType::UnsupportedType,
+                          "Unsupported type #{ symbol.to_s.camelize } given for validates_type.")
+      end
+
+      # Helper method to circumvent active record's coercion
+      #
+      # @type_before_coercion
+      #   param: record <Object> - subject of validation
+      #   param: value <Variable> - current value of attribute
+      #   return: the value of the attribute before active record's coercion
+      #           or the current value
+      def type_before_coercion(record, attribute, value)
+        record.try(:"#{ attribute }_before_type_cast") || value
+      end
+    end
+
+    module ClassMethods
+      # Validates the type of an attribute with supported types:
+      #   - :array
+      #   - :boolean
+      #   - :float
+      #   - :hash
+      #   - :integer
+      #   - :string
+      #   - :symbol
+      #
+      # class Foo
+      #   include ActiveModel::Validations
+      #
+      #   attr_accessor :thing, :something
+      #
+      #   validates_type :thing, :boolean
+      #   validates_type :something, :array
+      # end
+      #
+      # @validates_type
+      #   param: attribute_name <Symbol> - name of attribute to validate
+      #   param: attribute_type <Symbol> - type of attribute to validate against
+      #   param: options <Hash>          - other common options to validate methods calls
+      #                                    i.e. message: 'my custom error message'
+      #   return: nil
+      def validates_type(attribute_name, attribute_type, options = {})
+        args = ValidatesType::Arguments.new(attribute_name, attribute_type, options)
+        validates_with TypeValidator, _merge_attributes(args.to_validation_attributes)
+      end
+    end
+  end
+end

data/spec/active_model/base_spec.rb

@@ -0,0 +1,33 @@
+require_relative '../spec_helper'
+
+describe 'ValidatesType' do
+  context 'validates_type :attribute' do
+    subject { ActiveModel::TypeValidationTestClass.set_accessor_and_long_validator(:string) }
+
+    it 'adds a validator to the subject' do
+      klass = subject.class
+      expect(klass.validators).to_not be_empty
+      expect(klass.validators).to include(ActiveModel::Validations::TypeValidator)
+    end
+
+    it 'adds the correct validator to the subject' do
+      validator = subject.class.validators.find { |v| v.is_a?(ActiveModel::Validations::TypeValidator) }
+      expect(validator.options[:type]).to eq(:string)
+    end
+  end
+
+  context 'validates :attribute, type: { type: type }.merge(other_options)' do
+    subject { ActiveModel::TypeValidationTestClass.set_accessor_and_validator(:string) }
+
+    it 'adds a validator to the subject' do
+      klass = subject.class
+      expect(klass.validators).to_not be_empty
+      expect(klass.validators).to include(ActiveModel::Validations::TypeValidator)
+    end
+
+    it 'adds the correct validator to the subject' do
+      validator = subject.class.validators.find { |v| v.is_a?(ActiveModel::Validations::TypeValidator) }
+      expect(validator.options[:type]).to eq(:string)
+    end
+  end
+end

data/spec/active_model/modifiers_spec.rb

@@ -0,0 +1,319 @@
+require_relative '../spec_helper'
+
+describe 'ValidatesType' do
+  %i[set_accessor_and_long_validator
+     set_accessor_and_validator].each do |validate_version|
+    context "#{ validate_version }" do
+      context 'custom modifiers' do
+        before do
+          subject.attribute = value
+        end
+
+        describe 'message' do
+          subject do
+            ActiveModel::TypeValidationTestClass.send(validate_version,
+              :string, message: 'is not a String!')
+          end
+
+          context 'when validation fails' do
+            let(:value) { 1 }
+
+            specify do
+              subject.validate
+              expect(subject.errors.messages[:attribute][0]).to match(/is not a String!/)
+            end
+          end
+        end
+
+        describe 'allow_nil' do
+          subject do
+            ActiveModel::TypeValidationTestClass.send(validate_version,
+              :string, allow_nil: true)
+          end
+
+          context 'field value is nil' do
+            let(:value) { nil }
+
+            specify do
+              expect(subject).to be_valid
+            end
+          end
+
+          context 'field value is not nil' do
+            context 'field value is the specified type' do
+              let(:value) { 'I am a string'}
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+
+            context 'field value is not specified type' do
+              let(:value) { -1 }
+
+              specify do
+                expect(subject).to_not be_valid
+              end
+            end
+          end
+        end
+
+        describe 'allow_blank' do
+           subject do
+            ActiveModel::TypeValidationTestClass.send(validate_version,
+              :integer, allow_blank: true)
+            end
+
+          context 'field value is nil' do
+            let(:value) { nil }
+
+            specify do
+              expect(subject).to be_valid
+            end
+          end
+
+          context 'field value is an empty string' do
+            let(:value) { '' }
+
+            specify do
+              expect(subject).to be_valid
+            end
+          end
+
+          context 'field value is not nil' do
+            context 'field value is the specified type' do
+              let(:value) { 1 }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+
+            context 'field value is not specified type' do
+              let(:value) { { foo: :bar } }
+
+              specify do
+                expect(subject).to_not be_valid
+              end
+            end
+          end
+        end
+
+        describe 'strict' do
+          subject do
+            ActiveModel::TypeValidationTestClass.send(validate_version,
+              :string, strict: true)
+          end
+
+          context 'field value is expected type' do
+            let(:value) { 'I am a string' }
+
+            specify do
+              expect do
+                subject.valid?
+              end.to_not raise_error
+            end
+          end
+
+          context 'field value is not expected type' do
+            let(:value) { -1 }
+
+            specify do
+              expect do
+                subject.valid?
+              end.to raise_error(ActiveModel::StrictValidationFailed)
+            end
+
+            context 'with a custom error class' do
+              class UhOhSpaghettios < StandardError; end
+              subject do
+                ActiveModel::TypeValidationTestClass.send(validate_version,
+                  :string, strict: UhOhSpaghettios)
+              end
+
+              specify do
+                expect do
+                  subject.valid?
+                end.to raise_error(UhOhSpaghettios)
+              end
+            end
+          end
+        end
+
+        describe 'if' do
+          subject do
+            ActiveModel::TypeValidationTestClass.send(validate_version,
+              :string, if: condition)
+          end
+
+          context 'field value is expected type' do
+            let(:value) { 'I am a string' }
+
+            context 'condition is true' do
+              let(:condition) { ->{ true } }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+
+            context 'condition is false' do
+              let(:condition) { ->{ false } }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+          end
+
+          context 'field value is not expected type' do
+            let(:value) { -1 }
+
+            context 'condition is true' do
+              let(:condition) { ->{ true } }
+
+              specify do
+                expect(subject).to_not be_valid
+              end
+            end
+
+            context 'condition is false' do
+              let(:condition) { ->{ false } }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+          end
+        end
+
+        describe 'unless' do
+          subject do
+            ActiveModel::TypeValidationTestClass.send(validate_version,
+              :string, unless: condition)
+          end
+
+          context 'field value is expected type' do
+            let(:value) { 'I am a string' }
+
+            context 'condition is true' do
+              let(:condition) { ->{ true } }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+
+            context 'condition is false' do
+              let(:condition) { ->{ false } }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+          end
+
+          context 'field value is not expected type' do
+            let(:value) { -1 }
+
+            context 'condition is true' do
+              let(:condition) { ->{ true } }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+
+            context 'condition is false' do
+              let(:condition) { ->{ false } }
+
+              specify do
+                expect(subject).to_not be_valid
+              end
+            end
+          end
+        end
+
+        describe 'on' do
+          let(:value) { nil }
+          subject do
+            ActiveModel::TypeValidationTestClass.send(validate_version,
+              :string, on: :some_test_method)
+          end
+
+          before do
+            allow(subject).to receive(:some_test_method) { subject.validate }
+          end
+
+          context 'on: criteria is met' do
+            specify do
+              expect(subject).to receive(:validate)
+              subject.some_test_method
+            end
+          end
+
+          context 'on: criteria is not met' do
+            specify do
+              expect(subject).to_not receive(:validate)
+              subject.valid?
+            end
+          end
+        end
+      end
+
+      context 'multiple custom modifiers' do
+        before do
+          subject.attribute = value
+        end
+
+        describe 'message: with if:' do
+          subject do
+            ActiveModel::TypeValidationTestClass.send(validate_version,
+              :string, message: 'This is bad!', if: condition)
+          end
+
+          context 'condition is true' do
+            let(:condition) { -> { true } }
+
+            context 'field value is the expected type' do
+              let(:value) { 'I am a string' }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+
+            context 'field value is not the expected type' do
+              let(:value) { -1 }
+
+              specify do
+                expect(subject).to_not be_valid
+                expect(subject.errors.messages[:attribute][0]).to match(/This is bad!/)
+              end
+            end
+          end
+
+          context 'condition is false' do
+            let(:condition) { -> { false } }
+
+            context 'field value is the expected type' do
+              let(:value) { 'I am a string' }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+
+            context 'field value is not the expected type' do
+              let(:value) { -1 }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end