traco 3.1.2 → 3.1.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YTc4OWNjMzkxOTcwNzE3NmE4NDM4MDQ4MWM5MGIyMzJkNjRlZWY0OQ==
+    NGU5NTFmYTU4ZDQ5ZDA5ZWUyMzIyYjNiZDkxOGZiYzkyZDAwOGU1ZA==
   data.tar.gz: !binary |-
-    NTYzYTFhZmFjYzk1Yjk1ZTM4NGJhN2QyOGIwNGM1ZTYzZDg0OGI2NQ==
+    OTI3ODAxOTgwNTE1OGQyZmFjYjUxMTJlZjQ1MmI0YjBkNTY0MjU5OA==
 SHA512:
   metadata.gz: !binary |-
-    MWRjNTM2ZjcyYTZhNTliYmUzNjg4OWJlZTBiMTdjMTA3NzM1ODBkMTJlOGVi
-    NjQzZmJhMzhkMTA5YjdkYmQzY2NiODk3YzM2YzMzZWNiMGMzNGYzYWEyYWZj
-    Nzg3NzE4OGE4NDE5OWE2YjQyNzI1OTAyN2I2MWMwZTk5ZmNiYmY=
+    NGFlOGM1M2QyMjVjZmQzNjQ1MjRkZDYxNDE5ZWQzOGQ2MjFkODFlNjU3ZjI2
+    Y2UxNTJiYTZmYTRiM2FiMDFkYzYxMDRkMGNkMjA5NjVlNzIzYWNmMjJiZWFm
+    MzU4Y2NiZWNlODk1MWMxODEyMTg4NTRmMDQ1ZjBkZmRlNjlkNDg=
   data.tar.gz: !binary |-
-    YzY1OGI0MTc3OTNhOGU2NzJhYWQxYWU3YzI2N2IwZWM0MGQxNDY4Yjc1MGE3
-    NDY3ZTBiNTc5MDNiNzNlNzEyNTEwNTNhNjc2MTEwOWVmZDgyNDkzNmVkNjdi
-    NDhmMDBkMmFlMjNiNWI4NTJmMTRlMTM5N2NmYzliMTU1ZjExODc=
+    NWQ2MmFlZDZhY2FhZTllMTZkMTUzMWI2ZWRkZDEwNzBkMmY5M2Y2YmM0NjIz
+    MGIwZmY3MmY3YTgxYTY0NzVmODM4M2Q1Mjk0ZTI5MDU1MjYxOTM0N2U3Njll
+    NmQ0MWY4NzBmNjcyMjk2M2M2ZGQwNTdmMjBlNWU5ZmExMjU2MDA=

data/Gemfile

@@ -1,4 +1,8 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in the .gemspec.
 gemspec
+
+group :benchmark do
+  gem "benchmark-ips"
+end

data/README.md

@@ -134,6 +134,11 @@ to install it.
     rake
 
 
+## Benchmark
+
+    ruby benchmarks/overhead.rb
+
+
 <!-- Keeping this a hidden brain dump for now.
 
 ## TODO
@@ -150,6 +155,17 @@ Possible improvements to make:
 
 -->
 
