easy_translatable 0.0.7 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2be2c2dc9fc20ce961fad405019f1579d98d1958
-  data.tar.gz: decf8b50cd1b08f0f8da58f3587d042b7c87126f
+  metadata.gz: b058f1009620ef66e0eb9a2425af27841e3f4d61
+  data.tar.gz: 97066aa3b7af92612aff25f95896be71a0f70174
 SHA512:
-  metadata.gz: 32082ff14221d9002f9ab63bd8cec4cd7660f31d447a8e8dda5d29b4c2fd217eccbcd82adb5539555a1c73d5fe5b20b7f5f0d4fa166213d6747e753d6ffdbc6b
-  data.tar.gz: 5edad626aba2bcda39997ac8966871c1ea9122d6b44d86e7ae44eb47771eb9066b4b109a29e65484a164556475e754e0751c5b3ed228e591cb997d9e1bf675d1
+  metadata.gz: 29f96b7b1d821caafea24001ba52d15350527d3df865819a60b17cfafea5fa2aab40459c04be70935b624597ed8f90b68905c79ba2703474d72e9fc63625259e
+  data.tar.gz: 40ddc1c5111c3b3d1ac02bf2d75d87e8349e24d043b0b345b361a28e804e227f122aa17f30e2c833eda46090b4e74b8dca7b929df4bc6084da11ea80b135444e

data/README.md

@@ -0,0 +1,20 @@
+# Translatable
+
+## Requirements
+
+* ActiveRecord 3.2
+* I18n
+
+## Installation
+
+To install just use:
+
+```ruby
+gem install easy_translatable
+```
+
+When using bundler put this in your Gemfile:
+
+```ruby
+gem 'easy_translatable', '~> 0.1.0'
+```

data/lib/translatable/active_record/adapter.rb

@@ -0,0 +1,43 @@
+module Translatable
+  module ActiveRecord
+    class Adapter
+      # The cache caches attributes that already were looked up for read access.
+      # The stash keeps track of new or changed values that need to be saved.
+      attr_accessor :record, :stash, :translations
+      private :record=, :stash=
+
+      def initialize(record)
+        self.record = record
+        self.stash = Attributes.new
+      end
+
+      def fetch_stash(locale, name)
+        value = stash.read(locale, name)
+        return value if value
+        return nil
+      end
+
+      def stash_contains?(locale, name)
+        stash.contains?(locale, name)
+      end
+
+      def fetch(locale, name)
+        value = stash_contains?(locale, name) ? fetch_stash(locale, name) : fetch_attribute(locale, name)
+
+        return value
+      end
+
+      def write(locale, name, value)
+        stash.write(locale, name, value)
+      end
+
+      protected
+
+      def fetch_attribute(locale, name)
+        translation = record.translation_for(locale, name, false)
+        return translation && translation.send(:value)
+      end
+
+    end
+  end
+end

data/lib/translatable/active_record/attributes.rb

@@ -0,0 +1,27 @@
+# Helper class for storing values per locale. Used by Globalize::Adapter
+# to stash and cache attribute values.
+
+module Translatable
+  module ActiveRecord
+    class Attributes < Hash # TODO: Think about using HashWithIndifferentAccess ?
+      def [](locale)
+        locale = locale.to_sym
+        self[locale] = {} unless has_key?(locale)
+        self.fetch(locale)
+      end
+
+      def contains?(locale, name)
+        self[locale].has_key?(name.to_s)
+      end
+
+      def read(locale, name)
+        self[locale][name.to_s]
+      end
+
+      def write(locale, name, value)
+        #raise 'z' if value.nil? # TODO
+        self[locale][name.to_s] = value
+      end
+    end
+  end
+end

data/lib/translatable/active_record/class_methods.rb

@@ -0,0 +1,42 @@
+module Translatable
+  module ActiveRecord
+    module ClassMethods
+      def translation_class
+        Translatable.translation_class
+      end
+
+      def translated?(name)
+        translated_attribute_names.include?(name.to_sym)
+      end
+
+      protected
+
+      def translated_attr_accessor(name)
+        define_method(:"#{name}=") do |value|
+          write_attribute(name, value)
+        end
+        define_method(name) do |*args|
+          self.read_attribute(name, {:locale => args.detect {|a| !a.is_a? Hash }})
+        end
+        alias_method :"#{name}_before_type_cast", name
+      end
+
+      def locale_from(args)
+        args.detect {|a| !a.is_a? Hash }
+      end
+
+      def translations_accessor(name)
+        define_method(:"#{name}_translations") do
+          translations.each_with_object(HashWithIndifferentAccess.new) do |translation, result|
+            result[translation.locale] = translation.send(name)
+          end
+        end
+        define_method(:"#{name}_translations=") do |value|
+          value.each do |(locale, value)|
+            write_attribute name, value, :locale => locale
+          end
+        end
+      end
+    end
+  end
+end

data/lib/translatable/active_record/instance_methods.rb

@@ -0,0 +1,99 @@
+module Translatable
+  module ActiveRecord
+    module InstanceMethods
+      delegate :translated_locales, :to => :translations
+
+      def translatable
+        @translatable ||= Adapter.new(self)
+      end
+
+      def self.included(base)
+        # only Rails > 3.1.x compatibility
+        base.class_eval %{
+          def attributes=(attributes, *args)
+            with_given_locale(attributes) { super }
+          end
+        }
+      end
+
+
+      #def write_attribute(name, value, options = {})
+      #  if translated?(name)
+      #    options = {:locale => Translatable.locale}.merge(options)
+      #
+      #    # Dirty tracking, paraphrased from
+      #    # ActiveRecord::AttributeMethods::Dirty#write_attribute.
+      #    name_str = name.to_s
+      #    if attribute_changed?(name_str)
+      #      # If there's already a change, delete it if this undoes the change.
+      #      old = changed_attributes[name_str]
+      #      changed_attributes.delete(name_str) if value == old
+      #    else
+      #      # If there's not a change yet, record it.
+      #      old = globalize.fetch(options[:locale], name)
+      #      old = old.clone if old.duplicable?
+      #      changed_attributes[name_str] = old if value != old
+      #    end
+      #
+      #    translatable.write(options[:locale], name, value)
+      #  else
+      #    super(name, value)
+      #  end
+      #end
+
+      def translate
+        @translate_me = true
+        self
+      end
+
+      def translate?
+        !@translate_me.nil? && @translate_me = true
+      end
+
+      def read_attribute(name, options = {})
+        options = {:translated => true, :locale => nil}.merge(options)
+        if translated?(name) and options[:translated]
+          if translate? && (value = translatable.fetch(options[:locale] || Translatable.locale, name))
+            value
+          else
+            super(name)
+          end
+        else
+          super(name)
+        end
+      end
+
+      def translated?(name)
+        self.class.translated?(name)
+      end
+
+      def translation_for(locale, name, build_if_missing = false)
+        unless translation_caches["#{locale}_#{name}"]
+          # Fetch translations from database as those in the translation collection may be incomplete
+          _translation = translations.detect{|t| t.locale.to_s == locale.to_s && t.key.to_s == name.to_s }
+          _translation ||= translations.build(:locale => locale) if build_if_missing
+          translation_caches["#{locale}_#{name}"] = _translation if _translation
+        end
+        translation_caches["#{locale}_#{name}"]
+      end
+
+      def translation_caches
+        @translation_caches ||= {}
+      end
+
+
+      def with_given_locale(attributes, &block)
+        attributes.symbolize_keys! if attributes.respond_to?(:symbolize_keys!)
+
+        locale = respond_to?(:locale=) ? attributes.try(:[], :locale) :
+            attributes.try(:delete, :locale)
+
+        if locale
+          Translatable.with_locale(locale, &block)
+        else
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/translatable/active_record/macro.rb

@@ -0,0 +1,96 @@
+module Translatable
+  module ActiveRecord
+    module Macro
+
+      def translatable(*attr_names)
+
+        options = attr_names.extract_options!
+        setup_translatable!(options) unless translatable?
+
+        attr_names = attr_names.map(&:to_sym)
+        attr_names -= translated_attribute_names if defined?(translated_attribute_names)
+
+        if attr_names.present?
+          translation_class.instance_eval %{
+            attr_accessible :#{attr_names.join(', :')}
+                                          }
+
+          attr_names.each do |attr_name|
+            # Detect and apply serialization.
+            serializer = self.serialized_attributes[attr_name.to_s]
+            if serializer.present?
+              if defined?(::ActiveRecord::Coders::YAMLColumn) &&
+                  serializer.is_a?(::ActiveRecord::Coders::YAMLColumn)
+
+                serializer = serializer.object_class
+              end
+
+              translation_class.send :serialize, attr_name, serializer
+            end
+
+            # Create accessors for the attribute.
+            translated_attr_accessor(attr_name)
+            translations_accessor(attr_name)
+
+            # Add attribute to the list.
+            self.translated_attribute_names << attr_name
+          end
+
+          Translatable.add_translatable self
+
+        end
+      end
+
+      def class_name
+        @class_name ||= begin
+          class_name = table_name[table_name_prefix.length..-(table_name_suffix.length + 1)].downcase.camelize
+          pluralize_table_names ? class_name.singularize : class_name
+        end
+      end
+
+      def translatable?
+        included_modules.include?(InstanceMethods)
+      end
+
+      protected
+      def setup_translatable!(options)
+        options[:table_name] ||= Translatable.translation_class.table_name
+        options[:foreign_key] ||= 'record_id'
+        options[:conditions] ||= ''
+
+        class_attribute :translated_attribute_names, :translation_options, :fallbacks_for_empty_translations
+        self.translated_attribute_names = []
+        self.translation_options        = options
+        self.fallbacks_for_empty_translations = options[:fallbacks_for_empty_translations]
+
+        # Alias original relation method so we can safely override it in ClassMethods.
+        #class << self
+        #  alias relation_without_globalize relation
+        #end
+
+        include InstanceMethods
+        extend  ClassMethods
+
+        translation_class.table_name = options[:table_name]
+
+        has_many :translations, :class_name  => translation_class.name,
+                 :foreign_key => options[:foreign_key],
+                 :conditions  => options[:conditions],
+                 :dependent   => :destroy,
+                 :extend      => HasManyExtensions,
+                 :autosave    => false
+
+        #after_create :save_translations!
+        #after_update :save_translations!
+
+        translation_class.instance_eval %{ attr_accessible :lang }
+      end
+    end
+
+    module HasManyExtensions
+      def find_or_initialize_by_locale(locale)
+        with_locale(locale.to_s).first || build(:locale => locale.to_s)
+      end
+    end
+  end
+end

data/lib/translatable/active_record/translate.rb

@@ -1,66 +1,13 @@
 module Translatable
   module ActiveRecord
     module Translate
-      def translate(lang, *attr_names)
 
-        model = self.table_name
-        if Translatable::Config.list.has_key?(model) and self.column_names.include?('group_id')
+    # Ask for translations
+    def translate
 
-          if attr_names.length == 0
-            to_translate = Translatable::Config.list[model]
-            q = has_select_values? ? self : self.select("#{model}.*")
-          else
-            to_translate = attr_names
-            q = self
-          end
-
-          index = 0
-          to_translate.each do |attr|
-
-            if is_in_scope? attr
-              index += 1
-              if Translatable::Config.list[model].include?(attr.to_s)
-                q = q.joins("LEFT JOIN snippets sn#{index} ON sn#{index}.record_id = #{model}.id AND sn#{index}.scope = '#{model}' AND sn#{index}.group_id = #{model}.group_id AND sn#{index}.lang = '#{lang}' AND sn#{index}.key = '#{attr}'").
-                    select("COALESCE(sn#{index}.value, '') AS #{attr}")
-              else
-                q = q.select("#{model}.#{attr}")
-              end
-            end
-
-          end
-
-          q.scoped
-        else
-          self.scoped
-        end
-
-      end
-
-      private
-
-      def has_select_values?
-        self.scoped.select_values.length > 0
-      end
-
-      def is_in_scope?(attr)
-
-        if has_select_values?
-          select_values = self.scoped.select_values.map { |one|
-            if one.is_a?(String)
-              one.split(',').map(&:lstrip).map(&:rstrip)
-            elsif one.is_a?(Symbol)
-              one.to_s
-            end
-          }.flatten
-          is_present = select_values.reject{ |value| !value.is_a?(String) || !value.split('.').last == '*' && !value.split('.').last == attr  }
-          if is_present.nil?
-            false
-          else
-            is_present.length > 0
-          end
-        else
-          true
-        end
+        q = self.scoped
+        q.map(&:translate)
+        q
 
       end
 

data/lib/translatable/active_record.rb

@@ -1,3 +1,8 @@
+require File.expand_path '../active_record/class_methods.rb', __FILE__
+require File.expand_path '../active_record/instance_methods.rb', __FILE__
+require File.expand_path '../active_record/attributes.rb', __FILE__
+require File.expand_path '../active_record/adapter.rb', __FILE__
+require File.expand_path '../active_record/macro.rb', __FILE__
 require File.expand_path '../active_record/translate.rb', __FILE__
 
 module Translatable

data/lib/translatable/default.rb

@@ -1,57 +1,5 @@
-require File.expand_path '../config.rb', __FILE__
+require 'active_record'
 require File.expand_path '../active_record.rb', __FILE__
 
-module Translatable
-  class Base
-
-    include Singleton
-    attr_accessor :models, :clicrdv_models
-
-    CLICRDV_TYPES = %w(model customfield preprosition)
-
-    def self.is_a_customfield?(str)
-      str.match(/\Acustomfields/)
-    end
-
-    def self.is_a_preposition?(str)
-      str.match(/\Apreposition/)
-    end
-
-    def self.is_an_ar_model?(str)
-      is_it = false
-      begin
-        model = str.singularize.camelize.constantize
-        is_it = true if model.superclass.name == 'ActiveRecord::Base' && str != 'customfields'
-      rescue NameError
-      end
-      is_it
-    end
-
-    def self.type str
-      if is_model str
-        'model'
-      elsif is_customfield str
-        'customfield'
-      end
-    end
-
-    # Get all translatables models
-    # @param array of things to translate
-    # @return an array of three elements : ARModels, Customfields and Preprositions
-    def self.clicrdv_models(hash=nil)
-      if hash.nil? || hash.empty?
-        process_me = Config.list
-      else
-        process_me = hash
-      end
-      # Don't remove the v in the block parameters |k,v| this because of Ruby 1.8.7
-      ar_models = process_me.reject{ |k,v| !is_an_ar_model?(k) }
-      customfields = process_me.reject{ |k,v| !is_a_customfield?(k) }
-      prepositions = process_me.reject{ |k,v| !is_a_preposition?(k) }
-
-      [ar_models, customfields, prepositions]
-    end
-  end
-end
-
-ActiveRecord::Base.extend(Translatable::ActiveRecord::Translate)
+ActiveRecord::Base.extend(Translatable::ActiveRecord::Translate)
+ActiveRecord::Base.extend(Translatable::ActiveRecord::Macro)

data/lib/translatable/version.rb

@@ -1,3 +1,3 @@
 module Translatable
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end

data/lib/translatable.rb

@@ -1 +1,58 @@
 require File.join(File.dirname(__FILE__), 'translatable/default.rb')
+
+module Translatable
+
+  @@translatable ||= Hash.new
+  @@translation_class ||= nil
+
+  class << self
+    def locale
+      I18n.locale
+    end
+
+    def locale=(locale)
+      set_locale(locale)
+    end
+
+    def with_locale(locale, &block)
+      previous_locale = read_locale
+      set_locale(locale)
+      result = yield(locale)
+      set_locale(previous_locale)
+      result
+    end
+
+    def translation_class_name=(klass)
+      @@translation_class = klass.constantize
+    end
+    def translation_class
+      @@translation_class ||= nil
+    end
+
+    # Hash of models that are translatable (values are the attrs)
+    def list
+      @@translatable ||= Hash.new
+    end
+
+    def add_translatable(klass)
+      if @@translatable.has_key? klass.name
+        klass.translated_attribute_names.each do |attr|
+          @@translatable[klass.name] << attr unless @@translatable[klass.name].include?(attr)
+        end
+      else
+        @@translatable[klass.name] = klass.translated_attribute_names
+      end
+    end
+
+    protected
+
+    def read_locale
+      Thread.current[:translatable_locale]
+    end
+
+    def set_locale(locale)
+      Thread.current[:translatable_locale] = locale.try(:to_sym)
+    end
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: easy_translatable
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.1.0
 platform: ruby
 authors:
 - Paul Bonaud
@@ -60,10 +60,15 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- README.md
 - lib/translatable.rb
 - lib/translatable/active_record.rb
+- lib/translatable/active_record/adapter.rb
+- lib/translatable/active_record/attributes.rb
+- lib/translatable/active_record/class_methods.rb
+- lib/translatable/active_record/instance_methods.rb
+- lib/translatable/active_record/macro.rb
 - lib/translatable/active_record/translate.rb
-- lib/translatable/config.rb
 - lib/translatable/default.rb
 - lib/translatable/version.rb
 homepage: http://rubygems.org/gems/single_translatable

data/lib/translatable/config.rb

@@ -1,14 +0,0 @@
-module Translatable
-  class Config
-    include Singleton
-    attr_accessor :list
-
-    def self.file=  path
-      instance.list = YAML.load_file path
-    end
-
-    def self.list
-      instance.list
-    end
-  end
-end