has_localization_table 0.0.4 → 0.1.0

data/README.md

@@ -52,21 +52,37 @@ The gem assumes that the localization table has already been migrated, and the m
 ### `has_localization_table` Arguments
 If given, the first argument is the name used for the association, otherwise it defaults to `strings`.
 
-* `class_name` (default: base class name + "Strings"; ie. `ArticleStrings`) - the name of the localization class.
+* `class_name` (default: base class name + class_suffix) - the name of the localization class.
 * `required` (default: false) - if true, at least a localization object for the primary language (see Configuration section) must be present or validation will fail
 * `optional` (default: []) - if `required` is true, can be used to specify that specific attributes are optional
 
 Any options that can be passed into `has_many` can also be passed along and will be used when creating the association.
 	
 ## Configuration
-`HasLocalizationTable` can also be configured as follows:
+`HasLocalizationTable` can also be configured as follows. Note that if any configuration option responds to `call`, it will be called.
 
 	HasLocalizationTable.configure do |config|
+	  # Default suffix to use for Localization class names
+	  # ie. Article -> ArticleLocalization
+	  config.class_suffix = "Localization"
+	  
+	  # Default localizations association name
+      config.default_association_name = :localizations
+      
+      # Class name for Locale objects
 	  config.locale_class = "Locale"
-	  config.locale_foreign_key = "locale_id"
-	  config.primary_locale = Locale.primary_language
-	  config.current_locale = Locale.current_language
-	  config.all_locales = Locale.all
+	  
+	  # Foreign key used in localization tables to relate to a Locale
+      config.locale_foreign_key = "locale_id"
+      
+      # Primary (main) locale
+	  config.primary_locale = ->{ Locale.primary_language }
+	  
+	  # Current locale
+	  config.current_locale = ->{ Locale.current_language }
+	  
+	  # All available locales
+	  config.all_locales = ->{ Locale.all }
 	end
 
 ## Contributing

data/lib/has_localization_table.rb

@@ -1,15 +1,17 @@
 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)
 
 module HasLocalizationTable
-  [:primary_locale, :current_locale, :all_locales].each do |meth|
-    define_singleton_method meth do
-      l = config.send(meth)
-      return l.call if l.respond_to?(:call)
-      l
+  HasLocalizationTable.config.config.keys.each do |key|
+    define_singleton_method key do
+      val = config.send(key)
+      val = val.call if val.respond_to?(:call)
+      val
     end
   end
 end

data/lib/has_localization_table/active_record.rb

@@ -2,184 +2,17 @@ module HasLocalizationTable
   module ActiveRecord
     def has_localization_table(*args)
       options = args.extract_options!
-      options[:association_name] = args.first
+      options[:association_name] = args.first || HasLocalizationTable.default_association_name
       
       class_attribute :localization_table_options
-      self.localization_table_options = options
+      self.localization_table_options = { dependent: :delete_all, class_name: localization_class.name }.merge(options)
       
       extend(ClassMethods)
       include(InstanceMethods)
     end
