babylonia-rails 0.0.2 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 23b9f13165bbb20bfdb7df78223d70aeac3a2786
-  data.tar.gz: 9852997ff2602bb4a6fdc3df158849ac70dfcba1
+  metadata.gz: 23a9d0abe039872a11f1cc2e55c0d4d1e50898f1
+  data.tar.gz: 256aedb91e172f3bdcc51d5e03de89dd6348408f
 SHA512:
-  metadata.gz: 75121a38895577938c5c73c80118aa150621435dd096a28d4b720de9a7ccf0a509ac17f5b48ce0ce8edf3f532b0799eabafe5a3976a5dccd6720f0dbb6bd5812
-  data.tar.gz: 8e1847e0126bd7f30da95912610795719f64e3411b1b69c6f7295bc103ac27f2f5c401becbfe8da221720ead3eb02a09a6c91b631fb182995eed8da2f55c5c7d
+  metadata.gz: 23c004c9cc8086efce000c3bfc5c37d33f660ce32aa818a30730c603076a81875b33178dafdeae4c191108c0e455fb91e33bba507145ffcd5003d1782b8cc443
+  data.tar.gz: 392d0bc2877b8ffd537acbec02d019a77d72d061025e982e98f7f92025c4c6969efc9e5629532de68608164fcb6b1a6c462d17111077f2f534d6950dd9e149da

data/README.rdoc

@@ -7,28 +7,44 @@ In your gemfile
 Or via the gem command
   gem install babylonia-rails
 
-== How to ride the rails to babylonia
-Feels like babylonia, validates like rails
+== How to Ride the Rails to Babylonia
+Feels like babylonia, validates like rails: You can use all rails validators except confirmation. Just add the validation options under :locales in the validation as you would normally do.
 
    class BabylonianFields < ActiveRecord::Base
-     build_babylonian_tower_on :grass
+     build_babylonian_tower_on :grass, :sand, :sea
      
-     validate :grass, languages: {present: [:en, :de, :it], length: 2..1000}
+     validates :grass, locales: { presence: [:en, :de, :it], length: { in: 6..20 }}
+     validates :sand, locales: { absence: [:en, :it], format: { with: /some nifty regexp/ }}
    end
    
-   I18n.locale #=> :en, so it will set en
+You can add a :locales option to each validation to determine which locales get validated with the said validator
+
+   class BabylonianFields < ActiveRecord::Base
+     build_babylonian_tower_on :grass, :sand, :sea
+     
+     validates :grass, locales: { presence: [:en, :de, :it], length: { in: 6..20, locales: [:it] }}
+     validates :sand, locales: { absence: [:en, :it], uniqueness: { scope: :some_scope, locales: [:de, :en] }}
+   end
    
