has_localization_table 0.1.1 → 0.2.0

data/lib/has_localization_table/active_record/attributes.rb

@@ -0,0 +1,47 @@
+module HasLocalizationTable
+  module ActiveRecord
+    module Attributes
+      def read_localized_attribute(attribute, locale = HasLocalizationTable.current_locale)
+        attribute_cache[attribute.to_sym][locale.id] ||= localization_association.detect{ |a| a.send(HasLocalizationTable.locale_foreign_key) == locale.id }.send(attribute) rescue nil
+      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_association.build(HasLocalizationTable.locale_foreign_key => locale.id)
+        
+        localization.send(:"#{attribute}=", value)
+        attribute_cache[attribute.to_sym][locale.id] = value.blank? ? nil : 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
+              # 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)
+              return read_localized_attribute($1, *args) || read_localized_attribute($1, HasLocalizationTable.primary_locale)
+            else
+              raise ArgumentError, "wrong number of arguments (#{args.size} for 1)" unless args.size == 1
+              return write_localized_attribute($1, args.first)
+            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)
+        super
+      end
+    
+    private
+      def attribute_cache
+        @localization_attribute_cache ||= localized_attributes.inject({}) { |memo, attr| memo[attr] = {}; memo }
+      end
+    end
+  end
+end

data/lib/has_localization_table/active_record/callbacks.rb

@@ -0,0 +1,24 @@
+module HasLocalizationTable
+  module ActiveRecord
+    module Callbacks
+      def setup_localization_callbacks!
+        # Initialize string records after main record initialization
+        after_initialize do
+          build_missing_localizations!
+        end
+        
+        before_validation do
+          reject_empty_localizations!
+          build_missing_localizations!
+        end
+        
+        # Reject any blank strings before saving the record
+        # Validation will have happened by this point, so if there is a required string that is needed, it won't be rejected
+        before_save do
+          reject_empty_localizations!
+        end
+      end
+      private :setup_localization_callbacks!
+    end
+  end
+end

data/lib/has_localization_table/active_record/finder_methods.rb

@@ -0,0 +1,33 @@
+module HasLocalizationTable
+  module ActiveRecord
+    module FinderMethods
+      def method_missing(name, *args, &block)
+        if name.to_s =~ /\Afind_by_([a-z0-9_]+(_and_[a-z0-9_]+)*)\Z/
+          attributes = $1.split("_and_").map(&:to_sym)
+          if (attributes & localized_attributes).size == attributes.size
+            raise ArgumentError, "expected #{attributes.size} #{"argument".pluralize(attributes.size)}: #{attributes.join(", ")}" unless args.size == attributes.size
+            args = attributes.zip(args).inject({}) { |memo, (key, val)| memo[key] = val; memo }
+            return find_by_localized_attributes(args)
+          end
+        end
+        
+        super
+      end
+      
+      def respond_to?(*args)
+        if args.first.to_s =~ /\Afind_by_([a-z0-9_]+(_and_[a-z0-9_]+)*)\Z/
+          attributes = $1.split("_and_").map(&:to_sym)
+          return true if (attributes & localized_attributes).size == attributes.size
+        end
+        
+        super
+      end
+    
+    private
+      # Find a record by multiple localization values
+      def find_by_localized_attributes(attributes, locale = HasLocalizationTable.current_locale)
+        with_localizations.where(localization_class.table_name => attributes).first
+      end
+    end
+  end
+end

data/lib/has_localization_table/active_record/meta_methods.rb

@@ -0,0 +1,55 @@
+module HasLocalizationTable
+  module ActiveRecord
+    module MetaMethods
+      def self.extended(klass)
+        klass.send(:include, InstanceMethods)
+      end
+      
+      def localization_class
+        localization_table_options[:class_name].constantize
+      end
+      
+      def localization_association_name
+        localization_table_options[:association_name]
+      end
+      
+      def localized_attributes
+        # Determine which attributes of the association model should be accessable through the base class
+        # ie. everything that's not a primary key, foreign key, or timestamp attribute
+        association_name = self.localization_table_options[:association_name] || :strings
+        association = reflect_on_association(association_name)
+        
+        attribute_names = association.klass.attribute_names
+        timestamp_attrs = association.klass.new.send(:all_timestamp_attributes_in_model).map(&:to_s)
+        foreign_keys = association.klass.reflect_on_all_associations.map{ |a| a.association_foreign_key }
+        primary_keys = [association.klass.primary_key]
+        # protected_attrs = association.klass.protected_attributes.to_a
+        
+        (attribute_names - timestamp_attrs - foreign_keys - primary_keys).map(&:to_sym)
+      end
+      
+      def localized_attribute_required?(attribute)
+        return false unless localization_table_options[:required] || false
+        return true unless localization_table_options[:optional]
+        
+        !localization_table_options[:optional].include?(attribute) 
+      end
+      
+      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)
+        end
+        
+        def localized_attributes
+          self.class.localized_attributes
+        end
+        
+        def localization_table_options
+          self.class.localization_table_options
+        end
+      end
+    end
+  end
+end

