armot 0.3.1 → 0.3.2

data/README.md

@@ -72,10 +72,134 @@ Your translated model will have different contents for each locale transparently
     I18n.locale = :en
     car.name #=> A car
 
+Armot also provides an implementation for the `_changed?` method, so you can
+normally operate as if it was a standard active_record attribute.
+
+    car = Car.create :name => "Ford"
+    car.name = "Honda"
+
+    car.name_chaned? #=> true
+    car.save!
+    car.name_changed? #=> false
+
+
+Reloading caches
+----------------
 
 Be aware that armot doesn't take care of any cache expiration. If you're using
-Memoize with I18n ActiveRecord backend you must remember to reload the backend
-with an observer, for example.
+Memoize with I18n ActiveRecord backend you must remember to reload the
+backend.
+
+Armot provides the `reload_armot!` callback which is called on the
+instance after performing the changes. For example:
+
+    class Post < ActiveRecord::Base
+      # ...
+
+      def reload_armot!
+        I18n.backend.reload!
+        Rails.cache.clear
+      end
+    end
+
+
+Find_by dynamic methods
+-----------------------
+
+Armot also writes the dynamic `find_by` and `find_by!` methods in order to
+fetch a record from database given a specific content for an armotized
+attribute. It will *only* look for translations in the current language, and
+it will not perform any kind of fallback mechanism. For example:
+
+    I18n.locale = :en
+    post = Post.create :title => "Title in english"
+
+    Post.find_by_title "Title in english" #=> <post>
+    Post.find_by_title "Not found"  #=> nil
+    Post.find_by_title! "Not found" #=> ActiveRecord::RecordNotFound raised
+
+    I18n.locale = :es
+    Post.find_by_title "Title in english" #=> nil
+
+
+Fallbacks
+---------
+
+When reading the contents from an instance (not find_by methods) Armot works
+with your current I18n setup for fallbacks, just as if you were performing a
+I18n.t lookup.
+
+
+Modularized implementation
+--------------------------
+
+All the methods Armot provides are implemented in modules injected in your
+class (ArmotInstanceMethods and ArmotClassMethods). This means that you can
+override them in order to include custom logic. For instance if you are
+translating the `slug_url` attribute on your Post model, maybe you have a
+setter like this:
+
+    class Post
+      def slug_url=(value)
+        self[:slug_url] = ConvertToSafeUrl(value)
+      end
+
+      def to_param
+        slug_url
+      end
+    end
+
+Now if you want to armotize this slug_url attribute and still perform this
+logic, you could do that:
+
+    class Post
+      def slug_url=(value)
+        super(ConvertToSafeUrl(value))
+      end
+    end
+
+Armotized_attributes
+--------------------
+
+You can get a list of all the currently armotized attributes on a class by
+calling:
+
+    Post.armotized_attributes #=> [:title, :text]
+
+
+Defining localized accessors
+----------------------------
+
+There are situations in which it's useful for you to have localized accessors for
+your armotized attributes, so you don't need to change the current language in
+order to get the value for an attribute in that language, for instance:
+
+    I18n.locale = :en
+    post = Post.create :title => "ENG title"
+    I18n.locale = :es
+    post.title = "SP title"
+    post.save!
+
+    I18n.locale = :en
+    post.title_en #=> "ENG title"
+    post.title_es #=> "SP title"
+
+Armot provides now an automatic way to define these methods:
+
+    class Post
+      define_localized_accessors_for :title
+    end
+
+This will make available the `title_en` and `title_en=` methods (also in every
+other languages that may be available, as returned from
+`I18n.available_locales`). You can also set up these methods for all your
+armotized attributes using the `:all` keyword:
+
+
+    class Post
+      define_localized_accessors_for :all
+    end
+
 
 
 Development with armot

data/lib/armot/active_record_extensions.rb

@@ -2,11 +2,41 @@ module Armot
   module ActiveRecordExtensions
     module ClassMethods
       def armotize(*attributes)
-        make_it_armot! unless included_modules.include?(InstanceMethods)
+        if included_modules.include?(InstanceMethods)
+          raise DoubleDeclarationError, "armotize can only be called once in #{self}"
+        end
+
+        make_it_armot!
 
         instance_mixin = Module.new
         class_mixin = Module.new
 