-   babylonian_field = BabylonianFields.new grass: 'Hello'
-  
-   babylonian_field.valid? #=> false
-   babylonian_field.errors.full_messages #=> "Grass should also be translated in DE and IT"
-   babylonian_field.grass = {de: 'DEUTSCH', it: 'I'}
-   babylonian_field.valid? #=> false
-   babylonian_field.errors.full_messages #=> "Grass should be between 2 an 1000 characters in IT"
-   babylonian_field.grass = {it: 'IT'}
-   babylonian_field.valid? #=> true
-
-== For Basic Usage
+Yes, there's also uniqueness validation. It works with a LIKE / arel.matches query.
+
+For all the details on rails validation visit {here}[http://edgeguides.rubyonrails.org/active_record_validations.html#validation-helpers].
+
+Please be aware that validations will only validate available locales!
+
+== What About Forms?
+
+   form_for(@babylonian_field, url: {action: 'create'}) do |f|
+     f.text_field :grass_en
+     f.text_field :grass_de
+     f.text_field :grass_it
+     f.submit "Create"
+   end
+   
+== What about dynamic Finders?
+Uhhm, no. Arel itself is pretty nifty, so if you want to find something by SQL, you will.
+
+== For Further Usage
 Visit {babylonia}[http://github.com/beatrichartz/babylonia]
 
 == Contributing to babylonia-rails

data/babylonia-rails.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   
   active_record       = ENV["ACTIVE_RECORD_VERSION"] || ">= 3.2.0"
   
-  s.add_dependency              "babylonia", ">= 0.0.3"
+  s.add_dependency              "babylonia", ">= 0.1.1"
   s.add_dependency              "activerecord", active_record
   s.add_development_dependency  "bundler", ">= 1.0.0"
 end

data/lib/babylonia/rails.rb

@@ -1,4 +1,4 @@
 require 'babylonia'
 require "babylonia/rails/class_methods"
+require "babylonia/rails/validators"
 require "babylonia/rails/integration"
-require "babylonia/rails/validator"

data/lib/babylonia/rails/integration.rb

@@ -1,4 +1,5 @@
 require 'babylonia'
 require 'active_record'
 
-ActiveRecord::Base.send(:extend, Babylonia::ClassMethods)
+ActiveRecord::Base.send(:extend, Babylonia::ClassMethods)
+ActiveRecord::Base.send(:include, Babylonia::Rails::Validators)

data/lib/babylonia/rails/validators.rb

@@ -0,0 +1,2 @@
+require 'babylonia/rails/validators/locale_validator'
+require 'babylonia/rails/validators/uniqueness_validator'

data/lib/babylonia/rails/validators/locale_validator.rb

@@ -0,0 +1,62 @@
+# Rails each validator for locales
+# @params [Hash] options
+# @option [Hash] locales The validations to do on the locales of an attribute
+require 'active_model'
+
+module Babylonia
+  module Rails
+    module Validators
+      class LocalesValidator < ::ActiveModel::EachValidator
+        attr_reader :validators
+  
+        def validate_each(record, attribute, value)
+          @validators = {}
+          record.available_locales.each do |lang|
+            validations = ActiveRecord::VERSION::MAJOR < 4 ? [:acceptance, :exclusion, :format, :inclusion, :length, :numericality, :presence, :uniqueness] : [:absence, :acceptance, :exclusion, :format, :inclusion, :length, :numericality, :presence, :uniqueness]
+            validations.each do |validation|
+              add_validator validation, attribute, lang if should_validate?(validation, lang)
+            end
+          end
+    
+          validators.each do |validator, attributes|
+            if validator == :uniqueness
+              Babylonia::Rails::Validators::LocaleUniquenessValidator.new(validator_attributes(validator, attributes)).validate(record)
+            else
+              "ActiveModel::Validations::#{validator.to_s.classify}Validator".constantize.new(validator_attributes(validator, attributes)).validate(record)
+            end
+          end
+        end
+  
+        private
+  
+        def add_validator validator, attribute, lang
+          @validators ||= {}
+          if validator == :uniqueness
+            @validators[validator] ||= { attributes: {} }
+            @validators[validator][:attributes].merge! lang => attribute
+          else
+            @validators[validator] ||= { attributes: [] }
+            @validators[validator][:attributes] << :"#{attribute}_#{lang}"
+          end
+        end
+  
+        def should_validate?(option, lang)
+          if [:presence, :absence, :uniqueness, :numericality].include?(option)
+            options[option] == true || (options[option].is_a?(Array) && options[option].include?(lang)) || (options[option].is_a?(Hash) && locale_included_in_validation_options?(option, lang))
+          else
+            options[option].is_a?(Hash) && locale_included_in_validation_options?(option, lang)
+          end
+        end
+    
+        def locale_included_in_validation_options?(validation_name, lang)
+          options[validation_name][:locales].blank? || options[validation_name][:locales].include?(lang)
+        end
+  
+        def validator_attributes(validator, attributes)
+          options[validator].is_a?(Hash) ? options[validator].delete_if{|k,v| k == :locales}.merge(attributes) : attributes
+        end
+  
+      end
+    end
+  end
+end

data/lib/babylonia/rails/validators/uniqueness_validator.rb

@@ -0,0 +1,74 @@
+require 'active_record'
+
+module Babylonia
+  module Rails
+    module Validators
+      class LocaleUniquenessValidator < ::ActiveRecord::Validations::UniquenessValidator
+        
+        def validate(record)
+          (ActiveRecord::VERSION::MAJOR > 3 ? attributes : attributes.first).each do |locale, attribute|
+            value = record.read_attribute_for_validation(:"#{attribute}_#{locale}")
+            next if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
+            validate_each(record, attribute, locale, value)
+          end
+        end
+        
+        def validate_each(record, attribute, locale, value)
+          finder_class = find_finder_class_for(record)
+          table = finder_class.arel_table
+
+          relation = build_relation(finder_class, table, attribute, locale, value)
+          relation = relation.and(table[finder_class.primary_key.to_sym].not_eq(record.id)) if record.persisted?
+          if ActiveRecord::VERSION::MAJOR > 3
+            relation = scope_relation(record, table, relation)
+          else
+            Array.wrap(options[:scope]).each do |scope_item|
+              scope_value = record.read_attribute(scope_item)
+              relation = relation.and(table[scope_item].eq(scope_value))
+            end
+          end
+          relation = finder_class.unscoped.where(relation)
+          relation = relation.merge(options[:conditions]) if options[:conditions]
+
+          if relation.exists?
+            error_options = options.except(:case_sensitive, :scope, :conditions)
+            error_options[:value] = value
+
+            record.errors.add(:"#{attribute}_#{locale}", :taken, error_options)
+          end
+        end
+
+      protected
+      
+        # Copy from rails uniqueness validator
+        # The check for an existing value should be run from a class that
+        # isn't abstract. This means working down from the current class
+        # (self), to the first non-abstract class. Since classes don't know
+        # their subclasses, we have to build the hierarchy between self and
+        # the record's class.
+        def find_finder_class_for(record) #:nodoc:          
+          class_hierarchy = [record.class]
+
+          while class_hierarchy.last != @klass && class_hierarchy.last.superclass
+            class_hierarchy.push(class_hierarchy.last.superclass)
+          end
+        
+          class_hierarchy.detect { |klass| !klass.abstract_class? }
+        end
+
+        def build_relation(klass, table, attribute, locale, value) #:nodoc:
+          column = klass.columns_hash[attribute.to_s]
+          value  = klass.connection.type_cast(value, column)
+          value  = YAML.dump({locale => value}).gsub(/\A[^\n]+/, '')
+          value  = value.to_s[0, column.limit] if value && column.limit && column.text?
+          if !options[:case_sensitive] && value && column.text?
+            table[attribute].lower.matches("%#{value.respond_to?(:expr) ? value.expr : value.downcase}%")
+          else
+            value = klass.connection.case_sensitive_modifier(value) unless value.nil?
+            table[attribute].matches("%#{value.expr}%")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/babylonia/rails/version.rb

@@ -1,5 +1,5 @@
 module Babylonia
   module Rails
-    VERSION = '0.0.2'
+    VERSION = '0.1.2'
   end
 end

data/spec/babylonia-rails/integration_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 describe "Integration" do
   
-  class BabylonianField < ActiveRecord::Base
-    
+  class BabylonianIntegratedField < ActiveRecord::Base
+    self.table_name = 'babylonian_fields'
   end
   
   describe "Babylonia" do
     it "should already have extended active record" do
-      BabylonianField.should be_respond_to(:build_babylonian_tower_on)
+      BabylonianIntegratedField.should be_respond_to(:build_babylonian_tower_on)
     end
   end
   

data/spec/babylonia-rails/persistence_spec.rb

@@ -1,11 +1,12 @@
 require 'spec_helper'
 
-describe LanguagesValidator do
+describe Babylonia::Rails::Validators::LocalesValidator do
   
-  class BabylonianField < ActiveRecord::Base
+  class BabylonianPersistentField < ActiveRecord::Base
+    self.table_name = 'babylonian_fields'
     
     build_babylonian_tower_on :marshes
-    validates :marshes, languages: { present: [:de, :en, :it], length: 5..11 }
+    validates :marshes, locales: { presence: [:de, :en, :it], length: {in: 5..11} }
     
   end
   
@@ -13,7 +14,7 @@ describe LanguagesValidator do
     before(:each) do
       I18n.stub available_locales: [:de, :en, :it]
     end
-    subject { BabylonianField.new(marshes: {en: 'Hello', de: 'Hello', it: 'Hello'})}
+    subject { BabylonianPersistentField.new(marshes: {en: 'Hello', de: 'Hello', it: 'Hello'})}
     it "should be possible to store the string value" do
       subject.save!
       subject.reload

data/spec/babylonia-rails/validators/locale_validator_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+describe Babylonia::Rails::Validators::LocalesValidator do
+  let(:format_validation_options) {
+    {
+      with: /\A\z/,
+      locales: [:de, :en, :it]
+    }
+  }
+  let(:numericality_validation_options) {
+    {
+      only_integer: true,
+      locales: [:de, :en, :it]
+    }
+  }
+  let(:inclusion_validation_options) {
+    {
+      in: %w(small medium large),
+      locales: [:de, :en, :it]
+    }
+  }
+  let(:exclusion_validation_options) {
+    {
+      in: %w(big huge),
+      locales: [:de, :en, :it]
+    }
+  }
+  let(:length_validation_options) {
+    {
+      in: 5..11,
+      locales: [:de, :en, :it]
+    }
+  }
+  let(:validation_options) {
+    {
+      presence: [:de, :en, :it],
+      absence: [:pi, :gb, :er],
+      format: format_validation_options,
+      numericality: numericality_validation_options,
+      inclusion: inclusion_validation_options,
+      exclusion: exclusion_validation_options,
+      length: length_validation_options
+    }
+  }
+  
+  class BabylonianField < ActiveRecord::Base
+
+    build_babylonian_tower_on :marshes
+
+    class << self
+      attr_accessor :installed_validations
+      def install_validations(options)
+        self.installed_validations = true
+        validates :marshes, locales: options
+      end
+    end
+
+  end
+  
+  class BabylonianSecondField < ActiveRecord::Base
+    self.table_name = 'babylonian_fields'
+    
+    build_babylonian_tower_on :marshes
+
+    class << self
+      attr_accessor :installed_validations
+      def install_validations(options)
+        self.installed_validations = true
+        validates :marshes, locales: options
+      end
+    end
+  end
+  
+  class BabylonianThirdField < ActiveRecord::Base
+    self.table_name = 'babylonian_fields'
+    
+    build_babylonian_tower_on :marshes
+
+    class << self
+      attr_accessor :installed_validations
+      def install_validations(options)
+        self.installed_validations = true
+        validates :marshes, allow_nil: true, locales: options
+      end
+    end
+  end
+  
+  before(:each) do
+    I18n.stub available_locales: [:de, :en, :it, :pi, :gb, :er]
+    # it is not allowed to access structures created by let in before(:all), but installing the validators on each run is also not
+    # the way to go.
+    BabylonianField.install_validations(validation_options) unless BabylonianField.installed_validations
+    BabylonianSecondField.install_validations(validation_options) unless BabylonianSecondField.installed_validations
+    BabylonianThirdField.install_validations(validation_options) unless BabylonianThirdField.installed_validations
+  end
+  
+  describe "rails validations except confirmation, acceptance and uniqueness" do
+    subject { BabylonianField.new }
+    let(:format_validator) { double('format_validator') }
+    let(:inclusion_validator) { double('inclusion_validator') }
+    let(:exclusion_validator) { double('exlusion_validator') }
+    let(:length_validator) { double('length_validator') }
+    let(:presence_validator) { double('presence_validator') }
+    let(:absence_validator) { double('absence_validator') }
+    let(:numericality_validator) { double('absence_validator') }
+    
+    it "should pass them on to the rails validators" do
+      [:format, :inclusion, :exclusion, :length, :numericality].each do |validator|
+        options = send(:"#{validator}_validation_options")
+        attributes = options[:locales].map{|l| :"marshes_#{l}"}
+        "ActiveModel::Validations::#{validator.to_s.classify}Validator".constantize.should_receive(:new).with(options.dup.delete_if{|k,v| k == :locales}.merge(attributes: attributes)).and_return(send(:"#{validator}_validator"))
+        send(:"#{validator}_validator").should_receive(:validate).with(subject)
+      end
+      ActiveModel::Validations::PresenceValidator.should_receive(:new).with(attributes: [:marshes_de,:marshes_en,:marshes_it]).and_return(presence_validator)
+      presence_validator.should_receive(:validate).with(subject)
+      unless ActiveRecord::VERSION::MAJOR < 4
+        ActiveModel::Validations::AbsenceValidator.should_receive(:new).with(attributes: [:marshes_pi,:marshes_gb,:marshes_er]).and_return(absence_validator)
+        absence_validator.should_receive(:validate).with(subject)
+      end
+      subject.valid? #=> this will be true since all calls are mocked
+    end
+    context "integration" do
+      context "with defaults" do
+        subject { BabylonianSecondField.new }
+        it "should work for all kinds of errors" do
+          subject.should_not be_valid
+          [:de, :en, :it].each do |lang|
+            subject.errors[:"marshes_#{lang}"].should == ["is not included in the list", "is too short (minimum is 5 characters)", "is not a number", "can't be blank"]
+          end
+        end
+      end
+      context "with allow_nil set to true" do
+        subject { BabylonianThirdField.new }
+        it "should allow blank" do
+          subject.should be_valid
+          subject.errors.should be_blank
+        end
+      end
+    end
+
+  end
+  
+  
+end

data/spec/babylonia-rails/validators/uniqueness_validator_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe Babylonia::Rails::Validators::LocaleUniquenessValidator do
+  let(:case_sensitive_validation_options) {
+    {
+      uniqueness: {
+        locales: [:de, :en, :fr]
+      }
+    }
+  }
+  let(:case_insensitive_validation_options) {
+    {
+      uniqueness: {
+        case_sensitive: false,
+        locales: [:de, :en, :fr]
+      }
+    }
+  }
+  let(:scoped_validation_options) {
+    {
+      uniqueness: {
+        scope: :some_value,
+        case_sensitive: false,
+        locales: [:de, :en, :fr]
+      }
+    }
+  }
+  
+  class BabylonianUniqueField < ActiveRecord::Base
+    self.table_name = 'babylonian_fields'
+
+    build_babylonian_tower_on :marshes
+
+    class << self
+      attr_accessor :installed_validations
+      def install_validations(options)
+        self.installed_validations = true
+        validates :marshes, locales: options
+      end
+    end
+
+  end
+  
+  class BabylonianUniqueSecondField < ActiveRecord::Base
+    self.table_name = 'babylonian_fields'
+    
+    build_babylonian_tower_on :marshes
+
+    class << self
+      attr_accessor :installed_validations
+      def install_validations(options)
+        self.installed_validations = true
+        validates :marshes, locales: options
+      end
+    end
+  end
+  
+  class BabylonianUniqueThirdField < ActiveRecord::Base
+    self.table_name = 'babylonian_fields'
+    
+    build_babylonian_tower_on :marshes
+
+    class << self
+      attr_accessor :installed_validations
+      def install_validations(options)
+        self.installed_validations = true
+        validates :marshes, allow_nil: true, locales: options
+      end
+    end
+  end
+  
+  before(:each) do
+    I18n.stub available_locales: [:de, :en, :it, :pi, :fr, :er]
+    # it is not allowed to access structures created by let in before(:all), but installing the validators on each run is also not
+    # the way to go.
+    BabylonianUniqueField.install_validations(case_insensitive_validation_options) unless BabylonianUniqueField.installed_validations
+    BabylonianUniqueSecondField.install_validations(case_sensitive_validation_options) unless BabylonianUniqueSecondField.installed_validations
+    BabylonianUniqueThirdField.install_validations(scoped_validation_options) unless BabylonianUniqueThirdField.installed_validations
+  end
+  
+  describe "case insensitive uniqueness validation" do
+    let(:attributes) { { marshes: {en: "Hello, I'm a string!", de: "Hallo,\nIch bin ein Faden!", fr: "Bonjour: Je suis un fil" } } }
+    let(:duplicate_attributes) { { marshes: {en: "hello, I'm a string!", de: "Hallo,\nich bin ein faden!", fr: "Bonjour: je suis un fil" } } }
+    context "with an existing record" do
+      let!(:existing) { BabylonianUniqueField.create(attributes) }
+      subject { BabylonianUniqueField.new(duplicate_attributes) }
+      after(:each) do
+        existing.destroy
+      end
+      it "should validate the records uniqueness" do
+        subject.should_not be_valid
+        subject.errors.full_messages.should == ["Marshes de has already been taken", "Marshes en has already been taken", "Marshes fr has already been taken"]
+      end
+    end
+    context "with no existing record" do
+      subject { BabylonianUniqueField.new(duplicate_attributes) }
+      it "should validate the records uniqueness" do
+        subject.should be_valid
+      end
+    end
+  end
+  
+  describe "case sensitive uniqueness validation" do
+    let(:attributes) { { marshes: {en: "Hello, I'm a string!", de: "Hallo,\nIch bin ein Faden!", fr: "Bonjour: Je suis un fil" } } }
+    let(:other_case_attributes) { { marshes: {en: "hello, I'm a string!", de: "Hallo,\nich bin ein faden!", fr: "Bonjour: je suis un fil" } } }
+    context "with an existing record" do
+      let!(:existing) { BabylonianUniqueSecondField.create(attributes) }
+      subject { BabylonianUniqueSecondField.new(attributes) }
+      after(:each) do
+        existing.destroy
+      end
+      it "should validate the records uniqueness" do
+        subject.should_not be_valid
+        subject.errors.full_messages.should == ["Marshes de has already been taken", "Marshes en has already been taken", "Marshes fr has already been taken"]
+      end
+    end
+    context "with an existing record with differently cased attributes" do
+      let!(:existing) { BabylonianUniqueSecondField.create(attributes) }
+      subject { BabylonianUniqueSecondField.new(other_case_attributes) }
+      after(:each) do
+        existing.destroy
+      end
+      it "should validate the records uniqueness" do
+        subject.should be_valid
+      end
+    end
+    context "with no existing record" do
+      subject { BabylonianUniqueSecondField.new(attributes) }
+      it "should validate the records uniqueness" do
+        subject.should be_valid
+      end
+    end
+  end
+  
+  describe "scoped uniqueness validation" do
+    let(:attributes) { { marshes: {en: "Hello, I'm a string!", de: "Hallo,\nIch bin ein Faden!", fr: "Bonjour: Je suis un fil" }, some_value: true } }
+    let(:same_scope_attributes) { { marshes: {en: "hello, I'm a string!", de: "Hallo,\nich bin ein faden!", fr: "Bonjour: je suis un fil" }, some_value: true } }
+    let(:other_scope_attributes) { { marshes: {en: "hello, I'm a string!", de: "Hallo,\nich bin ein faden!", fr: "Bonjour: je suis un fil" }, some_value: false } }
+    context "with an existing record" do
+      let!(:existing) { BabylonianUniqueThirdField.create(attributes) }
+      subject { BabylonianUniqueThirdField.new(same_scope_attributes) }
+      after(:each) do
+        existing.destroy
+      end
+      it "should validate the records uniqueness" do
+        subject.should_not be_valid
+        subject.errors.full_messages.should == ["Marshes de has already been taken", "Marshes en has already been taken", "Marshes fr has already been taken"]
+      end
+    end
+    context "with an existing record in another scope" do
+      let!(:existing) { BabylonianUniqueThirdField.create(attributes) }
+      subject { BabylonianUniqueThirdField.new(other_scope_attributes) }
+      after(:each) do
+        existing.destroy
+      end
+      it "should validate the records uniqueness" do
+        subject.should be_valid
+      end
+    end
+    context "with no existing record" do
+      subject { BabylonianUniqueThirdField.new(attributes) }
+      it "should validate the records uniqueness" do
+        subject.should be_valid
+      end
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -18,12 +18,13 @@ module HelperMethods
   
 end
 
+require File.expand_path('./support/tables.rb', File.dirname(__FILE__))
+
 RSpec.configure do |configuration|
   include HelperMethods
   configuration.before(:suite) do
     ActiveRecord::Base.configurations = YAML.load_file(File.expand_path('./support/database.yml', File.dirname(__FILE__)))
     ActiveRecord::Base.establish_connection(:test)
-    require File.expand_path('./support/tables.rb', File.dirname(__FILE__))
 
     CreateTestTables.new.up
   end

data/spec/support/tables.rb

@@ -1,7 +1,8 @@
 class CreateTestTables < ActiveRecord::Migration
   def up
-    create_table :babylonian_fields do |t|
+    create_table :babylonian_fields, options: 'ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin' do |t|
       t.text :marshes
+      t.boolean :some_value
       t.timestamps
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: babylonia-rails
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.2
 platform: ruby
 authors:
 - Beat Richartz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-20 00:00:00.000000000 Z
+date: 2013-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: babylonia
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.0.3
+        version: 0.1.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 0.0.3
+        version: 0.1.1
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -71,11 +71,14 @@ files:
 - lib/babylonia/rails.rb
 - lib/babylonia/rails/class_methods.rb
 - lib/babylonia/rails/integration.rb
-- lib/babylonia/rails/validator.rb
+- lib/babylonia/rails/validators.rb
+- lib/babylonia/rails/validators/locale_validator.rb
+- lib/babylonia/rails/validators/uniqueness_validator.rb
 - lib/babylonia/rails/version.rb
 - spec/babylonia-rails/integration_spec.rb
 - spec/babylonia-rails/persistence_spec.rb
-- spec/babylonia-rails/validator_spec.rb
+- spec/babylonia-rails/validators/locale_validator_spec.rb
+- spec/babylonia-rails/validators/uniqueness_validator_spec.rb
 - spec/spec_helper.rb
 - spec/support/database.yml
 - spec/support/tables.rb
@@ -106,7 +109,8 @@ summary: Let there be languages for your rails users!
 test_files:
 - spec/babylonia-rails/integration_spec.rb
 - spec/babylonia-rails/persistence_spec.rb
-- spec/babylonia-rails/validator_spec.rb
+- spec/babylonia-rails/validators/locale_validator_spec.rb
+- spec/babylonia-rails/validators/uniqueness_validator_spec.rb
 - spec/spec_helper.rb
 - spec/support/database.yml
 - spec/support/tables.rb

data/lib/babylonia/rails/validator.rb

@@ -1,42 +0,0 @@
-class LanguagesValidator < ActiveModel::EachValidator
-  def validate_each(record, attribute, value)
-    validate_languages_present(record, attribute, options[:present].sort) if options[:present]
-    validate_length_in_range(record, attribute, options[:length]) if options[:length].is_a?(Range)
-  end
-  
-  private
-  
-  def validate_languages_present(record, attribute, languages)
-    is     = record_attribute_languages(record, attribute)
-    unless is == languages
-      record.errors[attribute] << (options[:message] || "should be filled in #{(languages - is).map(&:upcase).to_sentence}")
-      (languages - is).each do |lang|
-        record.errors[:"#{attribute}_#{lang}"] << (options[:message] || "should be filled")
-      end
-    end
-  end
-  
-  def validate_length_in_range(record, attribute, range)
-    all          = record_attribute_languages(record, attribute)
-    in_range     = keys_not_matching(record, attribute){|k,v| !range.include?(v.size) }
-    unless all.empty? || all == in_range
-      record.errors[attribute] << (options[:message] || "should be between #{range.first} and #{range.last} characters in #{(all - in_range).map(&:upcase).to_sentence}")
-      (all - in_range).each do |lang|
-        record.errors[:"#{attribute}_#{lang}"] << (options[:message] || "should be between #{range.first} and #{range.last} characters")
-      end
-    end
-  end
-  
-  def keys_not_matching record, attribute, &block
-    not_matching = record_attribute_hash(record, attribute).dup.delete_if &block
-    not_matching.keys.sort
-  end
-  
-  def record_attribute_hash record, attribute
-    record.send(:"#{attribute}_hash")
-  end
-  
-  def record_attribute_languages record, attribute
-    record.send(:"#{attribute}_languages").sort
-  end
-end

data/spec/babylonia-rails/validator_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-describe LanguagesValidator do
-  
-  class BabylonianField < ActiveRecord::Base
-    
-    build_babylonian_tower_on :marshes
-    validates :marshes, languages: { present: [:de, :en, :it], length: 5..11 }
-    
-  end
-  
-  describe "validations" do
-    subject { BabylonianField.new(marshes: "Hello") }
-    before(:each) do
-      I18n.stub locale: :en, available_locales: [:de, :en, :it]
-    end
-    context "presence validations" do
-      context "when invalid" do
-        it "should indicate which languages are not translated" do
-          subject.should_not be_valid
-          subject.errors[:marshes].first.should == "should be filled in DE and IT"
-          subject.errors[:marshes_en].should be_empty
-          subject.errors[:marshes_de].first.should == "should be filled"
-          subject.errors[:marshes_it].first.should == "should be filled"
-        end
-        it "should indicate remaining incomplete languages if some are updated" do
-          subject.marshes = {it: 'SOMETHING'}
-          subject.should_not be_valid
-          subject.errors[:marshes].first.should == "should be filled in DE"
-          subject.errors[:marshes_en].should be_empty
-          subject.errors[:marshes_it].should be_empty
-          subject.errors[:marshes_de].first.should == "should be filled"
-        end
-        it "should work when attributes are deleted" do
-          subject.marshes = ''
-          subject.should_not be_valid
-          subject.errors[:marshes].first.should == "should be filled in DE, EN, and IT"
-          subject.errors[:marshes_en].first.should == "should be filled"
-          subject.errors[:marshes_de].first.should == "should be filled"
-          subject.errors[:marshes_it].first.should == "should be filled"
-        end
-      end
-      context "when valid" do
-        before(:each) do
-          subject.marshes = {en: 'Hello', de: 'Hello', it: 'Hello'}
-        end
-        it "should be valid" do
-          subject.should be_valid
-        end
-      end
-    end
-    context "length validations" do
-      before(:each) do
-        subject.marshes = {en: 'H', de: 'Hello', it: 'Hlo'}
-      end
-      context "when invalid" do
-        it "should indicate that the languages that are not in length" do
-          subject.should_not be_valid
-          subject.errors[:marshes].first.should == "should be between 5 and 11 characters in EN and IT"
-          subject.errors[:marshes_en].first.should == "should be between 5 and 11 characters"
-          subject.errors[:marshes_it].first.should == "should be between 5 and 11 characters"
-        end
-      end
-      context "when valid" do
-        before(:each) do
-          subject.marshes = {en: 'HelloHelloH', de: 'Hello', it: 'Hello'}
-        end
-        it "should be valid" do
-          subject.should be_valid
-        end
-      end
-    end
-  end
-  
-  
-end