has_localization_table 0.4.0 → 0.4.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZDVjZmEwMjUwZTk5OTMxMWJhZmQ4MmJhNTk5NTFjNDZhNjcxNDk3OQ==
+    ODMwMzhkMGY3Mjg1MzZiZjBkMDJjNDk1ZjFkNjk2Y2Y2N2MxODg1Nw==
   data.tar.gz: !binary |-
-    Y2ExNzJkNWJkMTY0MmQyMDM4MmQ5Y2YzYTVlNWE5YWUwMzhkYjg1ZA==
+    N2VmZWRhMmQyMjIxNDVhMTVlZTc4ZDk0YWQzNmMzZjcyYzVlNjA5Mw==
 SHA512:
   metadata.gz: !binary |-
-    OTQzNGFhMThhMmZmY2NiMjliOTJlYmQ2YWVmYjM3YTYzM2E0ZDdmNTA0YzI4
-    OTdkODNmYzRhYjNiNGIyNTdkMGIwYzRjMTBjMzZkNmQ3MjczMTUyZmQ5NmVj
-    ODQyZTQ5N2JjYTcwZjYwMDgwNTY3ZTBkNDM4MWUxMmZjNzE1ZTc=
+    NzFhMjg3NmE1OTcwMzZhNmI2ZDgzNDRhNzk0Njg0MmZlNzVjMTQ0Nzg0YTNj
+    NTdjZTI2OGNkYjU1MzI0NmE4YjI4Y2JiNjhmYjk3MjkxM2EwNTMxZmM4MDli
+    MmIxNjk5ODE0MzI4ZGY5MzJlOTkyZTk5NmIzMDlmYTg4NzQzZDg=
   data.tar.gz: !binary |-
-    ZDkwZGMxODU0ODNiNjNkMzVmNGRmYzYyODBhYmUzMjgyNTViMDYxYjgxY2E2
-    YzM1MDY5OGNkZTVlYWFkMTYyMjdjZGI2MWMzODFlYTE4OGU3NGY2NTRlYzYz
-    NDcwMzViNTc5Yjg4MTgxNGNkN2QzMTUwYWEzYTBiMzA1ZDc0ODQ=
+    ODgyYzU3Y2U3MTExMjg5MjQ5N2NiNDMwMzdhNjMwOGRjMzhjMGRmY2E2N2E0
+    OWE5MGIzYzczZjIzODkzNTA4ZTFmMGY4YWVmYWUzNDBjZDk5YWFiYjllNjhh
+    OTRlMzA1YzA1YjliZDQwOTIyM2U5MDEwZjUyZmJiY2Y0M2RmYzM=

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,11 @@
+sudo: false
+language: ruby
+cache:
+  - bundler
+rvm:
+  - 1.9.3
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3.0
+before_install: gem install bundler -v 1.11.2

data/README.md

@@ -1,5 +1,8 @@
 # HasLocalizationTable
 