+## Contributors
+
+* [Henrik Nyh](http://henrik.nyh.se)
+* Andrii Malyshko
+* Tobias Bohwalli
+* Mario Alberto Chavez
+* Philip Arndt
+* Leung Ho Kuen
+* Fernando Morgenstern
+* Tomáš Horáček
+* Joakim Kolsjö
 
 ## Credits and license
 

data/benchmarks/overhead.rb

@@ -0,0 +1,41 @@
+# This benchmark tests how fast a Traco-wrapped attribute is
+# compared to the plain Active Record attribute.
+
+require "bundler/setup"
+require "benchmark/ips"
+require "active_record"
+require "traco"
+
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+
+I18n.enforce_available_locales = false
+I18n.available_locales = [ :en, :de, :sv ]
+I18n.default_locale = :en
+I18n.locale = :sv
+
+COLUMNS = %w(title body long_title seo_title)
+
+silence_stream(STDOUT) do
+  ActiveRecord::Schema.define(version: 0) do
+    create_table :posts, force: true do |t|
+      I18n.available_locales.each do |locale|
+        COLUMNS.each do |column|
+          t.string "#{column}_#{locale}"
+        end
+      end
+    end
+  end
+end
+
+class Post < ActiveRecord::Base
+  translates *COLUMNS
+end
+
+post = Post.new(title_en: "hello", title_sv: "Hej")
+
+Benchmark.ips do |x|
+  x.report("activerecord") { post.title_sv }
+  x.report("traco") { post.title }
+
+  x.compare!
+end

data/lib/traco.rb

@@ -1,11 +1,57 @@
 require "traco/version"
-require "traco/translates"
+require "traco/attributes"
 require "traco/class_methods"
-require "traco/localized_reader"
+require "traco/locale_fallbacks"
+require "traco/translates"
 
 module Traco
-  # E.g. :sv -> :sv, :"pt-BR" -> :pt_br
-  def self.locale_suffix(locale)
-    locale.to_s.downcase.sub("-", "_").to_sym
+  COLUMN_RE =
+    /\A
+      (?<attribute>\w+?)        # title
+      _                         # _
+      (?<primary>[a-z]{2})      # pt
+      (
+        _                       # _
+        (?<extended>[a-z]{2})   # br
+      )?
+    \z/x
+
+  # @example
+  #   Traco.column("title", :sv)      # => :title_sv
+  #   Traco.column("title", :"pt-BR") # => :title_pt_br
+  def self.column(attribute, locale)
+    normalized_locale = locale.to_s.downcase.sub("-", "_")
+    "#{attribute}_#{normalized_locale}".to_sym
+  end
+
+  # @example
+  #   Traco.split_localized_column("title_sv")     # => [:title, :sv]
+  #   Traco.split_localized_column("title_pt_br")  # => [:title, :"pt-BR"]
+  #   Traco.split_localized_column("unlocalized")  # => nil
+  def self.split_localized_column(column)
+    match_data = column.to_s.match(COLUMN_RE)
+    return unless match_data
+
+    attribute       = match_data[:attribute]
+    primary_locale  = match_data[:primary]
+    extended_locale = match_data[:extended]
+
+    if extended_locale
+      locale = "#{primary_locale}-#{extended_locale.upcase}"
+    else
+      locale = primary_locale
+    end
+
+    [ attribute.to_sym, locale.to_sym ]
+  end
+
+  def self.locale_name(locale)
+    default = locale.to_s.upcase.sub("_", "-")
+    I18n.t(locale, scope: :"i18n.languages", default: default)
+  end
+
+  def self.locale_with_fallbacks(locale, fallback_option)
+    locale_fallbacks_resolver = LocaleFallbacks.new(fallback_option)
+    locale_fallbacks_resolver[locale]
   end
 end

data/lib/traco/attributes.rb

@@ -0,0 +1,71 @@
+module Traco
+  class Attributes < Module
+    def initialize(*attributes)
+      @options = attributes.extract_options!
+      @attributes = attributes.map(&:to_sym)
+
+      attributes.each do |attribute|
+        define_reader(attribute)
+        define_writer(attribute)
+      end
+    end
+
+    def included(base)
+      self.class.ensure_translatable_attributes(base)
+      base.translatable_attributes |= @attributes
+
+      self.class.warm_up_activerecord_methods(base)
+
+      base.extend ClassMethods
+    end
+
+    private
+
+    def define_reader(attribute)
+      class_eval <<-EOM, __FILE__, __LINE__ + 1
+        def #{attribute}(options = {})
+          default_fallback = #{@options.fetch(:fallback, LocaleFallbacks::DEFAULT_FALLBACK).inspect}
+          fallback = options.fetch(:fallback, default_fallback)
+
+          columns_to_try = self.class._locale_columns_for_attribute(:#{attribute}, fallback)
+          columns_to_try.each do |column|
+            value = send(column)
+            return value if value.present?
+          end
+
+          nil
+        end
+      EOM
+    end
+
+    def define_writer(attribute)
+      class_eval <<-EOM, __FILE__, __LINE__ + 1
+        def #{attribute}=(value)
+          column = Traco.column(:#{attribute}, I18n.locale).to_s + "="
+          send(column, value)
+        end
+      EOM
+    end
+
+    # Only called once per class or inheritance chain (e.g. once
+    # for the superclass, not at all for subclasses). The separation
+    # is important if we don't want to overwrite values if running
+    # multiple times in the same class or in different classes of
+    # an inheritance chain.
+    def self.ensure_translatable_attributes(base)
+      return if base.respond_to?(:translatable_attributes)
+
+      base.class_attribute :translatable_attributes
+      base.translatable_attributes = []
+    end
+
+    # Force AR to create methods `title_en` etc, which are lazily evaluated,
+    # otherwise we can't safely check `.instance_methods`.
+    def self.warm_up_activerecord_methods(base)
+      random_attribute = base.translatable_attributes.first
+
+      instance = base.new
+      instance.send(Traco.column(random_attribute, I18n.default_locale))
+    end
+  end
+end

data/lib/traco/class_methods.rb

@@ -1,61 +1,70 @@
 module Traco
   module ClassMethods
-    LOCALE_RE = /[a-zA-Z]{2}(?:_[a-zA-Z]{2})?/
-
     def locales_for_attribute(attribute)
-      re = /\A#{attribute}_(#{LOCALE_RE})\z/
+      traco_cache(attribute, LocaleFallbacks::ANY_FALLBACK).keys
+    end
 
-      column_names.
-        grep(re) { $1.to_sym }.
-        sort_by(&locale_sort_value)
+    # Consider this method internal.
+    def _locale_columns_for_attribute(attribute, fallback)
+      traco_cache(attribute, fallback).values
     end
 
     def locale_columns(*attributes)
-      attributes.inject([]) { |memo, attribute|
-        memo += locales_for_attribute(attribute).map { |locale|
-          :"#{attribute}_#{locale}"
-        }
-      }
+      attributes.each_with_object([]) do |attribute, columns|
+        columns.concat(_locale_columns_for_attribute(attribute, LocaleFallbacks::ANY_FALLBACK))
+      end
     end
 
     def current_locale_column(attribute)
-      :"#{attribute}_#{I18n.locale.to_s.downcase.sub("-", "_")}"
+      Traco.column(attribute, I18n.locale)
     end
 
-    def human_attribute_name(attribute, options = {})
-      default = super(attribute, options.merge(default: ""))
+    def human_attribute_name(column, options = {})
+      attribute, locale = Traco.split_localized_column(column)
 
-      if default.blank? && attribute.to_s.match(/\A(\w+?)_(#{LOCALE_RE})\z/)
-        column, locale = $1, $2.to_sym
-        if translates?(column)
-          return "#{super(column, options)} (#{locale_name(locale)})"
-        end
+      if translates?(attribute)
+        default = super(column, options.merge(default: ""))
+        default.presence || "#{super(attribute, options)} (#{Traco.locale_name(locale)})"
+      else
+        super
       end
-
-      super
     end
 
     private
 
-    def locale_sort_value
-      lambda { |locale|
-        if locale == Traco.locale_suffix(I18n.default_locale)
-          # Sort the default locale first.
-          "0"
-        else
-          # Sort the rest alphabetically.
-          locale.to_s
-        end
-      }
-    end
-
     def translates?(attribute)
-      translatable_attributes.include?(attribute.to_sym)
+      translatable_attributes.include?(attribute)
     end
 
-    def locale_name(locale)
-      default = locale.to_s.upcase.sub("_", "-")
-      I18n.t(locale, scope: :"i18n.languages", default: default)
+    # Structured by (current) locale => attribute => fallback option => {locale_to_try => column}.
+    # @example
+    #     {
+    #       :"pt-BR" => {
+    #         title: {
+    #           default: { :"pt-BR" => :title_pt_br, :en => :title_en },
+    #           any: { :"pt-BR" => :title_pt_br, :en => :title_en, :sv => :title_sv }
+    #         },
+    #       },
+    #       :sv => {
+    #         title: {
+    #           default: { :sv => :title_sv, :en => :title_en },
+    #           any: { :sv => :title_sv, :en => :title_en, :"pt-BR" => :title_pt_br }
+    #         }
+    #       }
+    #     }
+    def traco_cache(attribute, fallback)
+      cache = @traco_cache ||= {}
+      per_locale_cache = cache[I18n.locale] ||= {}
+      per_attribute_cache = per_locale_cache[attribute] ||= {}
+
+      per_attribute_cache[fallback] ||= begin
+        locales_to_try = Traco.locale_with_fallbacks(I18n.locale, fallback)
+
+        locales_to_try.each_with_object({}) do |locale, columns|
+          column = Traco.column(attribute, locale)
+          columns[locale] = column if instance_methods.include?(column)
+        end
+      end
     end
   end
 end

data/lib/traco/locale_fallbacks.rb

@@ -0,0 +1,46 @@
+# Intended to be API compatible with https://github.com/svenfuchs/i18n/blob/master/lib/i18n/locale/fallbacks.rb
+
+module Traco
+  class LocaleFallbacks
+    OPTIONS = [
+      DEFAULT_FALLBACK = :default,
+      ANY_FALLBACK = :any,
+      NO_FALLBACK = false,
+    ]
+
+    attr_reader :fallback_option
+    private :fallback_option
+
+    def initialize(fallback_option)
+      @fallback_option = validate_option(fallback_option)
+      @default_locale = I18n.default_locale
+      @available_locales = I18n.available_locales.sort
+    end
+
+    def [](for_locale)
+      chain = [for_locale]
+      chain << @default_locale if include_default_locale?
+      chain |= @available_locales if include_available_locales?
+      chain
+    end
+
+    private
+
+    def include_default_locale?
+      [ DEFAULT_FALLBACK, ANY_FALLBACK ].include?(fallback_option)
+    end
+
+    def include_available_locales?
+      ANY_FALLBACK == fallback_option
+    end
+
+    def validate_option(fallback_option)
+      if OPTIONS.include?(fallback_option)
+        fallback_option
+      else
+        valids = OPTIONS.map(&:inspect).join(", ")
+        raise ArgumentError.new("Unsupported fallback: #{fallback_option.inspect} (expected one of #{valids})")
+      end
+    end
+  end
+end

data/lib/traco/translates.rb

@@ -1,11 +1,7 @@
-require "traco/attribute_setup"
-
 module Traco
   module Translates
     def translates(*attributes)
-      options = attributes.extract_options!
-      attributes = attributes.map(&:to_sym)
-      AttributeSetup.new(self).set_up(attributes, options)
+      include Traco::Attributes.new(*attributes)
     end
   end
 end

data/lib/traco/version.rb

@@ -1,3 +1,3 @@
 module Traco
-  VERSION = "3.1.2"
+  VERSION = "3.1.3"
 end

data/spec/locale_fallbacks_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+require "traco/locale_fallbacks"
+
+describe Traco::LocaleFallbacks do
+  describe "#initialize" do
+    it "accepts :default, :any, and false as valid arguments" do
+      expect {
+        Traco::LocaleFallbacks.new(:default)
+        Traco::LocaleFallbacks.new(:any)
+        Traco::LocaleFallbacks.new(false)
+      }.not_to raise_error
+    end
+
+    it "raises ArgumentError if invalid argument passed in" do
+      expect { Traco::LocaleFallbacks.new(:invalid) }.to raise_error(ArgumentError)
+      expect { Traco::LocaleFallbacks.new(nil) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#[]" do
+        context "with the :default option" do
+      it "returns given locale, then default locale" do
+        I18n.default_locale = :en
+        subject = Traco::LocaleFallbacks.new(:default)
+        expect(subject[:sv]).to eq [ :sv, :en ]
+      end
+    end
+
+    context "with the :any option" do
+      it "returns given locale, then default locale, then remaining available locales alphabetically" do
+        I18n.default_locale = :en
+        I18n.available_locales = [ :en, :sv, :uk, :de ]
+        subject = Traco::LocaleFallbacks.new(:any)
+        expect(subject[:sv]).to eq [ :sv, :en, :de, :uk ]
+      end
+    end
+
+    context "with the false option" do
+      it "returns only given locale" do
+        subject = Traco::LocaleFallbacks.new(false)
+        expect(subject[:sv]).to eq [ :sv ]
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,33 +1,9 @@
+require "i18n"
+
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
   config.filter_run focus: true
   config.run_all_when_everything_filtered = true
-
-  # Clear class state before each spec.
-  config.before(:each) do
-    Object.send(:remove_const, 'Post')
-    Object.send(:remove_const, 'SubPost')
-    load 'app/post.rb'
-  end
-end
-
-# Test against real ActiveRecord models.
-# Very much based on the test setup in
-# https://github.com/iain/translatable_columns/
-
-require "active_record"
-require "app/post.rb"
-
-ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
-
-silence_stream(STDOUT) do
-  ActiveRecord::Schema.define(version: 0) do
-    create_table :posts, force: true do |t|
-      t.string :title_sv, :title_en, :title_pt_br
-      t.string :body_sv, :body_en, :body_pt_br
-    end
-  end
 end
 
 I18n.enforce_available_locales = false
-I18n.load_path << "spec/app/sv.yml"

data/spec/spec_helper_models.rb

@@ -0,0 +1,28 @@
+RSpec.configure do |config|
+  # Clear class state before each spec.
+  config.before(:each) do
+    Object.send(:remove_const, 'Post')
+    Object.send(:remove_const, 'SubPost')
+    load "app/post.rb"
+  end
+end
+
+# Test against real ActiveRecord models.
+# Very much based on the test setup in
+# https://github.com/iain/translatable_columns/
+
+require "active_record"
+require "app/post.rb"
+
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+
+silence_stream(STDOUT) do
+  ActiveRecord::Schema.define(version: 0) do
+    create_table :posts, force: true do |t|
+      t.string :title_sv, :title_en, :title_pt_br
+      t.string :body_sv, :body_en, :body_pt_br
+    end
+  end
+end
+
+I18n.load_path << "spec/app/sv.yml"

data/spec/traco_spec.rb

@@ -1,8 +1,29 @@
 # encoding: utf-8
 
+require "spec_helper_models"
 require "spec_helper"
 require "traco"
 
+describe Traco, ".split_localized_column" do
+  subject { described_class }
+
+  it "returns attribute and locale" do
+    expect(subject.split_localized_column("title_sv")).to eq [:title, :sv]
+  end
+
+  it "handles normalized locales" do
+    expect(subject.split_localized_column("title_pt_br")).to eq [:title, :"pt-BR"]
+  end
+
+  it "returns nil if column is not localized" do
+    expect(subject.split_localized_column("title")).to be_nil
+  end
+
+  it "returns nil if column is not localized but with undercores" do
+    expect(subject.split_localized_column("long_title")).to be_nil
+  end
+end
+
 describe ActiveRecord::Base, ".translates" do
   it "is available" do
     expect(Post).to respond_to :translates
@@ -21,6 +42,12 @@ describe ActiveRecord::Base, ".translates" do
     expect(Post.new).to respond_to :title, :body
   end
 
+  it "allows to define several attributes at once" do
+    expect(Post.new).not_to respond_to :title, :body
+    Post.translates :title, :body
+    expect(Post.new).to respond_to :title, :body
+  end
+
   it "inherits columns from the superclass" do
     Post.translates :title
     SubPost.translates :body
@@ -36,38 +63,59 @@ describe Post, ".translatable_attributes" do
   end
 
   it "lists the translatable attributes" do
-    expect(Post.translatable_attributes).to match_array [ :title ]
+    expect(Post.translatable_attributes).to eq [ :title ]
+  end
+
+  it "inherits attributes from superclass to a subclass" do
+    SubPost.translates :body
+    expect(SubPost.translatable_attributes).to eq [ :title, :body ]
+  end
+
+  it "doesn't inherit attributes from a subclass to superclass" do
+    SubPost.translates :body
+    expect(Post.translatable_attributes).to eq [ :title ]
   end
 end
 
 describe Post, ".locales_for_attribute" do
   before do
     Post.translates :title
+    I18n.locale = :"pt-BR"
   end
 
-  it "lists the locales, default first and then alphabetically" do
-    I18n.default_locale = :"pt-BR"
-    expect(Post.locales_for_attribute(:title)).to match_array [
-      :pt_br, :en, :sv
-    ]
+  it "lists the current locale with :any locale fallback" do
+    expect(Traco).to receive(:locale_with_fallbacks).with(:"pt-BR", :any).and_return([:"pt-BR", :en, :sv])
+    expect(Post.locales_for_attribute(:title)).to eq [ :"pt-BR", :en, :sv ]
+  end
+
+  it "doesn't include a locale if there's no corresponding column for it" do
+    expect(Traco).to receive(:locale_with_fallbacks).with(:"pt-BR", :any).and_return([:"pt-BR", :ru])
+    expect(Post.locales_for_attribute(:title)).to eq [ :"pt-BR" ]
   end
 end
 
 describe Post, ".locale_columns" do
   before do
     Post.translates :title
-    I18n.default_locale = :"pt-BR"
+    I18n.locale = :"pt-BR"
   end
 
-  it "lists the columns-with-locale for that attribute, default locale first and then alphabetically" do
-    expect(Post.locale_columns(:title)).to match_array [
+  it "lists the columns-with-locale for current locale with :any locale fallback" do
+    expect(Traco).to receive(:locale_with_fallbacks).with(:"pt-BR", :any).and_return([:"pt-BR", :en, :sv])
+    expect(Post.locale_columns(:title)).to eq [
       :title_pt_br, :title_en, :title_sv
     ]
   end
 
+  it "doesn't include a column-with-locale if it doesn't exist" do
+    expect(Traco).to receive(:locale_with_fallbacks).with(:"pt-BR", :any).and_return([:"pt-BR", :ru])
+    expect(Post.locale_columns(:title)).to eq [ :title_pt_br ]
+  end
+
   it "supports multiple attributes" do
     Post.translates :body
-    expect(Post.locale_columns(:body, :title)).to match_array [
+    expect(Traco).to receive(:locale_with_fallbacks).with(:"pt-BR", :any).twice.and_return([:"pt-BR", :en, :sv])
+    expect(Post.locale_columns(:body, :title)).to eq [
       :body_pt_br, :body_en, :body_sv,
       :title_pt_br, :title_en, :title_sv
     ]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: traco
 version: !ruby/object:Gem::Version
-  version: 3.1.2
+  version: 3.1.3
 platform: ruby
 authors:
 - Henrik Nyh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-09 00:00:00.000000000 Z
+date: 2014-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -80,15 +80,18 @@ files:
 - Gemfile
 - README.md
 - Rakefile
+- benchmarks/overhead.rb
 - lib/traco.rb
-- lib/traco/attribute_setup.rb
+- lib/traco/attributes.rb
 - lib/traco/class_methods.rb
-- lib/traco/localized_reader.rb
+- lib/traco/locale_fallbacks.rb
 - lib/traco/translates.rb
 - lib/traco/version.rb
 - spec/app/post.rb
 - spec/app/sv.yml
+- spec/locale_fallbacks_spec.rb
 - spec/spec_helper.rb
+- spec/spec_helper_models.rb
 - spec/traco_spec.rb
 - traco.gemspec
 homepage: ''
@@ -117,5 +120,7 @@ summary: Translatable columns for Rails 3 or better, stored in the model table i
 test_files:
 - spec/app/post.rb
 - spec/app/sv.yml
+- spec/locale_fallbacks_spec.rb
 - spec/spec_helper.rb
+- spec/spec_helper_models.rb
 - spec/traco_spec.rb

data/lib/traco/attribute_setup.rb

@@ -1,78 +0,0 @@
-module Traco
-  class AttributeSetup
-    INSTANCE_METHODS_MODULE_NAME = "TracoInstanceMethods"
-
-    def initialize(klass)
-      @klass = klass
-    end
-
-    def set_up(attributes, options)
-      ensure_class_methods
-      ensure_attribute_list
-      ensure_instance_methods_module
-      add_attributes attributes, options
-    end
-
-    private
-
-    def ensure_class_methods
-      klass.extend Traco::ClassMethods
-    end
-
-    # Only called once per class or inheritance chain (e.g. once
-    # for the superclass, not at all for subclasses). The separation
-    # is important if we don't want to overwrite values if running
-    # multiple times in the same class or in different classes of
-    # an inheritance chain.
-    def ensure_attribute_list
-      return if klass.respond_to?(:translatable_attributes)
-      klass.class_attribute :translatable_attributes
-      klass.translatable_attributes = []
-    end
-
-    def ensure_instance_methods_module
-      # Instance methods are defined on an included module, so your class
-      # can just redefine them and call `super`, if you need to.
-      # http://thepugautomatic.com/2013/07/dsom/
-      unless klass.const_defined?(INSTANCE_METHODS_MODULE_NAME, _search_ancestors = false)
-        klass.send :include, klass.const_set(INSTANCE_METHODS_MODULE_NAME, Module.new)
-      end
-    end
-
-    def add_attributes(attributes, options)
-      klass.translatable_attributes |= attributes
-
-      attributes.each do |attribute|
-        define_localized_reader attribute, options
-        define_localized_writer attribute, options
-      end
-    end
-
-    def define_localized_reader(attribute, options)
-      default_fallback = options.fetch(:fallback, Traco::LocalizedReader::DEFAULT_FALLBACK)
-
-      custom_define_method(attribute) do |method_opts = {}|
-        fallback = method_opts.fetch(:fallback, default_fallback)
-
-        Traco::LocalizedReader.new(self, attribute, fallback: fallback).value
-      end
-    end
-
-    def define_localized_writer(attribute, options)
-      custom_define_method("#{attribute}=") do |value|
-        suffix = Traco.locale_suffix(I18n.locale)
-        send("#{attribute}_#{suffix}=", value)
-      end
-    end
-
-    def custom_define_method(name, &block)
-      klass.const_get(INSTANCE_METHODS_MODULE_NAME).module_eval do
-        define_method(name, &block)
-      end
-    end
-
-    def klass
-      @klass
-    end
-  end
-end

data/lib/traco/localized_reader.rb

@@ -1,50 +0,0 @@
-module Traco
-  class LocalizedReader
-    FALLBACK_OPTIONS = [
-      DEFAULT_FALLBACK = :default,
-      ANY_FALLBACK = :any,
-      NO_FALLBACK = false,
-    ]
-
-    def initialize(record, attribute, options)
-      @record = record
-      @attribute = attribute
-      @fallback = options[:fallback]
-      validate_fallback
-    end
-
-    def value
-      locales_to_try.each do |locale|
-        value = @record.send("#{@attribute}_#{Traco.locale_suffix(locale)}")
-        return value if value.present?
-      end
-
-      nil
-    end
-
-    private
-
-    def locales_to_try
-      locale_chain & locales_for_attribute
-    end
-
-    def locale_chain
-      chain = []
-      chain << I18n.locale
-      chain << I18n.default_locale    if [DEFAULT_FALLBACK, ANY_FALLBACK].include?(@fallback)
-      chain += I18n.available_locales if @fallback == ANY_FALLBACK
-      chain.map { |locale| Traco.locale_suffix(locale) }
-    end
-
-    def locales_for_attribute
-      @record.class.locales_for_attribute(@attribute)
-    end
-
-    def validate_fallback
-      unless FALLBACK_OPTIONS.include?(@fallback)
-        valids = FALLBACK_OPTIONS.map(&:inspect).join(", ")
-        raise "Unsupported fallback: #{@fallback.inspect} (expected one of #{valids})"
-      end
-    end
-  end
-end