+        class_mixin.module_eval do
+          define_method :armotized_attributes do
+            attributes.map(&:to_sym)
+          end
+
+          define_method :define_localized_accessors_for do |*localizable_attributes|
+            localizable_attributes = armotized_attributes if localizable_attributes == [:all]
+
+            localizable_attributes.each do |attr|
+              I18n.available_locales.each do |locale|
+                define_method "#{attr}_#{locale}" do
+                  armot_wrap_in_locale(locale) do
+                    send attr
+                  end
+                end
+
+                define_method "#{attr}_#{locale}=" do |value|
+                  armot_wrap_in_locale(locale) do
+                    send "#{attr}=", value
+                  end
+                end
+              end
+            end
+          end
+        end
+
         attributes.each do |attribute|
           class_mixin.module_eval do
             define_method :"find_by_#{attribute}" do |value|
@@ -52,10 +82,6 @@ module Armot
                 res ? res : raise(ActiveRecord::RecordNotFound)
               end
             end
-
-            # To implement by armotized classes
-            define_method :"reload_armot!" do
-            end
           end
 
           instance_mixin.module_eval do
@@ -98,19 +124,19 @@ module Armot
       def make_it_armot!
         include InstanceMethods
 
-        after_save :update_translations!
-        after_destroy :remove_i18n_entries
+        after_save :armot_update_translations!
+        after_destroy :armot_remove_i18n_entries
       end
     end
 
     module InstanceMethods
+      private
 
-    private
       def armot_attributes
         @armot_attributes ||= Hash.new { |hash, key| hash[key] = {} }
       end
 
-      def update_translations!
+      def armot_update_translations!
         return if armot_attributes.empty?
 
         armot_attributes.each do |locale, attributes|
@@ -120,14 +146,22 @@ module Armot
           end
         end
 
-        self.class.reload_armot!
+        reload_armot! if respond_to?(:"reload_armot!")
         armot_attributes.clear
       end
 
-      def remove_i18n_entries
+      def armot_remove_i18n_entries
         t = I18n::Backend::ActiveRecord::Translation.arel_table
         I18n::Backend::ActiveRecord::Translation.delete_all(t[:key].matches("armot.#{self.class.to_s.underscore.pluralize}%_#{id}"))
       end
+
+      def armot_wrap_in_locale(locale)
+        aux = I18n.locale
+        I18n.locale = locale.to_sym
+        res = yield
+        I18n.locale = aux
+        res
+      end
     end
   end
 end

data/lib/armot/version.rb

@@ -1,3 +1,3 @@
 module Armot
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

data/lib/armot.rb

@@ -4,5 +4,7 @@ require 'armot/railtie' if defined?(Rails)
 module Armot
   mattr_accessor :token
   @@token = "aXqvyiainsvQWivbpo13/asf/tTG27cbASBFPOQ"
+
+  class DoubleDeclarationError < RuntimeError; end
 end
 

data/test/armot_test.rb

@@ -10,6 +10,8 @@ def to_method_name(name)
 end
 
 class ArmotTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Pending
+
   def setup
     setup_db
     I18n.locale = I18n.default_locale = :en
@@ -326,4 +328,163 @@ class ArmotTest < ActiveSupport::TestCase
     post[:title] = "Hello world"
     assert_equal "Hello world", post.title
   end
