mongoid-verbalize 0.0.1

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Rakefile

@@ -0,0 +1,25 @@
+require 'rspec/core/rake_task'
+require 'yard'
+
+spec = Gem::Specification.load("mongoid-verbalize.gemspec")
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+YARD::Rake::YardocTask.new(:doc)
+
+desc "Build the .gem file"
+task :build do
+  system "gem build #{spec.name}.gemspec"
+end
+
+desc "Push the .gem file to rubygems.org"
+task :release => :build do
+  system "gem push #{spec.name}-#{spec.version}.gem"
+end
+
+desc "Open an irb session"
+task :console do
+  sh "irb -rubygems -I lib -r ./spec/spec_helper.rb"
+end

data/lib/mongoid/verbalize.rb

@@ -0,0 +1,36 @@
+require 'mongoid/verbalize/fields'
+require 'mongoid/verbalize/translated_string'
+require 'mongoid/verbalize/selector'
+require 'mongoid/verbalize/verbalized_validator'
+require 'mongoid/verbalize/verbalized_version'
+require 'mongoid/verbalize/versioning'
+
+module Mongoid
+  module Verbalize
+    extend ActiveSupport::Concern
+    
+    included do
+      include Mongoid::Verbalize::Fields
+
+      Mongoid::Fields.option :use_default_if_empty do |model, field, value| end
+    end
+  
+    module ClassMethods
+      def verbalized_field(name, options = {})
+        field(name, options.merge(:type => TranslatedString, :default => {}))
+      end
+
+      def validates_default_locale(names, options = {})
+        validates_with VerbalizedValidator, options.merge(:mode => :only_default, :attributes => names)
+      end
+
+      def validates_one_locale(names, options = {})
+        validates_with VerbalizedValidator, options.merge(:mode => :one_locale,   :attributes => names)
+      end
+
+      def validates_all_locales(names, options = {})
+        validates_with VerbalizedValidator, options.merge(:mode => :all_locales,  :attributes => names)
+      end
+    end
+  end
+end

data/lib/mongoid/verbalize/fields.rb

@@ -0,0 +1,75 @@
+module Mongoid
+  module Verbalize
+    module Fields
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+      protected
+
+        # Monkey patch for Mongoid method
+        def create_accessors(name, meth, options = {})
+          # Let Mongoid do its thing
+          super
+
+          return unless options[:type] == Mongoid::Verbalize::TranslatedString
+
+          field = fields[name]
+
+          create_verbalized_field_getter(name, meth, field)
+          create_verbalized_field_setter(name, meth, field)
+          
+          create_verbalized_translations_getter(name, meth, field)
+
+          create_verbalized_translations_raw_getter(name, meth)
+          create_verbalized_translations_raw_setter(name, meth)
+        end
+
+        def create_verbalized_field_getter(name, meth, field)
+          generated_methods.module_eval do
+            define_method("#{meth}") do
+              raw = read_attribute(name)
+              field_value = field.demongoize(raw)
+              field_value.current_locale_value(field.options[:use_default_if_empty])
+            end
+          end
+        end
+
+        def create_verbalized_field_setter(name, meth, field)
+          generated_methods.module_eval do
+            define_method("#{meth}=") do |value|
+              raw = read_attribute(name)
+              field_value = field.demongoize(raw)
+              field_value.current_locale_value = value
+              write_attribute(name, field_value)
+            end
+          end
+        end
+
+        def create_verbalized_translations_getter(name, meth, field)
+          generated_methods.module_eval do
+            define_method("#{meth}_translations") do
+              field.demongoize(read_attribute(name))
+            end
+          end
+        end
+
+        def create_verbalized_translations_raw_getter(name, meth)
+          generated_methods.module_eval do
+            define_method("#{meth}_translations_raw") do
+              read_attribute(name)
+            end
+          end
+        end
+
+        def create_verbalized_translations_raw_setter(name, meth)
+          generated_methods.module_eval do
+            define_method("#{meth}_translations_raw=") do |values|
+              write_attribute(name, values)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/verbalize/selector.rb

