validates_serialized 0.0.1.pre2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NDEyNjVmMjdlZjJiMGZjZjhjNDk5Yjc1NGQ2MDY1MzkwNGFjZjgwMw==
+  data.tar.gz: !binary |-
+    NzMyMzBmNTBlYzk1MjY4ZTk3NGUxYTBkNDAxMTBhMzllMjIyZmM3YQ==
+SHA512:
+  metadata.gz: !binary |-
+    ZTdiOTliMTI2ZmMzOWY4Y2E3MWU4MjZmMTQ2YWY0NjBkMDU5NzViNGExOGNm
+    ZWRiMTE0Y2JiOTYwNzg2N2MyNGYwZDJlYzAwMzg4MzliZDM0YmI5OTczM2Zm
+    Nzc5NDcyOTU2ZjcxNTZlNWFhNzM2YWMxY2MzNzZkZWY1M2E5ZTI=
+  data.tar.gz: !binary |-
+    NTc2Yjg0NzY2OTAwMjFiMzA2MjE0MWQ2ODdiZGI4NzY3MWFjYmI2MTcxZjg2
+    NjBlZGUwODVjMTZhYjZjMTc4MGExMTQ3ZWRhMjI4YTRjNGY2YTI5NmY3YTc3
+    ODFkY2QxYjMwNmE0YzI5NWE5ZjZlNGRhZDJjNGUyNmM1MjkyMzU=

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.ruby-gemset

@@ -0,0 +1 @@
+validates_serialized_gem

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3-p545

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,46 @@
+PATH
+  remote: .
+  specs:
+    validates_serialized (0.0.0)
+      activemodel (>= 4.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.1.8)
+      activesupport (= 4.1.8)
+      builder (~> 3.1)
+    activesupport (4.1.8)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    builder (3.2.2)
+    diff-lcs (1.2.5)
+    i18n (0.6.11)
+    json (1.8.1)
+    minitest (5.5.0)
+    rake (10.4.2)
+    rspec (2.99.0)
+      rspec-core (~> 2.99.0)
+      rspec-expectations (~> 2.99.0)
+      rspec-mocks (~> 2.99.0)
+    rspec-core (2.99.2)
+    rspec-expectations (2.99.2)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.99.2)
+    sqlite3 (1.3.10)
+    thread_safe (0.3.4)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.5)
+  rake (~> 10.1)
+  rspec (~> 2.6)
+  sqlite3 (~> 1.3)
+  validates_serialized!

data/README.md

@@ -0,0 +1,151 @@
+# Validates Serialized
+
+ActiveModel provides ways to validate attributes, and to serialize objects.  This gem provides some ActiveModel extensions and syntactic sugar to simplify the process of validating those serialized objects.
+
+This gem provides:
+  * A generic validation method that supports any serializable object
+  * A validation method for serialized hashes, to validate specific key values
+  * A validation method for serialized hashes, to support validating all hash values
+  * A validation method for serialized arrays, to support validating all array values
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'validates_serialized', '~> 0.0.1'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install validates_serialized
+
+## Validating a generic object
+
+Here we have an example, serializable class called 'Person' with a name and age attribute.
+
+```ruby
+class Person
+  def initialize(h={})
+    h.each {|k,v| send("#{k}=",v)}
+  end
+
+  def name
+    @name ||= nil
+  end
+
+  def name=(val)
+    @name = val
+  end
+
+  def age
+    @age ||= nil
+  end
+
+  def age=(val)
+    @age = val
+  end
+end
+```
+
+Now we can serialize this object and validate its properties in another class
+
+```ruby
+class Family < ActiveRecord::Base
+  include ActiveModel
+  ...
+
+  serialize :father, Person
+  validates_serialized :father do
+    validates :name, presence: true
+    validates :age, numericality: { greater_than: 21 }
+  end
+end
+```
+The validations will be run against the serialized object whenever validation hooks are fired.  E.g.
+
+```ruby
+# With valid serialized object
+valid_father = Person.new(name: "Bob", age: 31)
+family = Family.new(father: valid_father)
+family.valid? #=> true
+
+# With invalid serialized object
+valid_father = Person.new(name: "Bob", age: 13)
+family = Family.new(father: valid_father)
+family.valid? #=> false
+family.errors[:father] #=> ["age must be greater than 13"]
+```
+
+## Validating a serialized hash by keys
+```ruby
+class Comment < ActiveRecord::Base
+  include ActiveModel
+  ...
+
+  serialize :metadata, Hash
+  validates_hash_keys :metadata do
+    validates :timestamp, presence: true
+    validates :locale, presence: true
+  end
+end
+
+# With valid hash
+comment = Comment.new(metadata: { timestamp: Time.new(2014, 1, 1), locale: "Ohio" })
+comment.valid? #=> true
+
+# With invalid hash
+comment = Comment.new(metadata: { timestamp: Time.new(2014, 1, 1), locale: nil })
+comment.valid? #=> false
+comment.errors[:metadata] #=> ["locale can't be blank"]
+```
+
+## Validating serialized hash values
+```ruby
+class Comment < ActiveRecord::Base
+  include ActiveModel
+  ...
+
+  serialize :ratings, Hash
+  validates_hash_values_with :ratings, numericality: { greater_than: 0 }
+end
+
+# With valid hash
+comment = Comment.new(ratings: { tom: 4, jim: 2 })
+comment.valid? #=> true
+
+# With invalid hash
+comment = Comment.new(ratings: { tom: 4, jim: -1 })
+comment.valid? #=> false
+comment.errors[:ratings] #=> ["ratings must be greater than 0"]
+```
+
+## Validating a serialized array
+```ruby
+class Comment < ActiveRecord::Base
+  include ActiveModel
+  ...
+
+  serialize :tags, Array
+  validates_array_values_with :tags, length: { minimum: 4 }
+end
+
+# With valid hash
+comment = Comment.new(tags: ["ruby" "rails"])
+comment.valid? #=> true
+
+# With invalid hash
+comment = Comment.new(tags: ["ruby" "rails", "ror"])
+comment.valid? #=> false
+comment.errors[:tags] #=> ["tags is too short (minimum is 4 characters)"]
+```
+
+## Contributing
+
+1. Fork it
+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/lib/validates_serialized/each_validator.rb