data/lib/has_localization_table/active_record/ordered_by.rb

@@ -0,0 +1,28 @@
+module HasLocalizationTable
+  module ActiveRecord
+    module OrderedBy
+      def method_missing(name, *args, &block)
+        if name.to_s =~ /\Aordered_by_([a-z0-9_]+)\Z/
+          attribute = $1.to_sym
+          return ordered_by_localized_attribute(attribute, *args) if localized_attributes.include?(attribute)
+        end
+        
+        super
+      end
+      
+      def respond_to?(*args)
+        if args.first.to_s =~ /\Aordered_by_([a-z0-9_]+)\Z/
+          return true if localized_attributes.include?($1.to_sym)
+        end
+        
+        super
+      end
+      
+    private
+      # Order records by localization value
+      def ordered_by_localized_attribute(attribute, asc = true, locale = HasLocalizationTable.current_locale)
+        with_localizations.order("#{localization_class.table_name}.#{attribute} #{asc ? "ASC" : "DESC"}")
+      end
+    end
+  end
+end

data/lib/has_localization_table/active_record/relation.rb

@@ -0,0 +1,46 @@
+module HasLocalizationTable
+  module ActiveRecord
+    module Relation
+      def self.extended(klass)
+        klass.send(:include, InstanceMethods)
+        
+        # Alias the scoping method to use the actual association name
+        alias_method :"with_#{klass.localization_association_name}", :with_localizations
+      end
+      
+      def with_localizations
+        lcat = localization_class.arel_table
+        
+        scoped.joins(
+          arel_table.join(lcat, Arel::Nodes::OuterJoin).
+            on(lcat[:"#{self.name.underscore}_id"].eq(arel_table[self.primary_key]).and(lcat[HasLocalizationTable.locale_foreign_key].eq(HasLocalizationTable.current_locale.id))).
+            join_sql
+        )
+      end
+    
+      def create_localization_association!
+        self.has_many localization_association_name, localization_table_options.except(:association_name, :required, :optional)
+      end
+      private :create_localization_association!
+      
+      module InstanceMethods
+        # Add localization objects for any available locale that doesn't have one 
+        def build_missing_localizations!
+          locale_ids = HasLocalizationTable.all_locales.map(&:id)
+          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)
+            end
+            
+            localization_association.sort_by!{ |l| locale_ids.index(l.send(HasLocalizationTable.locale_foreign_key)) || 0 }
+          end
+        end
+        
+        # Remove localization objects that are not filled in
+        def reject_empty_localizations!
+          localization_association.reject! { |l| !l.persisted? and localized_attributes.all?{ |attr| l.send(attr).blank? } }
+        end
+      end
+    end
+  end
+end

data/lib/has_localization_table/active_record/validations.rb

@@ -0,0 +1,26 @@
+module HasLocalizationTable
+  module ActiveRecord
+    module Validations
+      def setup_localization_validations!
+        localized_attributes.each do |attribute|
+          # Add validation to make all string fields required for the primary locale
+          obj = self
+          localization_class.class_eval do
+            validates attribute, presence: { message: :custom_this_field_is_required },
+              if: proc { |model| obj.name.constantize.localized_attribute_required?(attribute) && model.send(HasLocalizationTable.locale_foreign_key) == HasLocalizationTable.current_locale.id }
+          end
+        end
+        
+        # Add validation to ensure a string for the primary locale exists if the string is required
+        validate do
+          if localization_table_options[:required] || false
+            errors.add(localization_association_name, :primary_lang_string_required) unless localization_association.any? do |string|
+              string.send(HasLocalizationTable.locale_foreign_key) == HasLocalizationTable.primary_locale.id
+            end
+          end
+        end
+      end
+      private :setup_localization_validations!    
+    end
+  end
+end

