validates_serialized 0.0.1.pre2

data/lib/validates_serialized/validators/object_block_validator.rb

@@ -0,0 +1,58 @@
+module ActiveModel
+  module Validations
+    class ObjectBlockValidator < BlockValidator #:nodoc:
+      def initialize(options, &block)
+        @block = block
+        @options = options
+        super
+      end
+
+      private
+      def validate_each(record, attribute, value)
+        error_hash = get_serialized_object_errors(value)
+        add_errors_to_record(record, attribute, error_hash)
+      end
+
+      def get_serialized_object_errors(value)
+        serialized_object = ValidateableObject.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_serialized(*attr_names, &block)
+        raise ArgumentError, "You need to supply at least one attribute" if attr_names.empty?
+        validates_with ObjectBlockValidator, _merge_attributes(attr_names), &block
+      end
+
+      def validates_serialized!(*attr_names, &block)
+        options = attr_names.extract_options!
+        options[:strict] = true
+        validates_serialized(*(attr_names << options), &block)
+      end
+    end
+  end
+end

data/lib/validates_serialized/validators/serialized_validator.rb

@@ -0,0 +1,73 @@
+module ActiveModel
+  module Validations
+    # Special case of EachValidator that exists to allow other EachValidators to validate
+    # individual properties of a serialized object
+    class SerializedValidator < ::ActiveModel::EachValidator #:nodoc:
+      def initialize(*args, &block)
+        #TODO: Need a method for extracting serialized_attributes
+        @serialized_attributes = nil
+        options = args.extract_options!
+        @validators = []
+        args.first.each do |klass|
+          validator = klass.new(options.dup, &block)
+          @validators << validator
+        end
+        super(options)
+      end
+
+      def validate(record)
+        attributes.each do |attribute|
+          serialized = record.read_attribute_for_validation(attribute)
+          type_check!(serialized)
+          validate_serialized(record, attribute, serialized)
+        end
+      end
+
+      def validate_each(record, attribute, value)
+        @validators.each do |validator|
+          validator.validate_each(record, attribute, value)
+        end
+      end
+
+      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 Object" unless array.is_a?(Object)
+      end
+    end
+
+    module ClassMethods
+      def validates_serialized_with(*args, &block)
+        options = args.extract_options!
+        options[:class] = self
+        serialized_validator_class = args.shift
+        validator = serialized_validator_class.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
+    end
+
+    def validates_serialized_with!(*args, &block)
+      options = args.extract_options!
+      serialized_validator_class = args.shift
+      args.each do |klass|
+        validator = serialized_validator_class.new(args, options, &block)
+        validator.validate(self)
+      end
+    end
+  end
+end

data/lib/validates_serialized/version.rb

@@ -0,0 +1,3 @@
+module ValidatesSerialized
+  VERSION = "0.0.1.pre2"
+end

data/lib/validates_serialized.rb

@@ -0,0 +1,10 @@
+require 'validates_serialized/version'
+require 'validates_serialized/validateable_array'
+require 'validates_serialized/validateable_hash'
+require 'validates_serialized/validateable_object'
+require 'validates_serialized/each_validator'
+require 'validates_serialized/validators/serialized_validator'
+require 'validates_serialized/validators/array_validator'
+require 'validates_serialized/validators/hash_validator'
+require 'validates_serialized/validators/hash_block_validator'
+require 'validates_serialized/validators/object_block_validator'

data/notes.md

@@ -0,0 +1,5 @@
+1)  The 'validates' method iterates over each of the validations and passes along the parsed information to 'validates_with'
+
+2)  Validates_array should mimic the 'validates' method in this regard, but call 'validates_array_values_with' (which will do what 'validates_with' does, but by iterating over each value)
+
+TODO:  Look up/copy 'def validates_with' to understand that function and duplicate its functionality.

data/spec/acceptance_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+class Author
+  def initialize(h={})
+    h.each {|k,v| send("#{k}=",v)}
+  end
+
+  def name
+    @name ||= nil
+  end
+
+  def name=(val)
+    @name = val
+  end
+end
+
+class Blog
+  include ActiveModel::Validations
+
+  def initialize(h={})
+    h.each {|k,v| send("#{k}=",v)}
+  end
+
+  def author
+    @author
+  end
+
+  def author=(val)
+    @author = val
+  end
+
+  def ratings
+    @ratings
+  end
+
+  def ratings=(val)
+    @ratings = val
+  end
+
+  def comments
+    @comments
+  end
+
+  def comments=(val)
+    @comments = val
+  end
+
+  validates_serialized :author do
+    validates :name, presence: true
+  end
+  validates_array_values :ratings, inclusion: { in: [1, 2, 3] }
+  validates_hash_keys :comments, allow_blank: true do 
+    validates :admin, presence: true
+  end
+end
+
+describe ValidatesSerialized do
+  it "is valid with all params" do
+    model = Blog.new(ratings: [1, 3, 1], author: Author.new(name: "Tom"), comments: { admin: "This is great!" })
+    model.should be_valid
+  end
+
+  it "is valid without comments" do
+    model = Blog.new(ratings: [1, 3, 1], author: Author.new(name: "Tom"))
+    model.should be_valid
+  end
+
+  it "raises error without Serialized author" do
+    model = Blog.new(ratings: [1, 3, 1], comments: { admin: "This is great!" })
+    expect { model.valid? }.to raise_error
+  end
+
+  it "is invalid without author name" do
+    model = Blog.new(ratings: [1, 3, 1], author: Author.new, comments: { admin: "This is great!" })
+    model.should_not be_valid
+    model.errors[:author].should eq(["name can't be blank"])
+  end
+
+  it "is invalid without comment admin key" do
+    model = Blog.new(ratings: [1, 3, 1], author: Author.new(name: "Tom"), comments: { other: "This is great!" })
+    model.should_not be_valid
+    model.errors[:comments].should eq(["admin can't be blank"])
+  end
+
+  it "raises error without ratings" do
+    model = Blog.new(ratings: nil, author: Author.new(name: "Tom"), comments: { admin: "This is great!" })
+    expect { model.valid? }.to raise_error
+  end
+
+  it "is invalid with invalid ratings value" do
+    model = Blog.new(ratings: [1, 8], author: Author.new(name: "Tom"), comments: { admin: "This is great!" })
+    model.should_not be_valid
+    model.errors[:ratings].should eq(["is not included in the list"])
+  end
+end