+
+  test "should fetch all translations with only one query with multiple armotized parameters" do
+    pending "should be implemented in the active_record specific gem" do
+      post = Post.first
+      post.text = "English text"
+      post.save!
+
+      res = count_query_reads_for("I18n::Backend::ActiveRecord::Translation") do
+        a = Post.first
+        a.text
+        a.title
+      end
+
+      assert_equal 1, res
+    end
+  end
+
+  test "should not save the record if it has not changed" do
+    pending "should be implemented in the active_record specific gem" do
+      post = Post.last
+      post.title = "ENG title"
+      post.text = "English text"
+      post.save!
+
+      res = count_query_updates_for("I18n::Backend::ActiveRecord::Translation") do
+        a = Post.first
+        a.title = "ENG Second version"
+        a.text = "English text"
+        a.save!
+      end
+
+      assert_equal 1, res
+    end
+  end
+
+  test ".armotized_attributes" do
+    assert_equal [:title, :text], Post.armotized_attributes
+  end
+
+  test "multiple armotize calls raise an error" do
+    assert_raise Armot::DoubleDeclarationError do
+      class FooBar < ActiveRecord::Base
+        armotize :foo
+        armotize :bar
+      end
+    end
+  end
+
+  test "the setter method shold return the assigned value" do
+    post = Post.last
+    res = (post.title = "Foo bar title")
+    assert_equal "Foo bar title", res
+  end
+
+  test "an armotized class should not have armotized accessors by default" do
+    post = Post.last
+    assert_equal false, post.respond_to?(:title_en)
+  end
+
+  test ".define_localized_accessors_for should define localized accessors for the current locales" do
+    post = Post.last
+    I18n.locale = :es
+    post.title = "SP titulo"
+    post.save! # Just save here to make I18n.available_locales aware of both :es and :en
+
+    assert_equal [:es, :en].sort, I18n.available_locales.sort
+
+    class FuzzBar < Post
+      define_localized_accessors_for :title
+    end
+
+    foo = FuzzBar.new
+    foo.title = "Cucamonga"
+    foo.save!
+    assert_equal true, foo.respond_to?(:title_en)
+    assert_equal true, foo.respond_to?(:"title_en=")
+    assert_equal true, foo.respond_to?(:title_es)
+    assert_equal true, foo.respond_to?(:"title_es=")
+  end
+
+  test "localized getters behaviour" do
+    class FuzzBar < Post
+      define_localized_accessors_for :title
+    end
+
+    foo = FuzzBar.new
+    foo.title = "EN - title"
+    I18n.locale = :es
+    foo.title = "ES - titulo"
+    foo.save!
+
+    I18n.locale = :en
+    assert_equal "EN - title", foo.title_en
+    assert_equal "ES - titulo", foo.title_es
+  end
+
+  test "localized setters behaviour" do
+    class FuzzBar < Post
+      define_localized_accessors_for :title
+    end
+
+    foo = FuzzBar.new
+    foo.title = "EN - title"
+    I18n.locale = :es
+    foo.title = "ES - titulo"
+    foo.save!
+
+    I18n.locale = :en
+    res = (foo.title_es = "Segundo titulo")
+    assert_equal "Segundo titulo", foo.title_es
+    assert_equal "Segundo titulo", res
+  end
+
+  test "after using localized accessors the I18n.locale should remain the same" do
+    class FuzzBar < Post
+      define_localized_accessors_for :title
+    end
+
+    foo = FuzzBar.new
+    foo.title = "EN - title"
+    I18n.locale = :es
+    foo.title = "ES - titulo"
+    foo.save!
+
+    I18n.locale = :klingon
+    foo.title_es = "Segundo titulo"
+    foo.title_en
+    assert_equal :klingon, I18n.locale
+  end
+
+  test "localized accessors should work for more than one attribute" do
+    class FuzzBar < Post
+      define_localized_accessors_for :title, :text
+    end
+
+    foo = FuzzBar.new
+    foo.title = "EN - title"
+    foo.text = "EN - body text"
+    foo.save!
+    assert_equal true, foo.respond_to?(:title_en)
+    assert_equal true, foo.respond_to?(:"title_en=")
+    assert_equal true, foo.respond_to?(:text_en)
+    assert_equal true, foo.respond_to?(:"text_en=")
+  end
+
+  test ".define_localized_accessors_for :all" do
+    class FuzzBar < Post
+      define_localized_accessors_for :all
+    end
+
+    foo = FuzzBar.new
+    foo.title = "EN - title"
+    foo.text = "EN - body text"
+    foo.save!
+    assert_equal true, foo.respond_to?(:title_en)
+    assert_equal true, foo.respond_to?(:"title_en=")
+    assert_equal true, foo.respond_to?(:text_en)
+    assert_equal true, foo.respond_to?(:"text_en=")
+  end
 end

data/test/schema.rb

@@ -3,6 +3,7 @@ ActiveRecord::Schema.define(:version => 1) do
     t.string :title
     t.text   :text
     t.string :header
+    t.string :type
   end
 
   create_table :products do |t|

data/test/test_helper.rb

@@ -47,3 +47,25 @@ end
 # Puret translation model to test migration process
 class PostTranslation < ActiveRecord::Base
 end
+
+def count_query_reads_for(clazz)
+  old = ActiveRecord::Base.logger
+  log_stream = StringIO.new
+  logger = Logger.new(log_stream)
+  ActiveRecord::Base.logger = logger
+  yield
+  ActiveRecord::Base.logger = old
+  logger.close
+  log_stream.string.scan(/#{clazz} Load/).size
+end
+
+def count_query_updates_for(clazz)
+  old = ActiveRecord::Base.logger
+  log_stream = StringIO.new
+  logger = Logger.new(log_stream)
+  ActiveRecord::Base.logger = logger
+  yield
+  ActiveRecord::Base.logger = old
+  logger.close
+  log_stream.string.scan(/UPDATE \"#{clazz.constantize.table_name}\"/).size
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: armot
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-19 00:00:00.000000000 Z
+date: 2012-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n-active_record