data/lib/has_localization_table/active_record.rb

@@ -1,5 +1,13 @@
 module HasLocalizationTable
   module ActiveRecord
+    autoload :Attributes,     'has_localization_table/active_record/attributes'
+    autoload :Callbacks,      'has_localization_table/active_record/callbacks'
+    autoload :FinderMethods,  'has_localization_table/active_record/finder_methods'
+    autoload :MetaMethods,    'has_localization_table/active_record/meta_methods'
+    autoload :OrderedBy,      'has_localization_table/active_record/ordered_by'
+    autoload :Relation,       'has_localization_table/active_record/relation'
+    autoload :Validations,    'has_localization_table/active_record/validations'
+    
     def has_localization_table(*args)
       options = args.extract_options!
       options[:association_name] = args.first || HasLocalizationTable.default_association_name
@@ -8,8 +16,12 @@ module HasLocalizationTable
       class_attribute :localization_table_options
       self.localization_table_options = { dependent: :delete_all, class_name: self.name + HasLocalizationTable.class_suffix }.merge(options)
       
-      extend(ClassMethods)
-      include(InstanceMethods)
+      extend Relation, FinderMethods, OrderedBy, Callbacks, Validations, MetaMethods
+      include Attributes
+      
+      create_localization_association!
+      setup_localization_callbacks!
+      setup_localization_validations!
     end
   end
 end

data/lib/has_localization_table/version.rb

@@ -1,3 +1,3 @@
 module HasLocalizationTable
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/has_localization_table.rb

@@ -1,7 +1,5 @@
 require "has_localization_table/version"
 require "has_localization_table/config"
-require "has_localization_table/class_methods"
-require "has_localization_table/instance_methods"
 require "has_localization_table/active_record"
 
 ActiveRecord::Base.extend(HasLocalizationTable::ActiveRecord) if defined?(ActiveRecord::Base)

data/spec/active_record/attributes_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe HasLocalizationTable do
+  before do
+    # Configure HLT
+    HasLocalizationTable.configure do |c|
+      c.primary_locale = Locale.first 
+      c.current_locale = Locale.first
+      c.all_locales = Locale.all
+    end
+
+    Object.send(:remove_const, :Article) rescue nil
+    Article = Class.new(ActiveRecord::Base)
+    Article.has_localization_table
+  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
+    a.name.must_equal "Test"
+    a.description.must_equal "Description"
+  end
+  
+  it "should create mutator methods" do
+    a.name = "Changed"
+    a.description = "Changed Description"
+    a.name.must_equal "Changed"
+    a.description.must_equal "Changed Description"
+    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
+
+    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")
+    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: {} })
+
+    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")
+    
+    aa.reload
+    
+    Locale.current = fre
+    aa.name.must_equal "French Name"
+    aa.description.must_equal "French Description"
+  end
+end

data/spec/active_record/finder_method_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe HasLocalizationTable do
+  before do
+    # Configure HLT
+    HasLocalizationTable.configure do |c|
+      c.primary_locale = Locale.first 
+      c.current_locale = Locale.first
+      c.all_locales = Locale.all
+    end
+
+    Object.send(:remove_const, :Article) rescue nil
+    Article = Class.new(ActiveRecord::Base)
+    Article.has_localization_table
+  end
+  
+  let(:a) { Article.new(name: "Test", description: "Description") }
+  
+  it "should create finder methods" do
+    a.save!
+    Article.find_by_name("Test").must_equal a
+    Article.find_by_description("Description").must_equal a
+    Article.find_by_name_and_description("Test", "Description").must_equal a
+    Article.find_by_description_and_name("Description", "Test").must_equal a
+    
+    Article.find_by_name("Wrong").must_be_nil
+    Article.find_by_description("Wrong").must_be_nil
+  end
+end