-  end
-
-  module ClassMethods
-    def self.extended(klass)
-      options = { dependent: :delete_all }.merge(klass.localization_table_options)
-      
-      association_name = options.delete(:association_name) || :strings
-      
-      # If class_name isn't explicitly defined, try adding String onto the current class name
-      options[:class_name] = klass.name + "String" if options[:class_name].blank? and (Module.const_get(klass.name + "String") rescue false)
-      
-      # Define the association
-      klass.has_many association_name, options.except(:required, :optional)
-      association = klass.reflect_on_association(association_name)
-      
-      klass.class_eval do
-        # Initialize string records after main record initialization
-        after_initialize do
-          build_missing_strings
-        end
-        
-        before_validation do
-          reject_empty_strings
-          build_missing_strings
-        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_strings
-        end
-        
-        # Add validation to ensure a string for the primary locale exists if the string is required
-        validate do
-          if self.class.localization_table_options[:required] || false
-            errors.add(association_name, :primary_lang_string_required) unless send(association_name).any? do |string|
-              string.send(HasLocalizationTable.config.locale_foreign_key) == HasLocalizationTable.primary_locale.id
-            end
-          end
-        end
-        
-        define_method :build_missing_strings do
-          locale_ids = HasLocalizationTable.all_locales.map(&:id)
-          HasLocalizationTable.all_locales.each do |l|
-            send(association_name).build(HasLocalizationTable.config.locale_foreign_key => l.id) unless send(association_name).detect{ |str| str.send(HasLocalizationTable.config.locale_foreign_key) == l.id }
-            send(association_name).sort_by!{ |s| locale_ids.index(s.send(HasLocalizationTable.config.locale_foreign_key)) || 0 }
-          end
-        end
-        private :build_missing_strings
-        
-        define_method :reject_empty_strings do
-          send(association_name).reject! { |s| !s.persisted? and self.class.localized_attributes.all?{ |attr| s.send(attr).blank? } }
-        end
-        private :reject_empty_strings
-        
-        # Find a record by multiple string values
-        define_singleton_method :find_by_localized_attributes do |attributes, locale = HasLocalizationTable.current_locale|
-          string_record = association.klass.where({ HasLocalizationTable.config.locale_foreign_key => locale.id }.merge(attributes)).first
-          string_record.send(klass.to_s.underscore.to_sym) rescue nil
-        end
-        private_class_method :find_by_localized_attributes
-      end
-      
-      klass.localized_attributes.each do |attribute|
-        # Add validation to make all string fields required for the primary locale
-        association.klass.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.config.locale_foreign_key) == HasLocalizationTable.current_locale.id }
-        end
-      
-        # Set up accessors and ordering named_scopes for each non-FK attribute on the base model
-        klass.class_eval do
-          define_method attribute do |locale = HasLocalizationTable.current_locale|
-            # Try to load a string for the given locale
-            # If that fails, try for the primary locale
-            get_cached_localized_attribute(locale, association_name, attribute) || get_cached_localized_attribute(HasLocalizationTable.primary_locale, association_name, attribute)
-          end
-          
-          define_method "#{attribute}=" do |value|
-            cache_localized_attribute(HasLocalizationTable.current_locale, association_name, attribute, value)
-          end
-          
-          define_singleton_method "ordered_by_#{attribute}" do |direction = :asc|
-            direction = direction == :asc ? "ASC" : "DESC"
-            
-            joins(%{
-              LEFT OUTER JOIN #{association.table_name}
-                ON #{association.table_name}.#{association.foreign_key} = #{self.table_name}.#{self.primary_key}
-                  AND #{association.table_name}.#{HasLocalizationTable.config.locale_foreign_key} = %d
-              } % HasLocalizationTable.current_locale.id
-            ).
-            order( "#{association.table_name}.#{attribute} #{direction}")
-            #order{ Squeel::Nodes::Order.new(Squeel::Nodes::Stub.new(association.table_name).send(attribute), direction) }
-          end
-        end
-      end
-    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 and args.size == attributes.size
-          raise ArgumentError, "expected #{attributes.size} #{"argument".pluralize(attributes.size)}" 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 ((attributes & localized_attributes).size == attributes.size)
-      end
-      
-      super
-    end
-  end
-  
-  module InstanceMethods
-  private
-    # Both strings and the associations are memoized, so that if an association adds more than one attribute to the main model, the association doesn't need 
-    # to be loaded each time a different attribute is accessed.
-    def get_cached_localized_attribute(locale, association, attribute)
-      @_localized_attribute_cache ||= {}
-      @_localized_attribute_cache[attribute] ||= {}
-
-      @_localized_association_cache ||= {}
-      @_localized_association_cache[association] ||= {}
-    
-      @_localized_attribute_cache[attribute][locale.id] ||= begin
-        @_localized_association_cache[association][locale.id] ||= send(association).detect{ |a| a.send(HasLocalizationTable.config.locale_foreign_key) == locale.id }
-        s = @_localized_association_cache[association][locale.id].send(attribute) rescue nil
-        s.blank? ? nil : s
-      end
-    end
-    
-    def cache_localized_attribute(locale, association, attribute, value)
-      string = send(association).detect{ |a| a.send(HasLocalizationTable.config.locale_foreign_key) == locale.id } || send(association).build(HasLocalizationTable.config.locale_foreign_key => locale.id)
-      value = value.to_s
-      
-      string.send(:"#{attribute}=", value)
-      
-      @_localized_attribute_cache ||= {}
-      @_localized_attribute_cache[attribute] ||= {}
-      @_localized_attribute_cache[attribute][locale.id] = value.blank? ? nil : value
+    def localization_class
+      (self.name + HasLocalizationTable.class_suffix).constantize
     end
   end
 end