@@ -0,0 +1,20 @@
+require "active_model"
+
+module ActiveModel
+  # Extending ActiveModel's EachValidator to add +validate_each_in_array+
+  class EachValidator #:nodoc:
+    # Performs validation on the supplied record. By default this will call
+    # +validates_each+ to determine validity therefore subclasses should
+    # override +validates_each+ with validation logic.
+    def validate_each_in_array(record)
+      attributes.each do |attribute|
+        array = record.read_attribute_for_validation(attribute)
+        raise TypeError, "#{array} is not an array" unless array.is_a?(Array)
+        array.each_with_index do |value, index|
+          next if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
+          validate_each(record, :"#{attribute}[#{index}]", value)
+        end
+      end
+    end
+  end
+end

data/lib/validates_serialized/validateable_array.rb

@@ -0,0 +1,9 @@
+require 'active_model'
+
+class ValidateableArray < Array
+  include ::ActiveModel::Validations
+
+  def initialize(array)
+    @array = array
+  end
+end

data/lib/validates_serialized/validateable_hash.rb

@@ -0,0 +1,15 @@
+require 'active_model'
+
+class ValidateableHash < Hash
+  include ::ActiveModel::Validations
+
+  def initialize(hash)
+    @hash = hash
+  end
+
+  private
+  def method_missing(method, *args, &block)
+    # Delegate all methods to access the hash
+    @hash[method]
+  end
+end

data/lib/validates_serialized/validateable_object.rb

@@ -0,0 +1,14 @@
+require 'active_model'
+
+class ValidateableObject
+  include ::ActiveModel::Validations
+
+  def initialize(object)
+    @object = object
+  end
+
+  private
+  def method_missing(method, *args, &block)
+    @object.send(method, *args, &block)
+  end
+end

data/lib/validates_serialized/validators/array_validator.rb

@@ -0,0 +1,78 @@
+module ActiveModel
+  module Validations
+    class ArrayValidator < SerializedValidator #:nodoc:
+      protected
+      def validate_serialized(record, attribute, serialized)
+        serialized.each do |value|
+          next if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
+          validate_each(record, attribute, value)
+        end
+      end
+
+      def type_check!(value)
+        raise TypeError, "#{value} is not an Array" unless value.is_a?(Array)
+      end
+    end
+
+    module ClassMethods
+      def validates_array_values_with(*args, &block)
+        # TODO: It would be nice for these to all make a call to 'validates_serialized_with'
+        #    so that there's more code re-use
+        # validates_serialized_with args.push(ArrayValidator), &block
+
+        options = args.extract_options!
+        options[:class] = self
+
+        validator = ArrayValidator.new(args, options, &block)
+
+        if validator.respond_to?(:attributes) && !validator.attributes.empty?
+          validator.attributes.each do |attribute|
+            _validators[attribute.to_sym] << validator
+          end
+        else
+          _validators[nil] << validator
+        end
+
+        validate(validator, options)
+      end
+
+      # Helper to accept arguments in the style of the +validates+ class method
+      def validates_array_values(*attributes)
+        defaults = attributes.extract_options!.dup
+        validations = defaults.slice!(*_validates_default_keys)
+
+        raise ArgumentError, "You need to supply at least one attribute" if attributes.empty?
+        raise ArgumentError, "You need to supply at least one validation" if validations.empty?
+
+        defaults[:attributes] = attributes
+
+        validations.each do |key, options|
+          next unless options
+          key = "#{key.to_s.camelize}Validator"
+
+          begin
+            validator = key.include?('::') ? key.constantize : const_get(key)
+          rescue NameError
+            raise ArgumentError, "Unknown validator: '#{key}'"
+          end
+
+          validates_array_values_with(validator, defaults.merge(_parse_validates_options(options)))
+        end
+      end
+
+      def validates_array_values!(*attributes)
+        options = attributes.extract_options!
+        options[:strict] = true
+        validates_array_values(*(attributes << options))
+      end
+    end
+
+    def validates_array_values_with(*args, &block)
+      options = args.extract_options!
+      args.each do |klass|
+        validator = ArrayValidator.new(args, options, &block)
+        validator.validate(self)
+      end
+    end
+  end
+end