data/spec/active_record/ordered_by_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe HasLocalizationTable do
+  before do
+    # Configure HLT
+    HasLocalizationTable.configure do |c|
+      c.primary_locale = Locale.first 
+      c.current_locale = Locale.first
+      c.all_locales = Locale.all
+    end
+
+    Object.send(:remove_const, :Article) rescue nil
+    Article = Class.new(ActiveRecord::Base)
+    Article.has_localization_table
+  end
+  
+  let(:a) { Article.new(name: "Test", description: "Description") }
+  
+  it "should create ordered_by methods" do
+    a.save!
+    b = Article.create!(name: "Name", description: "Another Description")
+    c = Article.create!(name: "Once Upon a Time...", description: "Fairytale")
+    Article.ordered_by_name.must_equal [b, c, a]
+    Article.ordered_by_description.must_equal [b, a, c]
+    Article.ordered_by_name(false).must_equal [a, c, b]
+  end
+  
+  it "should allow ordered_by methods to apply to scope chains" do
+    a.save!
+    b = Article.create!(name: "Name", description: "Another Description")
+    c = Article.create!(name: "Once Upon a Time...", description: "Fairytale")
+    Article.scoped.ordered_by_name.must_equal [b, c, a]
+  end
+end

data/spec/active_record/relation_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe HasLocalizationTable do
+  before do
+    # Configure HLT
+    HasLocalizationTable.configure do |c|
+      c.primary_locale = Locale.first 
+      c.current_locale = Locale.first
+      c.all_locales = Locale.all
+    end
+
+    Object.send(:remove_const, :Article) rescue nil
+    Article = Class.new(ActiveRecord::Base)
+  end
+  
+  it "should alias with_localizations with the actual association name" do
+    Article.has_localization_table :strings
+    assert Article.respond_to? :with_strings
+  end
+end

data/spec/active_record/validation_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe HasLocalizationTable do
+  before do
+    # Configure HLT
+    HasLocalizationTable.configure do |c|
+      c.primary_locale = Locale.first 
+      c.current_locale = Locale.first
+      c.all_locales = Locale.all
+    end
+
+    Object.send(:remove_const, :Article) rescue nil
+    Article = Class.new(ActiveRecord::Base)
+    Article.has_localization_table
+  end
+  
+  let(:a) { Article.new(name: "Test", description: "Description") }
+  
+  it "should add validations if given required: true" do
+    Article.has_localization_table required: true
+    a = Article.new
+    refute a.valid?
+    a.errors[:localizations].wont_be_empty
+    
+    a = Article.new(description: "Wishing the world hello!")
+    s = a.localizations.first
+    refute s.valid?
+    s.errors[:name].wont_be_empty
+  end
+  
+  it "should not add validations if given required: false" do
+    Article.has_localization_table required: false
+    a = Article.new
+    assert a.valid?
+    a.errors[:localizations].must_be_empty
+    
+    a = Article.new(description: "Wishing the world hello!")
+    s = a.localizations.first
+    assert s.valid?
+    s.errors[:name].must_be_empty
+  end
+  
+  it "should not add validations if required is not given" do
+    Article.has_localization_table
+    a = Article.new
+    assert a.valid?
+    a.errors[:localizations].must_be_empty
+    
+    a = Article.new(description: "Wishing the world hello!")
+    s = a.localizations.first
+    assert s.valid?
+    s.errors[:name].must_be_empty
+  end
+  
+  it "should not add validations for optional fields" do
+    Article.has_localization_table required: true, optional: [:description]
+    a = Article.new(name: "Test")
+    assert a.valid?
+    a.errors[:localizations].must_be_empty
+    assert a.localizations.all?{ |s| s.errors[:description].empty? }
+  end
+end

data/spec/active_record_spec.rb

@@ -1,34 +1,5 @@
 require 'spec_helper'
 
-# Setup in-memory database so AR can work
-ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
-ActiveRecord::Migration.tap do |m|
-  m.create_table :articles do |t|
-    t.timestamps
-  end
-
-  m.create_table :locales do |t|
-    t.string :name
-  end
-
-  m.create_table :article_localizations do |t|
-    t.integer :article_id
-    t.integer :locale_id
-    t.string :name
-    t.string :description
-  end
-end
-
-# Set up locales
-Locale = Class.new(ActiveRecord::Base)
-Locale.create!(name: "English")
-Locale.create!(name: "French")
-
-ArticleLocalization = Class.new(ActiveRecord::Base) do
-  belongs_to :article
-  belongs_to :locale
-end
-
 describe HasLocalizationTable do
   before do
     # Configure HLT
@@ -76,123 +47,5 @@ describe HasLocalizationTable do
       
       Object.send(:remove_const, :ArticleText)
     end
