t9n 0.1.0

data/generators/t9n/templates/migrations/create_translations.rb

@@ -0,0 +1,20 @@
+class CreateTranslations < ActiveRecord::Migration
+  def self.up
+    create_table :translations do |t|
+      t.references  :translatable,  :polymorphic => true
+      t.column      :locale,        :string,  :null => false, :limit => 2
+      t.column      :key,           :string,  :null => false, :limit => 255
+      t.column      :value,         :text
+      t.timestamps
+    end
+
+    add_index :translations, [:translatable_id, :translatable_type], :name => "translations_translatable_index"
+    add_index :translations, [:locale, :key], :name => "translations_locale_key_index"
+    add_index :translations, [:translatable_id, :translatable_type, :locale, :key], :unique => true, 
+              :name => "translations_translatable_locale_key_unique_index"
+  end
+
+  def self.down
+    drop_table :translations
+  end
+end

data/generators/t9n/templates/translation.rb

@@ -0,0 +1,3 @@
+class Translation < ActiveRecord::Base
+  include Perfectline::T9n::Models::Translation
+end

data/init.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), "rails/init.rb")

data/install.rb

@@ -0,0 +1 @@
+puts IO.read(File.join(File.dirname(__FILE__), "README.markdown"))

data/lib/t9n.rb

@@ -0,0 +1,16 @@
+require "t9n/active_record/translatable_attribute"
+
+# include translatable attribute
+ActiveRecord::Base.__send__(:include, Perfectline::T9n::TranslatableAttribute)
+
+require "t9n/backend/active_record"
+require "t9n/backend/extension"
+require "t9n/backend/exception_handler"
+
+# include hoptoad notifier
+I18n.__send__(:include, Perfectline::T9n::Backend::ExceptionHandler)
+I18n.__send__(:include, Perfectline::T9n::Backend::Extension)
+
+# include needed model logic modules
+require "t9n/models/language"
+require "t9n/models/translation"

data/lib/t9n/active_record/translatable_attribute.rb