data/lib/validates_serialized/validators/hash_block_validator.rb

@@ -0,0 +1,59 @@
+module ActiveModel
+  module Validations
+    class HashBlockValidator < BlockValidator #:nodoc:
+      def initialize(options, &block)
+        @block = block
+        @options = options
+        super
+      end
+
+      private
+      def validate_each(record, attribute, value)
+        raise TypeError, "#{attribute} is not a Hash" unless value.is_a?(Hash)
+        error_hash = get_serialized_object_errors(value)
+        add_errors_to_record(record, attribute, error_hash)
+      end
+
+      def get_serialized_object_errors(value)
+        serialized_object = ValidateableHash.new(value)
+        serialized_object.class_eval &@block
+        serialized_object.valid?
+        serialized_object.errors.messages
+      end
+
+      def add_errors_to_record(record, attribute, error_hash)
+        error_hash.each_pair do |key, array|
+          text = array.join(", ")
+          message = "#{key} #{text}"
+          if exception = options[:strict]
+            exception = ActiveModel::StrictValidationFailed if exception == true
+            raise exception, message
+          end
+          record.errors.add(attribute, message)
+        end
+      end
+
+      def get_message_from_error_hash(error_hash)
+        message = nil
+        error_hash.each_pair do |key, array|
+          message = array.join(", ")
+        end
+        message
+      end
+    end
+
+    module ClassMethods
+      # Helper to accept arguments in the style of the +validates+ class method
+      def validates_hash_keys(*attr_names, &block)
+        raise ArgumentError, "You need to supply at least one attribute" if attr_names.empty?
+        validates_with HashBlockValidator, _merge_attributes(attr_names), &block
+      end
+
+      def validates_hash_keys!(*attr_names, &block)
+        options = attr_names.extract_options!
+        options[:strict] = true
+        validates_hash_keys(*(attr_names << options), &block)
+      end
+    end
+  end
+end

data/lib/validates_serialized/validators/hash_validator.rb

@@ -0,0 +1,75 @@
+module ActiveModel
+  module Validations
+    class HashValidator < SerializedValidator #:nodoc:
+      protected
+      def validate_serialized(record, attribute, serialized)
+        serialized.each_pair do |key, value|
+          next if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
+          validate_each(record, attribute, value)
+        end
+      end
+
+      def type_check!(value)
+        raise TypeError, "#{value} is not a Hash" unless value.is_a?(Hash)
+      end
+    end
+
+    module ClassMethods
+      def validates_hash_values_with(*args, &block)
+        options = args.extract_options!
+        options[:class] = self
+
+        validator = HashValidator.new(args, options, &block)
+
+        if validator.respond_to?(:attributes) && !validator.attributes.empty?
+          validator.attributes.each do |attribute|
+            _validators[attribute.to_sym] << validator
+          end
+        else
+          _validators[nil] << validator
+        end
+
+        validate(validator, options)
+      end
+
+
+      # Helper to accept arguments in the style of the +validates+ class method
+      def validates_hash_values(*attributes)
+        defaults = attributes.extract_options!.dup
+        validations = defaults.slice!(*_validates_default_keys)
+
+        raise ArgumentError, "You need to supply at least one attribute" if attributes.empty?
+        raise ArgumentError, "You need to supply at least one validation" if validations.empty?
+
+        defaults[:attributes] = attributes
+
+        validations.each do |key, options|
+          next unless options
+          key = "#{key.to_s.camelize}Validator"
+
+          begin
+            validator = key.include?('::') ? key.constantize : const_get(key)
+          rescue NameError
+            raise ArgumentError, "Unknown validator: '#{key}'"
+          end
+
+          validates_hash_values_with(validator, defaults.merge(_parse_validates_options(options)))
+        end
+      end
+
+      def validates_hash_values!(*attributes)
+        options = attributes.extract_options!
+        options[:strict] = true
+        validates_hash_values(*(attributes << options))
+      end
+    end
+
+    def validates_hash_values_with(*args, &block)
+      options = args.extract_options!
+      args.each do |klass|
+        validator = HashValidator.new(args, options, &block)
+        validator.validate(self)
+      end
+    end
+  end
+end