-     
-    it "should add validations if given required: true" do
-      Article.has_localization_table required: true
-      a = Article.new
-      refute a.valid?
-      a.errors[:localizations].wont_be_empty
-      
-      a = Article.new(description: "Wishing the world hello!")
-      s = a.localizations.first
-      refute s.valid?
-      s.errors[:name].wont_be_empty
-    end
-    
-    it "should not add validations if given required: false" do
-      Article.has_localization_table required: false
-      a = Article.new
-      a.valid? or raise a.localizations.map(&:errors).inspect
-      a.errors[:localizations].must_be_empty
-      
-      a = Article.new(description: "Wishing the world hello!")
-      s = a.localizations.first
-      assert s.valid?
-      s.errors[:name].must_be_empty
-    end
-    
-    it "should not add validations if required is not given" do
-      Article.has_localization_table
-      a = Article.new
-      assert a.valid?
-      a.errors[:localizations].must_be_empty
-      
-      a = Article.new(description: "Wishing the world hello!")
-      s = a.localizations.first
-      assert s.valid?
-      s.errors[:name].must_be_empty
-    end
-    
-    it "should not add validations for optional fields" do
-      Article.has_localization_table required: true, optional: [:description]
-      a = Article.new(name: "Test")
-      assert a.valid?
-      a.errors[:localizations].must_be_empty
-      assert a.localizations.all?{ |s| s.errors[:description].empty? }
-    end
-  end
-  
-  describe "other methods" do
-    before do
-      Object.send(:remove_const, :Article) rescue nil
-      Article = Class.new(ActiveRecord::Base)
-      Article.has_localization_table
-    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
-      a.name.must_equal "Test"
-      a.description.must_equal "Description"
-    end
-    
-    it "should create mutator methods" do
-      a.name = "Changed"
-      a.description = "Changed Description"
-      a.name.must_equal "Changed"
-      a.description.must_equal "Changed Description"
-      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 create finder methods" do
-      a.save!
-      Article.find_by_name("Test").must_equal a
-      Article.find_by_description("Description").must_equal a
-      Article.find_by_name_and_description("Test", "Description").must_equal a
-      Article.find_by_description_and_name("Description", "Test").must_equal a
-      
-      Article.find_by_name("Wrong").must_be_nil
-      Article.find_by_description("Wrong").must_be_nil
-    end
-    
-    it "should create ordered_by methods" do
-      a.save!
-      b = Article.create!(name: "Name", description: "Another Description")
-      c = Article.create!(name: "Once Upon a Time...", description: "Fairytale")
-      Article.ordered_by_name.must_equal [b, c, a]
-      Article.ordered_by_description.must_equal [b, a, c]
-    end
   end
 end

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
 require 'minitest/autorun'
 require 'active_record'
 require 'has_localization_table'
+require 'support/setup'
 
 class MiniTest::Spec
   def run(*args, &block)

data/spec/support/setup.rb

@@ -0,0 +1,28 @@
+# Setup in-memory database so AR can work
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+ActiveRecord::Migration.tap do |m|
+  m.create_table :articles do |t|
+    t.timestamps
+  end
+
+  m.create_table :locales do |t|
+    t.string :name
+  end
+
+  m.create_table :article_localizations do |t|
+    t.integer :article_id
+    t.integer :locale_id
+    t.string :name
+    t.string :description
+  end
+end
+
+# Set up locales
+Locale = Class.new(ActiveRecord::Base)
+Locale.create!(name: "English")
+Locale.create!(name: "French")
+
+ArticleLocalization = Class.new(ActiveRecord::Base) do
+  belongs_to :article
+  belongs_to :locale
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: has_localization_table
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &11607560 !ruby/object:Gem::Requirement
+  requirement: &10582840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *11607560
+  version_requirements: *10582840
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &11606680 !ruby/object:Gem::Requirement
+  requirement: &10581980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *11606680
+  version_requirements: *10581980
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &11606080 !ruby/object:Gem::Requirement
+  requirement: &10581320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *11606080
+  version_requirements: *10581320
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &11605360 !ruby/object:Gem::Requirement
+  requirement: &10580720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *11605360
+  version_requirements: *10580720
 description: Automatically sets up usage of a relational table to contain user-created
   multi-locale string attributes
 email:
@@ -71,12 +71,23 @@ files:
 - has_localization_table.gemspec
 - lib/has_localization_table.rb
 - lib/has_localization_table/active_record.rb
-- lib/has_localization_table/class_methods.rb
+- lib/has_localization_table/active_record/attributes.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
+- lib/has_localization_table/active_record/ordered_by.rb
+- lib/has_localization_table/active_record/relation.rb
+- lib/has_localization_table/active_record/validations.rb
 - lib/has_localization_table/config.rb