@@ -0,0 +1,14 @@
+module Origin
+  class Selector
+  
+  private
+
+    def normalized_key(key, serializer)
+      if serializer.type == Mongoid::Verbalize::TranslatedString
+        "#{key}.#{::I18n.locale}.value"
+      else
+        super
+      end
+    end
+  end
+end

data/lib/mongoid/verbalize/translated_string.rb

@@ -0,0 +1,137 @@
+module Mongoid
+  module Verbalize
+    # Strongly-typed accessor for this structure:
+    # {
+    #   'en' => { "value" => "Title",  "versions" => [ { "version" => 0, "value" => 'Title' } ] },
+    #   'es' => { "value" => "Título", "versions" => [ { "version" => 0, "value" => 'Título' } ] },
+    # }
+    class TranslatedString
+      class LocalizedValue
+        attr_accessor :current_value, :versions
+
+        def initialize(current_value=nil, versions=[])
+          @current_value = current_value
+          @versions = versions
+        end
+
+        def changed?
+          previous_version = versions.last
+          previous_version.nil? || previous_version.value != current_value
+        end
+
+        def add_version(new_version_number)
+          versions.push(LocalizedVersion.new(new_version_number, current_value))
+        end
+
+        def find_version(version)
+          versions.find_all { |v| v.version <= version }.last
+        end
+      end
+
+      LocalizedVersion = Struct.new(:version, :value)
+
+      attr_reader :localized_values
+
+      def initialize(localized_values)
+        @localized_values = localized_values
+      end
+
+      def find_version(language, version)
+        localized_value = @localized_values[language]
+        return unless localized_value.present?
+        
+        localized_value.find_version(version)
+      end
+
+      # Return translated value of field, accoring to current locale.
+      # If :use_default_if_empty is set, then in case when there no
+      # translation available for current locale, if will try to
+      # get translation for defalt_locale.
+      def current_locale_value(use_default_if_empty)
+        lookups = [self.class.current_locale]
+
+        # TODO: Add I18n.fallbacks support instead of :use_default_if_empty
+        if use_default_if_empty
+          lookups.push(::I18n.default_locale)
+        end
+        
+        # Find first localized value in lookup path
+        localized_value = @localized_values[lookups.find { |l| @localized_values[l] }]
+        return nil if localized_value.nil?
+
+        localized_value.current_value
+      end
+      def current_locale_value=(value)
+        current_value.current_value = value
+      end
+
+      # Called when determining whether to create a new version.
+      def changed?
+        @localized_values.values.any?(&:changed?)
+      end
+
+      # Creates a new version for changed values
+      def prepare_for_save(new_version_number)
+        @localized_values.values.select(&:changed?).each do |v|
+          v.add_version(new_version_number)
+        end
+      end
+
+      # Converts an object of this instance into a database friendly value.
+      def mongoize
+        @localized_values.each_with_object({}) do |(key, value), h|
+          h[key.to_s] = {
+            'value' => value.current_value,
+            'versions' => value.versions.map do |v|
+              { 'version' => v.version, 'value' => v.value }
+            end
+          }
+        end
+      end
+
+      class << self
+        # Get the object as it was stored in the database, and instantiate
+        # this custom class from it.
+        def demongoize(object)
+          localized_values = object.each_with_object({}) do |(key, value), h|
+            versions = (value['versions'] || []).map do |v|
+              LocalizedVersion.new(v['version'], v['value'])
+            end
+            h[key.to_sym] = LocalizedValue.new(value['value'], versions)
+          end
+          TranslatedString.new(localized_values)
+        end
+
+        # Takes any possible object and converts it to how it would be
+        # stored in the database.
+        def mongoize(object)
+          case object
+          when TranslatedString then object.mongoize
+          else object
+          end
+        end
+
+        # Converts the object that was supplied to a criteria and converts it
+        # into a database friendly form.
+        def evolve(object)
+          case object
+          when TranslatedString then object.mongoize.current_locale_value
+          else object
+          end
+        end
+
+        # Return current locale as string
+        def current_locale
+          ::I18n.locale
+        end
+      end
+
+    private
+
+      # TODO: Rename this method.
+      def current_value
+        @localized_values[self.class.current_locale] ||= LocalizedValue.new
+      end
+    end
+  end
+end