@@ -0,0 +1,120 @@
+module Perfectline
+  module T9n
+    module TranslatableAttribute
+
+      def self.included(base)
+        base.__send__(:extend, ClassMethods)
+        base.__send__(:include, InstanceMethods)
+      end
+
+      module ClassMethods
+
+        def translated_attributes
+          @translated_attributes ||= {}
+        end
+
+        def translate_attribute(attribute, options = {})
+          if columns_hash.keys.include?(attribute.to_s)
+            raise ArgumentError, "#{self.name} already has an attribute named :#{attribute}"
+          end
+
+          build_translated_attribute(attribute, options, false)
+        end
+
+        def translate_column(column, options = {})
+          unless columns_hash.keys.include?(column.to_s)
+            raise ArgumentError, "#{self.name} does not respond to column: :#{column}"
+          end
+
+          build_translated_attribute(column, options, true)
+        end
+
+        def build_translated_attribute(attribute, options, real_attribute)
+
+          # build key
+          key = "#{self.table_name}.#{((options.delete(:to) || attribute).to_s.gsub(/_/, "."))}"
+          default = options.delete(:default) || "#{attribute}_default"
+
+          # add the attribute name, default and type
+          translated_attributes.store(attribute, {
+                  :key            => key,
+                  :default        => default,
+                  :real_attribute => real_attribute
+          })
+
+          # create a separate method for accessing the original column
+          if real_attribute
+            define_method(default) do
+              self[attribute.to_sym]
+            end
+
+            define_method("#{default}=") do |value|
+              self[attribute.to_sym] = value
+            end
+          end
+
+          define_method(attribute) do
+            read_translatable_attribute(attribute, I18n.locale.to_s)
+          end
+
+          define_method("#{attribute}=") do |value|
+            write_translatable_attribute(attribute, value, I18n.locale.to_s)
+          end
+
+          unless self.base_class.reflect_on_association(:translations)
+            has_many :translations,
+                     :as        => :translatable,
+                     :dependent => :destroy,
+                     :autosave  => true
+          end
+
+        end
+      end
+
+      module InstanceMethods
+
+        def write_translatable_attribute(attribute, value, locale)
+          options = self.class.translated_attributes.fetch(attribute.to_sym)
+
+          if options.fetch(:real_attribute) && I18n.default_locale.to_s == locale
+            __send__("#{options.fetch(:default)}=", value)
+          else
+            translation = translations.detect{ |t| t.key == options.fetch(:key) && t.locale == locale }
+            translation = translations.build(:key => options.fetch(:key), :locale => locale) if translation.nil?
+            translation.value = value
+          end
+        end
+
+        def read_translatable_attribute(attribute, locale)
+          options = self.class.translated_attributes.fetch(attribute.to_sym)
+
+          if options.fetch(:real_attribute) && I18n.default_locale.to_s == locale
+            __send__(options.fetch(:default))
+          else
+            translation = translations.detect{ |t| t.key == options.fetch(:key) && t.locale == locale}
+            translation.nil? ? nil : translation.value
+          end
+        end
+
+        def method_missing(method, *args, &block)
+          if method.to_s.match(/^(#{self.class.translated_attributes.keys.map(&:to_s).join("|")})_([a-z]{2})(=)?$/)
+            if $3 == "="
+              write_translatable_attribute($1, args.first, $2)
+            else
+              read_translatable_attribute($1, $2)
+            end
+          else
+            super
+          end
+        end
+
+        def respond_to?(method, *args, &block)
+          !method.to_s.match(/^(#{self.class.translated_attributes.keys.map(&:to_s).join("|")})_([a-z]{2})(=)?$/).nil? || super
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/t9n/backend/active_record.rb

@@ -0,0 +1,179 @@
+module Perfectline
+  module T9n
+    module Backend
+
+      class ActiveRecord < ::I18n::Backend::Simple
+        INTERPOLATION_RESERVED_KEYS = %w(scope default object)
+
+        attr_accessor :default_backend
+        attr_accessor :cache_storage
+
+        def cache_enabled?
+          return !@cache_storage.nil?
+        end
+
+        def cache_storage=(store)
+          @cache_storage = ActiveSupport::Cache.lookup_store(store, {:namespace => "i18n"})
+        end
+
+        def initialize
+          @default_backend  = I18n::Backend::Simple.new
+          @cache_storage    = ActiveSupport::Cache.lookup_store(:mem_cache_store, {:namespace => "i18n"})
+        end
+
+        def reload!
+          # don't do anything as passenger with multiple rails instances will screw up memcached
+        end
+
+        def available_locales
+          begin
+            ::Translation.available_locales.map(&:to_sym)
+          rescue
+            @default_backend.available_locales
+          end
+        end
+
+        def store_translation(*args)
+          raise MethodNotAllowed, "Create translation not allowed for Perfectline::I18n::Backend"
+        end
+
+        def translate(locale, key, options = {})
+          if locale.nil?
+            raise InvalidLocale.new(locale)
+          end
+
+          if key.is_a?(Array)
+            return key.map{ |k| translate(locale, k, options) }
+          end
+
+          count   = options[:count]
+          scope   = options.delete(:count)
+          default = options.delete(:default)
+          object  = options.delete(:object)
+          values  = options.reject{ |name, value| INTERPOLATION_RESERVED_KEYS.include?(name.to_s) }
+          entry   = lookup(locale, key, scope, object)
+
+          if entry.nil?
+            entry = default(locale, default, key, options) unless default === false
+
+            if entry.nil?
+              raise I18n::MissingTranslationData.new(locale, key, options)
+            end
+          end
+
+          entry = pluralize(locale, entry, count)
+          entry = interpolate(locale, entry, values)
+          entry
+        end
+
+        protected
+
+        def lookup(locale, key, scope = [], object = nil)
+          # bail out instantly if key is nil
+          return unless key
+
+          scope_key = scope_key(scope, key)
+          cache_key = cache_key(locale, key, scope, object)
+
+          # check cache and ignore errors (string keys with spaces for AR error override messages)
+          begin
+            if result = cache_read(cache_key)
+              return result
+            end
+          rescue => exception
+            return nil
+          end
+
+          result = @default_backend.lookup(locale, key, scope)
+
+          if result.nil?
+            if object.kind_of?(::ActiveRecord::Base)
+              result = ::Translation.locale(locale).for(object).lookup(scope_key)
+            else
+              result = ::Translation.orphans.locale(locale).lookup(scope_key)
+            end
+
+            if result.empty?
+              result = nil
+            elsif result.first.key == scope_key
+              result = result.first.value
+            else
+              chop_range = (key.size + 1)..-1
+              result = result.inject({}) do |hash, range|
+                hash[range.key.slice(chop_range)] = range.value
+                hash
+              end
+
+              result = deep_symbolize_keys(unwind_keys(result))
+            end
+          end
+
+          # write to cache
+          cache_write(cache_key, result)
+
+          return result
+        end
+
+        def default(locale, default, key, options = {})
+          begin
+            case default
+              when String then
+                default
+              when Symbol then
+                translate(locale, default, options)
+              when Array then
+                default.map{ |obj| default(locale, obj, key, options.dup) }.compact!.first
+              else
+                # set default to false to avoid endless recursion
+                unless I18n.default_locale?(locale)
+                  translate(I18n.default_locale, key, options.merge(:default => false))
+                end
+            end
+          rescue I18n::MissingTranslationData
+            nil
+          end
+        end
+
+        def cache_read(key)
+          if cache_enabled?
+            return @cache_storage.fetch(key)
+          end
+        end
+
+        def cache_write(key, value)
+          if cache_enabled? && (not value.blank?)
+            @cache_storage.write(key, value)
+          end
+        end
+
+        def cache_clear!
+          if cache_enabled?
+            @cache_storage.clear
+          end
+        end
+
+        def cache_key(locale, key, scope, object)
+          ::Translation.cache_key(locale, scope_key(scope, key), object)
+        end
+
+        def scope_key(scope, key)
+          (Array(scope) + Array(key)).join(".")
+        end
+
+        # >> { "a.b.c" => "d", "a.b.e" => "f", "a.g" => "h", "i" => "j" }.unwind
+        # => { "a" => { "b" => { "c" => "d", "e" => "f" }, "g" => "h" }, "i" => "j"}
+        def unwind_keys(hash)
+          result = {}
+          hash.each do |key, value|
+            keys = key.split(".")
+            curr = result
+            curr = curr[keys.shift] ||= {} while keys.size > 1
+            curr[keys.shift] = value
+          end
+          result
+        end
+
+      end
+    end
+  end
+end

data/lib/t9n/backend/exception_handler.rb

@@ -0,0 +1,24 @@
+module Perfectline
+  module T9n
+    module Backend
+      module ExceptionHandler
+
+        def self.hoptoad_exception_handler(exception, locale, key, scope)
+          unless defined?(HoptoadNotifier)
+            throw RuntimeError, "HoptoadNotifier is not present, please get it from http://hoptoadapp.com/"
+          end
+
+          case exception
+            when MissingTranslationData
+              HoptoadNotifier.notify(exception)
+            else
+              raise exception
+          end
+
+          return exception.message
+        end
+
+      end
+    end
+  end
+end

data/lib/t9n/backend/extension.rb

@@ -0,0 +1,25 @@
+module Perfectline
+  module T9n
+    module Backend
+      module Extension
+
+        def self.available_languages
+
+          unless defined?(Language)
+            throw RuntimeError, "Language model is not defined"
+          end
+
+          if self.backend.respond_to?(:available_languages)
+            self.backend.available_languages
+          end
+
+        end
+
+        def self.default_locale?(locale = nil)
+          locale.nil? ? default_locale == self.locale : default_locale == locale.to_sym
+        end
+
+      end
+    end
+  end
+end

data/lib/t9n/models/language.rb

@@ -0,0 +1,41 @@
+module Perfectline
+  module T9n
+    module Models
+      module Language
+
+        def self.included(base)
+          base.__send__(:include, Scopes)
+          base.__send__(:include, Validations)
+        end
+
+        module Scopes
+
+          def self.included(base)
+            base.class_eval do
+              named_scope :code, lambda{ |code| {:conditions => {:code => code.to_s}} }
+            end
+          end
+
+        end
+
+        module Validations
+
+          def self.included(base)
+            base.class_eval do
+              validates_presence_of :code
+              validates_presence_of :name
+
+              validates_length_of   :code,    :maximum => 5
+              validates_length_of   :name,    :maximum => 200
+              validates_length_of   :native,  :maximum => 200, :allow_blank => true
+
+              validates_uniqueness_of :code
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end