data/spec/each_validator_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'ostruct'
+
+class MyValidator < ::ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    if invalid_format?(value)
+      record.errors.add(attribute, "is an invalid email")
+    end
+  end
+
+  def invalid_format?(email)
+    email !~ /.*\@gmail\.com/
+  end
+end
+
+class MyTestClass < OpenStruct
+  include ActiveModel::Validations
+end
+
+describe ActiveModel::EachValidator do
+  describe "#validate_each_in_array" do
+    it "does not add errors for all valid values" do
+      record = MyTestClass.new(my_attr: ["tom@gmail.com"])
+      MyValidator.new(attributes: [:my_attr]).validate_each_in_array(record)
+      record.errors.should be_empty
+    end
+
+    it "adds errors for single invalid value" do
+      record = MyTestClass.new(my_attr: ["tom"])
+      MyValidator.new(attributes: [:my_attr]).validate_each_in_array(record)
+      record.errors[:"my_attr[0]"].should eq(["is an invalid email"])
+    end
+
+    it "adds errors for multiple invalid value" do
+      record = MyTestClass.new(my_attr: ["tom", "rob@gmail.com", "steve@email.com"])
+      MyValidator.new(attributes: [:my_attr]).validate_each_in_array(record)
+      record.errors[:"my_attr[0]"].should eq(["is an invalid email"])
+      record.errors[:"my_attr[1]"].should eq([])
+      record.errors[:"my_attr[2]"].should eq(["is an invalid email"])
+    end
+
+    it "raises TypeError for non array" do
+      record = MyTestClass.new(my_attr: {email: "tom"})
+      expect { MyValidator.new(attributes: [:my_attr]).validate_each_in_array(record) }.to raise_error(TypeError, '{:email=>"tom"} is not an array')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'validates_serialized'
+
+spec = Gem::Specification.find_by_name("validates_serialized")
+gem_root = spec.gem_dir
+Dir[("#{gem_root}/spec/support/**/*.rb")].each {|f| require f}
+I18n.config.enforce_available_locales = true
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+end

data/spec/validateable_array_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe ValidateableArray do
+  let!(:array) { Array.new }
+
+  subject { described_class.new(array) }
+
+  it "responds to valid?" do
+    subject.should be_valid
+  end
+
+  it "responds to .errors" do
+    subject.errors.should be_empty
+  end
+end

data/spec/validateable_hash_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe ValidateableHash do
+  let!(:hash) { { key_1: "boy", key_2: "girl" } }
+
+  subject { described_class.new(hash) }
+
+  it "responds to valid?" do
+    subject.should be_valid
+  end
+
+  it "responds to .errors" do
+    subject.errors.should be_empty
+  end
+
+  describe "attributes" do
+    it "defines key_1 attribute" do
+      subject.key_1.should eq("boy")
+    end
+
+    it "defines key_2 attribute" do
+      subject.key_2.should eq("girl")
+    end
+
+    it "returns nil for non-existent key_3" do
+      subject.key_3.should be_nil
+    end
+  end
+
+  describe "validation block" do
+    it "validates when passes validation methods" do
+      subject.class_eval do
+        validates :key_1, presence: true
+      end
+      subject.should be_valid
+    end
+
+    it "handles errors when invalid" do
+      subject.class_eval do
+        validates :key_1, inclusion: { in: [ 'a', 'b', 'c' ] }
+      end
+      subject.should_not be_valid
+      subject.errors[:key_1].should eq(["is not included in the list"])
+    end
+
+    it "is invalid when validating non-existent property" do
+      subject.class_eval do
+        validates :other_key, inclusion: { in: [ 'a', 'b', 'c' ] }
+      end
+      subject.should_not be_valid
+      subject.errors[:other_key].should eq(["is not included in the list"])
+    end
+  end
+end

data/spec/validateable_object_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe ValidateableObject do
+  class TestPerson
+    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
+
+  let!(:object) { TestPerson.new(age: 26, name: "Thomas") }
+
+  subject { described_class.new(object) }
+
+  it "responds to valid?" do
+    subject.should be_valid
+  end
+
+  it "responds to .errors" do
+    subject.errors.should be_empty
+  end
+
+  describe "delegating attributes" do
+    it "delegates age attribute" do
+      subject.age.should eq(26)
+    end
+
+    it "delegates name attribute" do
+      subject.name.should eq("Thomas")
+    end
+  end
+
+  describe "validation block" do
+    it "validates when passes validation methods" do
+      subject.class_eval do
+        validates :name, presence: true
+        validates :age, presence: true
+      end
+      subject.should be_valid
+    end
+
+    it "handles errors when invalid" do
+      subject.class_eval do
+        validates :name, inclusion: { in: [ 'a', 'b', 'c' ] }
+      end
+      subject.should_not be_valid
+      subject.errors[:name].should eq(["is not included in the list"])
+    end
+
+    it "raises error when validating non-existent property" do
+      subject.class_eval do
+        validates :other_property, inclusion: { in: [ 'a', 'b', 'c' ] }
+      end
+      expect { subject.valid? }.to raise_error(NoMethodError)
+    end
+  end
+end