data/lib/has_localization_table/class_methods.rb

@@ -0,0 +1,121 @@
+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_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
+      scoped.joins((<<-eoq % HasLocalizationTable.current_locale.id).gsub(/\s+/, " "))
+        LEFT OUTER JOIN #{localization_class.table_name}
+          ON #{localization_class.table_name}.#{self.name.underscore}_id = #{self.table_name}.#{self.primary_key}
+          AND #{localization_class.table_name}.#{HasLocalizationTable.locale_foreign_key} = %d
+      eoq
+    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/config.rb

@@ -25,12 +25,16 @@ module HasLocalizationTable
     config_accessor :primary_locale
     config_accessor :current_locale
     config_accessor :all_locales
+    config_accessor :class_suffix
+    config_accessor :default_association_name
   end
 
   # this is ugly. why can't we pass the default value to config_accessor...?
   configure do |config|
     config.locale_class = "Locale"
     config.locale_foreign_key = "locale_id"
+    config.class_suffix = "Localization"
+    config.default_association_name = :localizations
     config.primary_locale = ->{ config.locale_class.constantize.first }
     config.current_locale = ->{ config.locale_class.constantize.first }
     config.all_locales = ->{ config.locale_class.constantize.all }

data/lib/has_localization_table/instance_methods.rb

@@ -0,0 +1,78 @@
+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

data/lib/has_localization_table/version.rb

@@ -1,3 +1,3 @@
 module HasLocalizationTable
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

data/spec/active_record_spec.rb

@@ -11,7 +11,7 @@ ActiveRecord::Migration.tap do |m|
     t.string :name
   end
 
-  m.create_table :article_strings do |t|
+  m.create_table :article_localizations do |t|
     t.integer :article_id
     t.integer :locale_id
     t.string :name
@@ -24,7 +24,7 @@ Locale = Class.new(ActiveRecord::Base)
 Locale.create!(name: "English")
 Locale.create!(name: "French")
 
-ArticleString = Class.new(ActiveRecord::Base) do
+ArticleLocalization = Class.new(ActiveRecord::Base) do
   belongs_to :article
   belongs_to :locale
 end
@@ -46,33 +46,33 @@ describe HasLocalizationTable do
     end
     
     it "should track any given options" do
-      Article.has_localization_table :localizations, required: true, optional: [:description]
-      Article.localization_table_options.must_equal({ association_name: :localizations, required: true, optional: [:description] })
+      Article.has_localization_table :strings, required: true, optional: [:description]
+      Article.localization_table_options.slice(:association_name, :required, :optional).must_equal({ association_name: :strings, required: true, optional: [:description] })
     end
     
-    it "should define has_many association on the base class with a default name of :strings" do
+    it "should define has_many association on the base class with a default name of :localizations" do
       Article.has_localization_table
-      assoc = Article.reflect_on_association(:strings)
+      assoc = Article.reflect_on_association(:localizations)
       assoc.wont_be_nil
       assoc.macro.must_equal :has_many
-      assoc.klass.must_equal ArticleString
+      assoc.klass.must_equal ArticleLocalization
     end
     
     it "should use the given association name" do
-      Article.has_localization_table :localizations
-      assoc = Article.reflect_on_association(:localizations)
+      Article.has_localization_table :strings
+      assoc = Article.reflect_on_association(:strings)
       assoc.wont_be_nil
       assoc.macro.must_equal :has_many
-      assoc.klass.must_equal ArticleString
+      assoc.klass.must_equal ArticleLocalization
     end
     
     it "should use the given class" do