data/lib/mongoid/verbalize/verbalized_validator.rb

@@ -0,0 +1,27 @@
+module Mongoid
+  module Verbalize
+    class VerbalizedValidator < ActiveModel::EachValidator
+      def validate_each record, attribute, value
+        if options[:mode] == :only_default
+          if record.send("#{attribute}_translations_raw")[::I18n.default_locale.to_s].blank?
+            record.errors.add(attribute, :locale_blank, options.except(:mode).merge(
+              :cur_locale => ::I18n.t(:"locales.#{::I18n.default_locale}", :default => ::I18n.default_locale.to_s)
+            ))
+          end
+        elsif options[:mode] == :one_locale
+          record.errors.add(attribute, :all_locales_blank, options.except(:mode)) if record.send("#{attribute}_translations_raw").empty?
+        elsif options[:mode] == :all_locales
+          #difference between available locales and stored locales
+          diffloc = ::I18n.available_locales - record.send("#{attribute}_translations_raw").keys.collect { |key| key.to_sym }
+
+          #print an error for each missing locale
+          diffloc.each do |locale| 
+            record.errors.add(attribute, :locale_blank, options.except(:mode).merge(
+              :cur_locale => ::I18n.t(:"locales.#{locale}", :default => locale.to_s)
+            )) 
+          end
+        end
+      end	
+    end	
+  end
+end

data/lib/mongoid/verbalize/verbalized_version.rb

@@ -0,0 +1,7 @@
+module Mongoid::Verbalize
+  class VerbalizedVersion
+    include Mongoid::Document    
+    embedded_in :versionable, :polymorphic => true
+    field :version, :type => Integer
+  end
+end

data/lib/mongoid/verbalize/versioning.rb

@@ -0,0 +1,85 @@
+module Mongoid
+  module Verbalize
+    module Versioning
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveSupport::Callbacks
+
+        define_callbacks :create_version
+        embeds_many :verbalized_versions, :as => :versionable,
+          :class_name => 'Mongoid::Verbalize::VerbalizedVersion'
+        before_save :create_new_version
+      end
+
+      module ClassMethods
+        def verbalized_fields(document)
+          document.class.fields.reject { |name, field| field.options[:type] != TranslatedString }
+        end
+        
+        def verbalized_children(document)
+          document._children.reject { |child| !child.class.include?(Mongoid::Verbalize) }
+        end
+        
+        def verbalized_field_values(document)
+          verbalized_fields(document).map do |name, field|
+            document.send("#{field.name}_translations")
+          end
+        end
+        
+        def iterate_verbalized_fields(document, &block)
+          verbalized_fields(document).each do |name, field|
+            yield document, field
+          end
+        end
+      end
+
+    private
+
+      def create_new_version
+        return if embedded? # Only do this on the root document
+
+        # Do a first pass to see if any verbalized field has changed
+        any_field_changed = false
+        iterate_all_verbalized_fields do |document, field|
+          any_field_changed = true if field.demongoize(document.read_attribute(field.name)).changed?
+        end
+        return unless any_field_changed
+
+        run_callbacks :create_version do
+          # Calculate new version number
+          previous_version = self.verbalized_versions.last.version if self.verbalized_versions.last.present?
+          next_version_number = previous_version.present? ? previous_version + 1 : 0
+          self.verbalized_versions.build(:version => next_version_number)
+        
+          # Apply this new version number to verbalized fields
+          iterate_all_verbalized_fields do |document, field|
+            field_value = field.demongoize(document.read_attribute(field.name))
+            field_value.prepare_for_save(next_version_number)
+            document.write_attribute(field.name, field_value)
+          end
+        end
+
+        # Reset _children so that Mongoid persists verbalized_versions correctly
+        @_children = nil
+      end
+
+      def all_verbalized_field_values
+        [self.class.verbalized_field_values(self) + self.class.verbalized_children(self).map do |child|
+          self.class.verbalized_field_values(child)
+        end].flatten
+      end
+      
+      def iterate_all_verbalized_fields(&block)
+        self.class.iterate_verbalized_fields(self, &block)
+        self.class.verbalized_children(self).each do |child|
+          self.class.iterate_verbalized_fields(child, &block)
+        end
+      end
+      
+      def current_version
+        self.verbalized_versions.last.version
+      end
+    end
+  end
+end