+[![Gem Version](https://badge.fury.io/rb/has_localization_table.svg)](https://badge.fury.io/rb/has_localization_table)
+[![Build Status](https://travis-ci.org/dvandersluis/has_localization_table.svg?branch=master)](https://travis-ci.org/dvandersluis/has_localization_table)
+
 ActiveRecord plugin which adds setup and convenience methods for working with a relational localization table for user-driven data.
 
 Adds accessors to retrieve localized attributes using the current locale, in order to avoid having to collect the correct object each time a value is needed. Localized attribute values are also cached for the current locale.

data/has_localization_table.gemspec

@@ -14,9 +14,10 @@ Gem::Specification.new do |gem|
   gem.name          = "has_localization_table"
   gem.require_paths = ["lib"]
   gem.version       = HasLocalizationTable::VERSION
-  
-  gem.add_dependency 'activesupport', ['>= 3.0.0']
-  gem.add_dependency 'activerecord', ['>= 3.0.0']
+
+  gem.add_dependency 'activesupport', '~> 3.0'
+  gem.add_dependency 'activerecord', '~> 3.0'
+
   gem.add_development_dependency 'minitest'
   gem.add_development_dependency 'sqlite3'
   gem.add_development_dependency 'rake'

data/lib/has_localization_table/active_record/attributes.rb

@@ -1,11 +1,15 @@
 module HasLocalizationTable
   module ActiveRecord
     module Attributes
+      LOCALIZED_ATTRIBUTE_REGEX = /\A(?<name>[a-z0-9_]+)(?<suffix>=|_changed\?)?\Z/i
+
+      autoload :Cache, 'has_localization_table/active_record/attributes/cache'
+
       def read_localized_attribute(attribute, locale = HasLocalizationTable.current_locale, options = {})
         locale ||= HasLocalizationTable.current_locale
 
-        attribute_cache[attribute.to_sym][locale.id] ||= begin
-          attr = localization_association.detect{ |a| a.send(HasLocalizationTable.locale_foreign_key) == locale.id }.send(attribute) rescue ''
+        localized_attribute_cache.get(attribute, locale) do
+          attr = localization_for(locale).send(attribute) rescue ''
           attr ||= '' # if the attribute somehow is nil, change it to a blank string so we're always dealing with strings
 
           fallback = options.fetch(:fallback, HasLocalizationTable.config.fallback_locale)
@@ -19,46 +23,59 @@ module HasLocalizationTable
           attr
         end
       end
-      
+
       def write_localized_attribute(attribute, value, locale = HasLocalizationTable.current_locale)
         value = value.to_s
-        localization = localization_association.detect{ |a| a.send(HasLocalizationTable.locale_foreign_key) == locale.id } ||
+        localization = localization_for(locale) ||
           localization_association.build(HasLocalizationTable.locale_foreign_key => locale.id)
-        
+
         localization.send(:"#{attribute}=", value)
-        attribute_cache[attribute.to_sym][locale.id] = value.blank? ? nil : value
+        value.blank? ? localized_attribute_cache.clear(attribute, locale) : localized_attribute_cache.set(attribute, locale, value)
       end
-      
+
       # Define attribute getters and setters
       def method_missing(name, *args, &block)
-        if name.to_s =~ /\A([a-z0-9_]+)(=)?\Z/i
-          if localized_attributes.include?($1.to_sym)
-            if $2.nil? # No equals sign -- not a setter
+        match = name.to_s.match(LOCALIZED_ATTRIBUTE_REGEX)
+
+        if match
+          if localized_attributes.include?(match[:name].to_sym)
+            if match[:suffix].nil? # No equals sign -- not a setter
               # Try to load a string for the given locale
               # If that fails, try for the primary locale
               raise ArgumentError, "wrong number of arguments (#{args.size} for 0 or 1)" unless args.size.between?(0, 1)
               options = args.extract_options!
               return read_localized_attribute($1, args.first, options) || read_localized_attribute($1, HasLocalizationTable.primary_locale, options)
-            else
+            elsif match[:suffix] == '='
               raise ArgumentError, "wrong number of arguments (#{args.size} for 1)" unless args.size == 1
               return write_localized_attribute($1, args.first)
+            elsif current_localization.respond_to?(name).inspect
+              return localized_attribute_changed?(name.to_s.sub(/_changed\?/, ''))
             end
           end
         end
-        
+
         super
       end
-      
+
       def respond_to?(*args)
-        return true if args.first.to_s =~ /\A([a-z0-9_]+)=?\Z/i and localized_attributes.include?($1.to_sym)
+        match = args.first.to_s.match(LOCALIZED_ATTRIBUTE_REGEX)
+        return true if match && localized_attributes.include?(match[:name].to_sym)
         super
       end
-    
+
+      def reset_localized_attribute_cache
+        localized_attribute_cache.reset
+      end
+
     private
 
-      def attribute_cache
-        @localization_attribute_cache ||= localized_attributes.inject({}) { |memo, attr| memo[attr] = {}; memo }
+      def localized_attribute_cache
+        @localization_attribute_cache ||= Cache.new(self)
+      end
+
+      def localized_attribute_changed?(attr)
+        current_localization.send("#{attr}_changed?")
       end
     end
   end
-end
+end

data/lib/has_localization_table/active_record/attributes/cache.rb

@@ -0,0 +1,35 @@
+module HasLocalizationTable
+  module ActiveRecord
+    module Attributes
+      class Cache < Hash
+        attr_reader :klass
+
+        def initialize(klass)
+          @klass = klass
+          reset
+        end
+
+        def get(attr, locale)
+          clear(attr, locale) if changed?(attr, locale)
+          self[attr.to_sym][locale.id] ||= yield
+        end
+
+        def set(attr, locale, value)
+          self[attr.to_sym][locale.id] = value
+        end
+
+        def clear(attr, locale)
+          self[attr.to_sym].delete(locale.id)
+        end
+
+        def reset
+          replace(klass.localized_attributes.inject({}) { |memo, attr| memo[attr] = {}; memo })
+        end
+
+        def changed?(attr, locale)
+          klass.localization_for(locale).send(attr) != self[attr.to_sym][locale.id]
+        end
+      end
+    end
+  end
+end

data/lib/has_localization_table/active_record/callbacks.rb

@@ -1,16 +1,7 @@
 module HasLocalizationTable
   module ActiveRecord
     module Callbacks
-      def self.extended(klass)
-        klass.send(:include, InstanceMethods)
-      end
-
       def setup_localization_callbacks!
-        # Initialize string records after main record initialization
-        after_initialize(if: :add_localization_after_initialize?) do
-          build_missing_localizations!
-        end
-
         before_validation do
           reject_empty_localizations!
           build_missing_localizations!
@@ -23,14 +14,6 @@ module HasLocalizationTable
         end
       end
       private :setup_localization_callbacks!
-
-      module InstanceMethods
-        def add_localization_after_initialize?
-          localization_table_options.fetch(:initialize, true) && !localization_table_options.fetch(:include, false)
-        end
-
-        private :add_localization_after_initialize?
-      end
     end
   end
 end

data/lib/has_localization_table/active_record/meta_methods.rb

@@ -38,8 +38,11 @@ module HasLocalizationTable
       module InstanceMethods
         # Helper method for getting the localization association without having to look up the name each time
         def localization_association
-          association_name = localization_table_options[:association_name]
-          send(association_name)
+          send(localization_association_name)
+        end
+
+        def localization_association_name
+          localization_table_options[:association_name]
         end
 
         def localized_attributes
@@ -49,6 +52,14 @@ module HasLocalizationTable
         def localization_table_options
           self.class.localization_table_options
         end
+
+        def localization_for(locale)
+          localization_association.detect{ |a| a.send(HasLocalizationTable.locale_foreign_key) == locale.id }
+        end
+
+        def current_localization
+          localization_for(HasLocalizationTable.current_locale)
+        end
       end
     end
   end

data/lib/has_localization_table/active_record/relation.rb

@@ -1,7 +1,7 @@
 module HasLocalizationTable
   module ActiveRecord
     module Relation
-      RESERVED_KEYS = [:association_name, :required, :optional, :dependent, :has_one, :initialize, :include]
+      RESERVED_KEYS = [:association_name, :required, :optional, :dependent, :has_one, :include, :build_missing]
 
       def self.extended(klass)
         klass.send(:include, InstanceMethods)
@@ -40,7 +40,7 @@ module HasLocalizationTable
         association_name = :localization if localized_attributes.include?(association_name)
 
         has_one_options = localization_table_options.except(*RESERVED_KEYS).
-          merge({ conditions: Proc.new { "#{table_name}.#{foreign_key} = #{HasLocalizationTable.current_locale.id}"} })
+          merge(conditions: -> { "#{table_name}.#{foreign_key} = #{HasLocalizationTable.current_locale.id}" })
 
         self.has_one association_name, has_one_options
         self.has_one(:localization, has_one_options) unless association_name == :localization
@@ -58,6 +58,18 @@ module HasLocalizationTable
         if localization_table_options.fetch(:include, false)
           self.default_scope -> { includes(localization_association_name) }
         end
+
+        override_association_getter
+      end
+
+      def override_association_getter(name = localization_association_name)
+        # Update the association getter to build missing localizations
+        # This works better than an after_initialize because it allows for strings to not be loaded
+        # until they are used, and also repopulates if necessary
+        define_method(name) do |build_missing = localization_table_options.fetch(:build_missing, true), force_reload = false|
+          build_missing_localizations! if build_missing
+          super(force_reload)
+        end
       end
 
     public
@@ -68,13 +80,15 @@ module HasLocalizationTable
           return unless HasLocalizationTable.all_locales.any?
 
           locale_ids = HasLocalizationTable.all_locales.map(&:id)
+          assoc = association(localization_association_name).reader
+
           HasLocalizationTable.all_locales.each do |locale|
-            unless localization_association.detect{ |str| str.send(HasLocalizationTable.locale_foreign_key) == locale.id }
-              localization_association.build(HasLocalizationTable.locale_foreign_key => locale.id)
+            unless assoc.detect{ |record| record.send(HasLocalizationTable.locale_foreign_key) == locale.id }
+              assoc.build(HasLocalizationTable.locale_foreign_key => locale.id)
             end
-
-            localization_association.sort_by!{ |l| locale_ids.index(l.send(HasLocalizationTable.locale_foreign_key)) || 0 }
           end
+
+          assoc.sort_by!{ |l| locale_ids.index(l.send(HasLocalizationTable.locale_foreign_key)) || 0 }
         end
 
         # Remove localization objects that are not filled in

data/lib/has_localization_table/version.rb

@@ -1,3 +1,3 @@
 module HasLocalizationTable
-  VERSION = "0.4.0"
+  VERSION = "0.4.2"
 end

data/spec/active_record/attributes_spec.rb

@@ -4,7 +4,7 @@ describe HasLocalizationTable do
   before do
     # Configure HLT
     HasLocalizationTable.configure do |c|
-      c.primary_locale = Locale.first 
+      c.primary_locale = Locale.first
       c.current_locale = Locale.first
       c.all_locales = -> { Locale.all }
     end
@@ -15,17 +15,17 @@ describe HasLocalizationTable do
   end
 
   let(:a) { Article.new(name: "Test", description: "Description") }
-  
+
   it "should set localized attributes" do
     a.localizations.first.name.must_equal "Test"
     a.localizations.first.description.must_equal "Description"
   end
-  
+
   it "should create accessor methods" do
     a.name.must_equal "Test"
     a.description.must_equal "Description"
   end
-  
+
   it "should save localized attributes" do
     a.save!
     a.reload
@@ -38,7 +38,7 @@ describe HasLocalizationTable do
     a.update_attributes!(name: "Test 2")
     Article.find(a.id).name.must_equal "Test 2"
   end
-  
+
   it "should create mutator methods" do
     a.name = "Changed"
     a.description = "Changed Description"
@@ -47,31 +47,31 @@ describe HasLocalizationTable do
     a.localizations.first.name.must_equal "Changed"
     a.localizations.first.description.must_equal "Changed Description"
   end
-  
+
   it "should use the current locale when setting" do
     a
 
     HasLocalizationTable.configure do |c|
       c.current_locale = Locale.last
     end
-    
+
     a.name = "French Name"
     a.description = "French Description"
-    
+
     eng = a.localizations.detect{ |s| s.locale_id == Locale.first.id }
     fre = a.localizations.detect{ |s| s.locale_id == Locale.last.id }
-    
+
     eng.name.must_equal "Test"
     eng.description.must_equal "Description"
     fre.name.must_equal "French Name"
     fre.description.must_equal "French Description"
   end
-  
+
   it "should return the correct value when the current locale changes" do
     Locale.class_eval { cattr_accessor :current }
     eng = Locale.find_by_name("English")
     fre = Locale.find_by_name("French")
-    
+
     HasLocalizationTable.configure do |c|
       c.current_locale = ->{ Locale.current }
     end
@@ -79,58 +79,58 @@ describe HasLocalizationTable do
     Locale.current = eng
     a.name = "English Name"
     a.description = "English Description"
-    
+
     Locale.current = fre
     a.name = "French Name"
     a.description = "French Description"
-    
+
     Locale.current = eng
     a.name.must_equal "English Name"
     a.description.must_equal "English Description"
-    
+
     Locale.current = fre
     a.name.must_equal "French Name"
     a.description.must_equal "French Description"
   end
-  
+
   it "should return the correct locale's value even if the cache is empty" do
     Locale.class_eval { cattr_accessor :current }
-    Locale.current = eng = Locale.find_by_name("English")
+    Locale.current = Locale.find_by_name("English")
     fre = Locale.find_by_name("French")
-    
+
     HasLocalizationTable.configure do |c|
       c.current_locale = ->{ Locale.current }
     end
 
     a.localizations.last.attributes = { name: "French Name", description: "French Description" }
-        
-    # Force empty cache 
-    a.instance_variable_set(:@localization_attribute_cache, { name: {}, description: {} })
+
+    # Force empty cache
+    a.reset_localized_attribute_cache
 
     Locale.current = fre
     a.name.must_equal "French Name"
     a.description.must_equal "French Description"
   end
-  
+
   it "should return the correct locale's value even if a language was added" do
     Locale.class_eval { cattr_accessor :current }
     Locale.current = eng = Locale.find_by_name("English")
     fre = Locale.find_by_name("French")
-    
+
     HasLocalizationTable.configure do |c|
       c.current_locale = ->{ Locale.current }
       c.all_locales = [eng]
     end
-    
+
     Object.send(:remove_const, :Article) rescue nil
     Article = Class.new(ActiveRecord::Base)
     Article.has_localization_table
-    
+
     aa = Article.create!(name: "Name", description: "Description")
-    l = ArticleLocalization.create!(article: aa, locale: fre, name: "French Name", description: "French Description")
-    
+    ArticleLocalization.create!(article: aa, locale: fre, name: "French Name", description: "French Description")
+
     aa.reload
-    
+
     Locale.current = fre
     aa.name.must_equal "French Name"
     aa.description.must_equal "French Description"
@@ -219,4 +219,84 @@ describe HasLocalizationTable do
       end
     end
   end
-end
+
+  it 'should build missing localizations when accessing the association' do
+    HasLocalizationTable.config.all_locales = [Locale.first]
+
+    a = Article.new
+    a.localizations.size.must_equal 1
+  end
+
+  it 'should build missing localizations when there is more than 1 locale' do
+    a = Article.new
+    a.localizations.size.must_equal 2
+  end
+
+  it 'should not build localizations when they already exist' do
+    a = Article.new
+    l1 = ArticleLocalization.new(locale_id: Locale.first.id, name: 'Name')
+    l2 = ArticleLocalization.new(locale_id: Locale.last.id, name: 'Nom')
+    a.localizations = [l1, l2]
+    a.localizations.must_equal [l1, l2]
+    a.localizations.first.name.must_equal 'Name'
+  end
+
+  it 'should add missing localizations if some exist' do
+    a = Article.new
+    a.localizations = [ArticleLocalization.new(locale_id: Locale.first.id, name: 'Name')]
+    a.association(:localizations).reader.size.must_equal 1
+    a.localizations.size.must_equal 2
+    a.localizations.first.name.must_equal 'Name'
+  end
+
+  it 'should not build missing localizations if asked not to' do
+    a = Article.new
+    a.localizations(false).must_be_empty
+  end
+
+  it 'should not build missing localizations if the options disable it' do
+    Article.has_localization_table build_missing: false
+    a = Article.new
+    a.localizations.must_be_empty
+  end
+
+  it 'should build missing localizations if the options disable it but the method requests it' do
+    Article.has_localization_table build_missing: false
+    a = Article.new
+    a.localizations(true).wont_be_empty
+  end
+
+  it 'should update the main model when the string is directly updated' do
+    Article.has_localization_table
+    a = Article.new
+
+    string = a.localizations.first
+    string.name = 'New Name'
+    a.name.must_equal 'New Name'
+  end
+
+  it 'should allow successive changes' do
+    Article.has_localization_table
+    a = Article.new
+
+    string = a.localizations.first
+    string.name = 'New Name'
+    a.name.must_equal 'New Name'
+
+    string.name = 'Another Name'
+    a.name.must_equal 'Another Name'
+  end
+
+  it 'should report if the attribute changed' do
+    Article.has_localization_table
+    a = Article.create!(name: 'Name')
+    a.name = 'New Name'
+    assert a.name_changed?
+  end
+
+  it 'should not report that the attribute has changed if it has not' do
+    Article.has_localization_table
+    a = Article.create!(name: 'Name')
+    refute a.name_changed?
+  end
+end

data/spec/active_record/callbacks_spec.rb

@@ -16,34 +16,6 @@ describe HasLocalizationTable do
 
   let(:article) { Article.create!(name: "Test", description: "Description") }
 
-  it 'should initialize the localizations association on initialize' do
-    a = Article.new
-    a.localizations.wont_be_empty
-  end
-
-  it 'should initialize the localizations association on initialize for an existing object' do
-    a = Article.find(article.id)
-    a.localizations.wont_be_empty
-  end
-
-  it 'should not initialize the association on initialize if initialize: false is given in config' do
-    Article.has_localization_table initialize: false
-    a = Article.new
-    a.localizations.must_be_empty
-  end
-
-  it 'should not initialize the association for an existing object if initialize: false is given in config' do
-    Article.has_localization_table initialize: false
-    a = Article.find(article.id)
-    refute(a.localizations.loaded?)
-  end
-
-  it 'should not initialize the association on initialize if include: true is given in config' do
-    Article.has_localization_table include: true
-    a = Article.new
-    a.localizations.must_be_empty
-  end
-
   it 'should load associations if include: true is given' do
     Article.has_localization_table include: true
     assert Article.find(article.id).localizations.loaded?

data/spec/has_localization_table_spec.rb

@@ -30,10 +30,10 @@ describe HasLocalizationTable do
           raise 'error!'
         end
 
-      rescue => e
+      rescue
       end
 
       HasLocalizationTable.fallback_locale.must_equal HasLocalizationTable.primary_locale
     end
   end
-end
+end

data/spec/support/setup.rb

@@ -2,7 +2,7 @@
 ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
 ActiveRecord::Migration.tap do |m|
   m.create_table :articles do |t|
-    t.timestamps
+    t.timestamps null: false
   end
 
   m.create_table :locales do |t|
@@ -25,4 +25,4 @@ Locale.create!(name: "French")
 ArticleLocalization = Class.new(ActiveRecord::Base) do
   belongs_to :article
   belongs_to :locale
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: has_localization_table
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Daniel Vandersluis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-30 00:00:00.000000000 Z
+date: 2016-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   type: :runtime
@@ -16,28 +16,28 @@ dependencies:
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '3.0'
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   type: :runtime
   prerelease: false
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '3.0'
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   type: :development
   prerelease: false
@@ -89,6 +89,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
+- .travis.yml
 - Gemfile
 - LICENSE
 - README.md
@@ -97,6 +99,7 @@ files:
 - lib/has_localization_table.rb
 - lib/has_localization_table/active_record.rb
 - lib/has_localization_table/active_record/attributes.rb
+- lib/has_localization_table/active_record/attributes/cache.rb
 - lib/has_localization_table/active_record/callbacks.rb
 - lib/has_localization_table/active_record/finder_methods.rb
 - lib/has_localization_table/active_record/meta_methods.rb