-- lib/has_localization_table/instance_methods.rb
 - lib/has_localization_table/version.rb
+- spec/active_record/attributes_spec.rb
+- spec/active_record/finder_method_spec.rb
+- spec/active_record/ordered_by_spec.rb
+- spec/active_record/relation_spec.rb
+- spec/active_record/validation_spec.rb
 - spec/active_record_spec.rb
 - spec/spec_helper.rb
+- spec/support/setup.rb
 homepage: https://github.com/dvandersluis/has_localization_table
 licenses: []
 post_install_message: 
@@ -103,6 +114,12 @@ specification_version: 3
 summary: Sets up associations and attribute methods for AR models that have a relational
   table to contain user-created data in multiple languages.
 test_files:
+- spec/active_record/attributes_spec.rb
+- spec/active_record/finder_method_spec.rb
+- spec/active_record/ordered_by_spec.rb
+- spec/active_record/relation_spec.rb
+- spec/active_record/validation_spec.rb
 - spec/active_record_spec.rb
 - spec/spec_helper.rb
+- spec/support/setup.rb
 has_rdoc: 

data/lib/has_localization_table/class_methods.rb

@@ -1,127 +0,0 @@
-module HasLocalizationTable
-  module ClassMethods
-    def self.extended(klass)
-      klass.class_eval do
-        create_localization_association!
-        
-        # Initialize string records after main record initialization
-        after_initialize do
-          build_missing_localizations!
-        end
-        
-        before_validation do
-          reject_empty_localizations!
-          build_missing_localizations!
-        end
-        
-        # Reject any blank strings before saving the record
-        # Validation will have happened by this point, so if there is a required string that is needed, it won't be rejected
-        before_save do
-          reject_empty_localizations!
-        end
-        
-        # Add validation to ensure a string for the primary locale exists if the string is required
-        validate do
-          if localization_table_options[:required] || false
-            errors.add(localization_association_name, :primary_lang_string_required) unless localization_association.any? do |string|
-              string.send(HasLocalizationTable.locale_foreign_key) == HasLocalizationTable.primary_locale.id
-            end
-          end
-        end
-      end
-      
-      klass.localized_attributes.each do |attribute|
-        # Add validation to make all string fields required for the primary locale
-        klass.send(:localization_class).class_eval do
-          validates attribute, presence: { message: :custom_this_field_is_required },
-            if: proc { |model| klass.name.constantize.localized_attribute_required?(attribute) && model.send(HasLocalizationTable.locale_foreign_key) == HasLocalizationTable.current_locale.id }
-        end
-      end
-      
-      # Alias the scoping method to use the actual association name
-      alias_method :"with_#{klass.localization_association_name}", :with_localizations
-    end
-    
-    def localization_class
-      localization_table_options[:class_name].constantize
-    end
-    
-    def localization_association_name
-      localization_table_options[:association_name]
-    end
-    
-    def localized_attributes
-      # Determine which attributes of the association model should be accessable through the base class
-      # ie. everything that's not a primary key, foreign key, or timestamp attribute
-      association_name = self.localization_table_options[:association_name] || :strings
-      association = reflect_on_association(association_name)
-      
-      attribute_names = association.klass.attribute_names
-      timestamp_attrs = association.klass.new.send(:all_timestamp_attributes_in_model).map(&:to_s)
-      foreign_keys = association.klass.reflect_on_all_associations.map{ |a| a.association_foreign_key }
-      primary_keys = [association.klass.primary_key]
-      # protected_attrs = association.klass.protected_attributes.to_a
-      
-      (attribute_names - timestamp_attrs - foreign_keys - primary_keys).map(&:to_sym)
-    end
-    
-    def localized_attribute_required?(attribute)
-      return false unless localization_table_options[:required] || false
-      return true unless localization_table_options[:optional]
-      
-      !localization_table_options[:optional].include?(attribute) 
-    end
-    
-    def method_missing(name, *args, &block)
-      if name.to_s =~ /\Afind_by_([a-z0-9_]+(_and_[a-z0-9_]+)*)\Z/
-        attributes = $1.split("_and_").map(&:to_sym)
-        if (attributes & localized_attributes).size == attributes.size
-          raise ArgumentError, "expected #{attributes.size} #{"argument".pluralize(attributes.size)}: #{attributes.join(", ")}" unless args.size == attributes.size
-          args = attributes.zip(args).inject({}) { |memo, (key, val)| memo[key] = val; memo }
-          return find_by_localized_attributes(args)
-        end
-      elsif name.to_s =~ /\Aordered_by_([a-z0-9_]+)\Z/
-        attribute = $1.to_sym
-        return ordered_by_localized_attribute(attribute, *args) if localized_attributes.include?(attribute)
-      end
-      
-      super
-    end
-    
-    def respond_to?(*args)
-      if args.first.to_s =~ /\Afind_by_([a-z0-9_]+(_and_[a-z0-9_]+)*)\Z/
-        attributes = $1.split("_and_").map(&:to_sym)
-        return true if (attributes & localized_attributes).size == attributes.size
-      elsif name.to_s =~ /\Aordered_by_([a-z0-9_]+)\Z/
-        return true if localized_attributes.include?($1.to_sym)
-      end
-      
-      super
-    end
-    
-    def with_localizations
-      lcat = localization_class.arel_table
-      
-      scoped.joins(
-        arel_table.join(lcat, Arel::Nodes::OuterJoin).
-          on(lcat[:"#{self.name.underscore}_id"].eq(arel_table[self.primary_key]).and(lcat[HasLocalizationTable.locale_foreign_key].eq(HasLocalizationTable.current_locale.id))).
-          join_sql
-      )
-    end
-    
-  private
-    def create_localization_association!
-      self.has_many localization_association_name, localization_table_options.except(:association_name, :required, :optional)
-    end
-    
-    # Find a record by multiple localization values
-    def find_by_localized_attributes(attributes, locale = HasLocalizationTable.current_locale)
-      with_localizations.where(localization_class.table_name => attributes).first
-    end
-    
-    # Order records by localization value
-    def ordered_by_localized_attribute(attribute, asc = true, locale = HasLocalizationTable.current_locale)
-      with_localizations.order("#{localization_class.table_name}.#{attribute} #{asc ? "ASC" : "DESC"}")
-    end
-  end
-end

data/lib/has_localization_table/instance_methods.rb

@@ -1,78 +0,0 @@
-module HasLocalizationTable
-  module InstanceMethods
-    def read_localized_attribute(attribute, locale = HasLocalizationTable.current_locale)
-      attribute_cache[attribute.to_sym][locale.id] ||= localization_association.detect{ |a| a.send(HasLocalizationTable.locale_foreign_key) == locale.id }.send(attribute) rescue nil
-    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_association.build(HasLocalizationTable.locale_foreign_key => locale.id)
-      
-      localization.send(:"#{attribute}=", value)
-      attribute_cache[attribute.to_sym][locale.id] = value.blank? ? nil : 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
-            # 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)
-            return read_localized_attribute($1, args.first) || read_localized_attribute($1, HasLocalizationTable.primary_locale)
-          else
-            raise ArgumentError, "wrong number of arguments (#{args.size} for 1)" unless args.size == 1
-            return write_localized_attribute($1, args.first)
-          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)
-      super
-    end
-  
-  private
-    # Add localization objects for any available locale that doesn't have one 
-    def build_missing_localizations!
-      locale_ids = HasLocalizationTable.all_locales.map(&:id)
-      HasLocalizationTable.all_locales.each do |l|
-        unless localization_association.detect{ |str| str.send(HasLocalizationTable.locale_foreign_key) == l.id }
-          localization_association.build(HasLocalizationTable.locale_foreign_key => l.id)
-        end
-        
-        localization_association.sort_by!{ |l| locale_ids.index(l.send(HasLocalizationTable.locale_foreign_key)) || 0 }
-      end
-    end
-    
-    # Remove localization objects that are not filled in
-    def reject_empty_localizations!
-      localization_association.reject! { |l| !l.persisted? and localized_attributes.all?{ |attr| l.send(attr).blank? } }
-    end
-    
-    # Helper method for getting the localization association without having to look up the name each time
-    def localization_association
-      @localization_association ||= begin
-        association_name = localization_table_options[:association_name]
-        send(association_name)
-      end
-    end
-    
-    def attribute_cache
-      @localized_attribute_cache ||= localized_attributes.inject({}) { |memo, attr| memo[attr] = {}; memo }
-    end
-    
-    def localized_attributes
-      self.class.localized_attributes
-    end
-    
-    def localization_table_options
-      self.class.localization_table_options
-    end
-  end
-end