-      ArticleText = Class.new(ArticleString)
+      ArticleText = Class.new(ArticleLocalization)
       Article.has_localization_table class_name: ArticleText
-      assoc = Article.reflect_on_association(:strings)
+      assoc = Article.reflect_on_association(:localizations)
       assoc.wont_be_nil
       assoc.macro.must_equal :has_many
-      assoc.klass.name.must_equal "ArticleText"
+      assoc.klass.must_equal ArticleText
       
       Object.send(:remove_const, :ArticleText)
     end
@@ -81,10 +81,10 @@ describe HasLocalizationTable do
       Article.has_localization_table required: true
       a = Article.new
       refute a.valid?
-      a.errors[:strings].wont_be_empty
+      a.errors[:localizations].wont_be_empty
       
       a = Article.new(description: "Wishing the world hello!")
-      s = a.strings.first
+      s = a.localizations.first
       refute s.valid?
       s.errors[:name].wont_be_empty
     end
@@ -92,11 +92,11 @@ describe HasLocalizationTable do
     it "should not add validations if given required: false" do
       Article.has_localization_table required: false
       a = Article.new
-      a.valid? or raise a.strings.map(&:errors).inspect
-      a.errors[:strings].must_be_empty
+      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.strings.first
+      s = a.localizations.first
       assert s.valid?
       s.errors[:name].must_be_empty
     end
@@ -105,10 +105,10 @@ describe HasLocalizationTable do
       Article.has_localization_table
       a = Article.new
       assert a.valid?
-      a.errors[:strings].must_be_empty
+      a.errors[:localizations].must_be_empty
       
       a = Article.new(description: "Wishing the world hello!")
-      s = a.strings.first
+      s = a.localizations.first
       assert s.valid?
       s.errors[:name].must_be_empty
     end
@@ -117,8 +117,8 @@ describe HasLocalizationTable do
       Article.has_localization_table required: true, optional: [:description]
       a = Article.new(name: "Test")
       assert a.valid?
-      a.errors[:strings].must_be_empty
-      assert a.strings.all?{ |s| s.errors[:description].empty? }
+      a.errors[:localizations].must_be_empty
+      assert a.localizations.all?{ |s| s.errors[:description].empty? }
     end
   end
   
@@ -132,8 +132,8 @@ describe HasLocalizationTable do
     let(:a) { Article.new(name: "Test", description: "Description") }
     
     it "should set localized attributes" do
-      a.strings.first.name.must_equal "Test"
-      a.strings.first.description.must_equal "Description"
+      a.localizations.first.name.must_equal "Test"
+      a.localizations.first.description.must_equal "Description"
     end
     
     it "should create accessor methods" do
@@ -153,8 +153,8 @@ describe HasLocalizationTable do
       a.description = "Changed Description"
       a.name.must_equal "Changed"
       a.description.must_equal "Changed Description"
-      a.strings.first.name.must_equal "Changed"
-      a.strings.first.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
@@ -167,8 +167,8 @@ describe HasLocalizationTable do
       a.name = "French Name"
       a.description = "French Description"
       
-      eng = a.strings.detect{ |s| s.locale_id == Locale.first.id }
-      fre = a.strings.detect{ |s| s.locale_id == Locale.last.id }
+      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"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: has_localization_table
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &21033000 !ruby/object:Gem::Requirement
+  requirement: &11803100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *21033000
+  version_requirements: *11803100
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &21032340 !ruby/object:Gem::Requirement
+  requirement: &11802200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *21032340
+  version_requirements: *11802200
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &21031960 !ruby/object:Gem::Requirement
+  requirement: &11800680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *21031960
+  version_requirements: *11800680
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &21031480 !ruby/object:Gem::Requirement
+  requirement: &11866300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *21031480
+  version_requirements: *11866300
 description: Automatically sets up usage of a relational table to contain user-created
   multi-locale string attributes
 email:
@@ -71,7 +71,9 @@ 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/config.rb
+- lib/has_localization_table/instance_methods.rb
 - lib/has_localization_table/version.rb
 - spec/active_record_spec.rb
 - spec/spec_helper.rb