data/spec/mongoid/verbalize_spec.rb

@@ -0,0 +1,600 @@
+# encoding: utf-8
+require 'spec_helper'
+
+class Entry
+  include Mongoid::Document
+  include Mongoid::Verbalize
+  include Mongoid::Verbalize::Versioning
+
+  field :weight, :type => Integer, :default => 60
+
+  verbalized_field :title
+  verbalized_field :title_with_default, :use_default_if_empty => true
+end
+
+class EntryWithValidations
+  include Mongoid::Document
+  include Mongoid::Verbalize
+  include Mongoid::Verbalize::Versioning
+
+  verbalized_field :title_validated_with_default_locale
+  verbalized_field :title_validated_with_one_locale
+  verbalized_field :title_validated_with_all_locales
+
+  validates_default_locale  :title_validated_with_default_locale
+  validates_one_locale      :title_validated_with_one_locale
+  validates_all_locales     :title_validated_with_all_locales
+end
+
+describe Mongoid::Verbalize, "verbalized_field" do
+  before do
+    I18n.locale = :en
+  end
+
+  describe "without an assigned value" do
+    before do
+      @entry = Entry.new
+    end
+
+    it "should return blank" do
+      @entry.title.should be_blank
+    end
+  end
+
+  describe "with an assigned value" do
+    before do
+      @entry = Entry.new(:title => 'Title')
+    end
+
+    it "should return that value" do
+      @entry.title.should == 'Title'
+    end
+
+    describe "and persisted" do
+      before do
+        @entry.save
+      end
+
+      describe "find by id" do
+        it "should find the document" do
+          Entry.find(@entry.id).should == @entry
+        end
+      end
+
+      describe "where() criteria" do
+        it "should use the current locale value" do
+          query = Entry.where(:title => 'Title')
+          Entry.where(:title => 'Title').first.should == @entry
+        end
+      end
+    end
+
+    describe "when the locale is changed" do
+      before do
+        I18n.locale = :es
+      end
+
+      it "should return a blank value" do
+        @entry.title.should be_blank
+      end
+
+      describe "a new value is assigned" do
+        before do
+          @entry.title = 'Título'
+        end
+
+        it "should return the new value" do
+          @entry.title.should == 'Título'
+        end
+
+        describe "persisted and retrieved from db" do
+          before do
+            @entry.save
+            @entry.reload
+          end
+
+          it "the localized field value should be correct" do
+            @entry.title.should == 'Título'
+            I18n.locale = :en
+            @entry.title.should == 'Title'
+            @entry.title_translations_raw.should == {
+              'en' => { "value" => "Title",  "versions" => [ { "version" => 0, "value" => 'Title' } ] },
+              'es' => { "value" => "Título", "versions" => [ { "version" => 0, "value" => 'Título' } ] },
+            }
+            @entry.verbalized_versions.should have(1).item
+          end
+        end
+
+        describe "field translations hash" do
+          context "before saving" do
+            it "should return all translations without versions" do
+              @entry.title_translations_raw.should == {
+                'en' => { "value" => "Title", "versions" => [] },
+                'es' => { "value" => "Título", "versions" => [] },
+              }
+            end
+          end
+          
+          context "after saving" do
+            before do
+              @entry.save
+              @entry.reload
+            end
+
+            it "should return all translations with versions" do
+              @entry.title_translations_raw.should == {
+                'en' => { "value" => "Title",  "versions" => [ { "version" => 0, "value" => 'Title' } ] },
+                'es' => { "value" => "Título", "versions" => [ { "version" => 0, "value" => 'Título' } ] },
+              }
+            end
+          end
+        end
+        
+        describe "field translations" do
+          context "before saving" do
+            it "should return all translations without versions" do
+              @entry.title_translations.should be_instance_of(
+                Mongoid::Verbalize::TranslatedString)
+              @entry.title_translations.localized_values[:en].should be_instance_of(
+                Mongoid::Verbalize::TranslatedString::LocalizedValue)
+              @entry.title_translations.localized_values[:en].current_value.should == 'Title'
+              @entry.title_translations.localized_values[:en].versions.should == []
+              @entry.title_translations.localized_values[:es].should be_instance_of(
+                Mongoid::Verbalize::TranslatedString::LocalizedValue)
+              @entry.title_translations.localized_values[:es].current_value.should == 'Título'
+              @entry.title_translations.localized_values[:es].versions.should == []
+            end
+          end
+          
+          context "after saving" do
+            before do
+              @entry.save
+              @entry.reload
+            end
+
+            it "should return all translations with versions" do
+              @entry.title_translations.localized_values[:en].should be_instance_of(
+                Mongoid::Verbalize::TranslatedString::LocalizedValue)
+              @entry.title_translations.localized_values[:en].current_value.should == 'Title'
+              @entry.title_translations.localized_values[:en].versions.should have(1).item
+              @entry.title_translations.localized_values[:en].versions[0].should be_instance_of(
+                Mongoid::Verbalize::TranslatedString::LocalizedVersion)
+              @entry.title_translations.localized_values[:en].versions[0].version.should == 0
+              @entry.title_translations.localized_values[:en].versions[0].value.should == 'Title'
+              @entry.title_translations.localized_values[:es].should be_instance_of(
+                Mongoid::Verbalize::TranslatedString::LocalizedValue)
+              @entry.title_translations.localized_values[:es].current_value.should == 'Título'
+              @entry.title_translations.localized_values[:es].versions.should have(1).item
+              @entry.title_translations.localized_values[:es].versions[0].should be_instance_of(
+                Mongoid::Verbalize::TranslatedString::LocalizedVersion)
+              @entry.title_translations.localized_values[:es].versions[0].version.should == 0
+              @entry.title_translations.localized_values[:es].versions[0].value.should == 'Título'
+            end
+          end
+        end
+
+        describe "with mass-assigned translations" do
+          before do
+            @entry.title_translations_raw = {
+              'en' => { "value" => "Title",  "versions" => [ { "version" => 0, "value" => 'Title' } ] },
+              'es' => { "value" => "Nuevo título", "versions" => [ { "version" => 0, "value" => 'Nuevo título' } ] },
+            }
+          end
+
+          it "should set all translations" do
+            @entry.title_translations_raw.should == {
+              'en' => { "value" => "Title",  "versions" => [ { "version" => 0, "value" => 'Title' } ] },
+              'es' => { "value" => "Nuevo título", "versions" => [ { "version" => 0, "value" => 'Nuevo título' } ] },
+            }
+          end
+
+          it "the getter should return the new translation" do
+            @entry.title.should == 'Nuevo título'
+          end
+        end
+
+        describe "if we go back to the original locale" do
+          before do
+            I18n.locale = :en
+          end
+
+          it "should return the original value" do
+            @entry.title.should == 'Title'
+          end
+        end
+      end
+    end
+  end
+end
+
+describe Mongoid::Verbalize do
+  before do
+    I18n.locale = :en
+  end
+  
+  describe "versions" do
+    before { @entry = Entry.new }
+    subject { @entry }
+    
+    describe "document versions" do
+      before do
+        @entry.title = 'foo'
+        @entry.save
+      end
+      
+      its(:verbalized_versions) { should have(1).item }
+    end
+    
+    describe "when field is updated twice without saving" do
+      before do
+        @entry.title = 'foo'
+        @entry.title = 'bar'
+        @expected_translations = {
+          'en' => { "value" => 'bar', 'versions' => [] }
+        }
+      end
+      
+      its(:title_translations_raw) { should == @expected_translations }
+    end
+    
+    describe "when field is not updated" do
+      before do
+        @entry.title = 'foo'
+        @entry.title_with_default = 'bar'
+        I18n.locale = :es
+        @entry.title = 'spanishfoo'
+        I18n.locale = :en
+        @entry.save
+        @entry.title = 'baz'
+        @entry.save
+        @expected_title_translations = {
+          'en' => {
+            "value" => "baz",
+            "versions" => [
+              { "version" => 0, "value" => 'foo' },
+              { "version" => 1, "value" => 'baz' }
+            ]
+          },
+          'es' => {
+            "value" => "spanishfoo",
+            "versions" => [
+              { "version" => 0, "value" => 'spanishfoo' }
+            ]
+          }
+        }
+        @expected_title_with_default_translations = {
+          'en' => {
+            "value" => "bar",
+            "versions" => [
+              { "version" => 0, "value" => 'bar' }
+            ]
+          }
+        }
+      end
+      
+      its(:title_translations_raw) { should == @expected_title_translations }
+      its(:title_with_default_translations_raw) { should == @expected_title_with_default_translations }
+    end
+    
+    describe "when field is updated, saved, updated, and then saved" do
+      before do
+        @entry.title = 'foo'
+        @entry.save
+        @entry.title = 'bar'
+        @entry.save
+        @expected_translations = {
+          'en' => {
+            "value" => "bar",
+            "versions" => [
+              { "version" => 0, "value" => 'foo' },
+              { "version" => 1, "value" => 'bar' }
+            ]
+          }
+        }
+      end
+      
+      its(:title_translations_raw) { should == @expected_translations }
+    end
+    
+    describe "when field is updated with the same value" do
+      before do
+        @entry.title = 'foo'
+        @entry.save
+        @entry.title = 'foo'
+        @entry.save
+        @expected_translations = {
+          'en' => {
+            "value" => "foo",
+            "versions" => [
+              { "version" => 0, "value" => 'foo' }
+            ]
+          }
+        }
+      end
+      
+      its(:title_translations_raw) { should == @expected_translations }
+      its(:verbalized_versions) { should have(1).item }
+    end
+    
+    describe "embedded document" do
+      before do
+        class Entry
+          include Mongoid::Document
+          include Mongoid::Verbalize
+          include Mongoid::Verbalize::Versioning
+          
+          verbalized_field :title
+          embeds_many :sub_entries
+        end
+
+        class SubEntry
+          include Mongoid::Document
+          include Mongoid::Verbalize
+          verbalized_field :subtitle
+          embedded_in :entry
+        end
+        @entry = Entry.new(:title => 'Selfridges')
+        @sub_entry = @entry.sub_entries.build(:subtitle => 'Oxford Street')
+        @entry.save
+        @entry.save
+        @entry.reload
+        @sub_entry = @entry.sub_entries.first
+        @expected_title_translations = {
+          'en' => {
+            "value" => "Selfridges",
+            "versions" => [
+              { "version" => 0, "value" => 'Selfridges' }
+            ]
+          }
+        }
+        @expected_subtitle_translations = {
+          'en' => {
+            "value" => "Oxford Street",
+            "versions" => [
+              { "version" => 0, "value" => 'Oxford Street' }
+            ]
+          }
+        }
+      end
+      
+      describe "entry" do
+        subject { @entry }
+        its(:verbalized_versions) { should have(1).item }
+        its(:title_translations_raw) { should == @expected_title_translations }
+      end
+      
+      describe "subentry" do
+        subject { @sub_entry }
+        it { should_not respond_to(:verbalized_versions) }
+        its(:subtitle_translations_raw) { should == @expected_subtitle_translations }
+      end
+      
+      describe "when subentry is updated" do
+        before do
+          @sub_entry.subtitle = 'Regent Street'
+          @entry.save
+          #@entry.reload
+        end
+        
+        describe "entry" do
+          subject { @entry }
+          its(:verbalized_versions) { should have(2).items }
+          its("verbalized_versions.first.version") { should == 0 }
+          its("verbalized_versions.second.version") { should == 1 }
+        end
+      end
+    end
+  end
+end
+
+describe Mongoid::Verbalize, 'localized field in embedded association' do
+  before do
+    class Entry
+      embeds_many :sub_entries
+    end
+
+    class SubEntry
+      include Mongoid::Document
+      include Mongoid::Verbalize
+      verbalized_field :title
+      embedded_in :entry, :inverse_of => :sub_entries
+    end
+    @entry = Entry.new
+    @sub_entries = (0..2).map { @entry.sub_entries.build }
+  end
+
+  it "should contain the embedded documents" do
+    @entry.sub_entries.criteria.instance_variable_get("@documents").should == @sub_entries
+  end
+end
+
+describe Mongoid::Verbalize, 'localized field in embedded document' do
+  before do
+    class Entry
+      embeds_one :sub_entry
+    end
+
+    class SubEntry
+      include Mongoid::Document
+      include Mongoid::Verbalize
+      verbalized_field :subtitle
+      embedded_in :entry, :inverse_of => :sub_entries
+    end
+    @entry = Entry.new
+    @entry.create_sub_entry(:subtitle => 'Oxford Street')
+  end
+
+  it "should store the title in the right locale" do
+    @entry.reload.sub_entry.subtitle.should == 'Oxford Street'
+  end
+end
+
+describe Mongoid::Verbalize, "verbalized_field with :use_default_if_empty => true" do
+  before do
+    I18n.default_locale = :en
+    I18n.locale = :en
+  end
+
+  describe "without an assigned value" do
+    before do
+      @entry = Entry.new
+    end
+
+    it "should return blank" do
+      @entry.title_with_default.should be_blank
+    end
+  end
+
+  describe "with an assigned value in the default locale" do
+    before do
+      @entry = Entry.new(:title_with_default => 'Title with default')
+    end
+
+    it "should return that value with the default locale" do
+      @entry.title_with_default.should == 'Title with default'
+    end
+
+    describe "when the locale is changed" do
+      before do
+        I18n.locale = :it
+      end
+
+      it "should return the value of the default locale" do
+        @entry.title_with_default.should == 'Title with default'
+      end
+
+      describe "when a new value is assigned" do
+        before do
+          @entry.title_with_default = 'Titolo con default'
+        end
+
+        it "should return the new value" do
+          @entry.title_with_default.should == 'Titolo con default'
+        end
+
+        describe "if we go back to the original locale" do
+          before do
+            I18n.locale = :en
+          end
+
+          it "should return the original value" do
+            @entry.title_with_default.should == 'Title with default'
+          end
+        end
+      end
+    end
+  end
+end
+
+describe Mongoid::Verbalize, "verbalized_field with validation 'validates_default_locale'" do
+  before do
+    I18n.default_locale = :en
+    I18n.locale = :it
+    @entry = EntryWithValidations.new
+  end
+
+  describe "when run entry validations and default locale translation wasn't set" do
+    before do
+      @entry.title_validated_with_default_locale = "Titolo"
+      @entry.valid?
+    end
+
+    it "is added a 'locale_blank' error for that field to entry errors list" do
+      @entry.errors.include?(:title_validated_with_default_locale).should be_true
+      @entry.errors[:title_validated_with_default_locale][0].split('.').last.should == 'locale_blank'
+    end
+  end
+
+  describe "when run entry validations and default locale translation was set" do
+    before do
+      @entry.title_validated_with_default_locale_translations_raw={'en'=>'Title'}
+      @entry.valid?
+    end
+
+    it "no error for that field is added to entry errors list" do
+      @entry.errors.include?(:title_validated_with_default_locale).should be_false
+    end
+  end
+end
+
+describe Mongoid::Verbalize, "verbalized_field with validation 'validates_one_locale'" do
+  before do
+    I18n.default_locale = :en
+    I18n.locale = :it
+    @entry = EntryWithValidations.new
+  end
+
+  describe "when run entry validations and no translation was set" do
+    before do
+      @entry.valid?
+    end
+
+    it "is added a 'locale_blank' error for that field to entry errors list" do
+      @entry.errors.include?(:title_validated_with_one_locale).should be_true
+      @entry.errors[:title_validated_with_one_locale][0].split('.').last.should == 'all_locales_blank'
+    end
+  end
+
+  describe "when run entry validations and a locale translation was set" do
+    before do
+      @entry.title_validated_with_one_locale_translations_raw={'it'=>'Titolo'}
+      @entry.valid?
+    end
+
+    it "no error for that field is added to entry errors list" do
+      @entry.errors.include?(:title_validated_with_one_locale).should be_false
+    end
+  end
+end
+
+describe Mongoid::Verbalize, "verbalized_field with validation 'validates_all_locales'" do
+  before do
+    I18n.default_locale = :en
+    I18n.available_locales = [:en, :it, :de, :fr]
+    I18n.locale = :it
+    @entry = EntryWithValidations.new
+  end
+
+  describe "when run entry validations and not all translations were set" do
+    before do
+      @entry.title_validated_with_all_locales_translations_raw={'it'=>'Titolo', 'en'=>'Title'}
+      @entry.valid?
+    end
+
+    it "is added a 'locale_blank' error for that field for each missing locale" do
+      @entry.errors.include?(:title_validated_with_all_locales).should be_true
+      @entry.errors[:title_validated_with_all_locales].count.should == 2
+      @entry.errors[:title_validated_with_all_locales][0].split('.').last.should == 'locale_blank'
+      @entry.errors[:title_validated_with_all_locales][1].split('.').last.should == 'locale_blank'
+    end
+  end
+
+  describe "when run entry validations and all available locales translation were set" do
+    before do
+      @entry.title_validated_with_all_locales_translations_raw={'it'=>'Titolo', 'en'=>'Title', 'fr'=>'Titre', 'de'=>'Titel'}
+      @entry.valid?
+    end
+
+    it "no error for that field is added to entry errors list" do
+      @entry.errors.include?(:title_validated_with_all_locales).should be_false
+    end
+  end
+end
+
+describe Mongoid::Verbalize, "create_accessors" do
+  before do
+    I18n.locale = :en
+    @entry = Entry.new
+  end
+
+  it "should not affect other fields accessors" do
+    @entry.weight.should == 60
+
+    @entry.weight = 70
+    @entry.weight.should == 70
+  end
+
+  it "should not define own methods on for fields" do
+    @entry.should_not respond_to :weight_translations
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'mongoid'
+require 'mongoid/verbalize'
+
+require 'rspec'
+
+Mongoid.configure do |config|
+  config.connect_to('mongoid_verbalize_test')
+end
+# Mongoid.logger = Logger.new($stdout)
+# Mongoid.logger.level = Logger::DEBUG
+# Moped.logger.level = Logger::DEBUG
+# Moped.logger = Logger.new($stdout)
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.after(:each) { Mongoid.purge! }
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: mongoid-verbalize
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Tim Jones
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - <=
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - <=
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Fine-grained versioning and localization for Mongoid documents
+email:
+- tim@timjones.tw
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mongoid/verbalize/fields.rb
+- lib/mongoid/verbalize/selector.rb
+- lib/mongoid/verbalize/translated_string.rb
+- lib/mongoid/verbalize/verbalized_validator.rb
+- lib/mongoid/verbalize/verbalized_version.rb
+- lib/mongoid/verbalize/versioning.rb
+- lib/mongoid/verbalize.rb
+- spec/mongoid/verbalize_spec.rb
+- spec/spec_helper.rb
+- LICENSE
+- README.md
+- Rakefile
+- Gemfile
+- .rspec
+homepage: https://github.com/tgjones/mongoid-verbalize
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 458357717130051605
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 458357717130051605
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Fine-grained versioning and localization for Mongoid documents
+test_files: []
+has_rdoc: