globalize2 0.1.0

data/lib/globalize/backend/pluralizing.rb

@@ -0,0 +1,37 @@
+require 'i18n/backend/simple'
+
+module Globalize
+  module Backend
+    class Pluralizing < I18n::Backend::Simple
+      def pluralize(locale, entry, count)
+        return entry unless entry.is_a?(Hash) and count
+        key = :zero if count == 0 && entry.has_key?(:zero)
+        key ||= pluralizer(locale).call(count)
+        raise InvalidPluralizationData.new(entry, count) unless entry.has_key?(key)
+        translation entry[key], :plural_key => key
+      end
+
+      def add_pluralizer(locale, pluralizer)
+        pluralizers[locale.to_sym] = pluralizer
+      end
+
+      def pluralizer(locale)
+        pluralizers[locale.to_sym] || default_pluralizer
+      end
+
+      protected
+        def default_pluralizer
+          pluralizers[:en]
+        end
+
+        def pluralizers
+          @pluralizers ||= { :en => lambda{|n| n == 1 ? :one : :other } }
+        end
+
+        # Overwrite this method to return something other than a String
+        def translation(string, attributes)
+          string
+        end
+    end
+  end
+end

data/lib/globalize/backend/static.rb

@@ -0,0 +1,61 @@
+require 'globalize/backend/pluralizing'
+require 'globalize/locale/fallbacks'
+require 'globalize/translation'
+
+module Globalize
+  module Backend
+    class Static < Pluralizing
+      def initialize(*args)
+        add(*args) unless args.empty?
+      end
+
+      def translate(locale, key, options = {})
+        result, default, fallback = nil, options.delete(:default), nil
+        I18n.fallbacks[locale].each do |fallback|
+          begin
+            result = super(fallback, key, options) and break
+          rescue I18n::MissingTranslationData
+          end
+        end
+        result ||= default locale, default, options
+
+        attrs = {:requested_locale => locale, :locale => fallback, :key => key, :options => options}
+        translation(result, attrs)
+#       translation(result, attrs) || raise(I18n::MissingTranslationData.new(locale, key, options))
+      end
+
+      protected
+
+        alias :orig_interpolate :interpolate unless method_defined? :orig_interpolate
+        def interpolate(locale, string, values = {})
+          result = orig_interpolate(locale, string, values)
+          translation = translation(string)
+          translation.nil? ? result : translation.replace(result)
+        end
+
+        def translation(result, meta = nil)
+          return unless result
+
+          case result
+          when Numeric
+            result
+          when String
+            result = Translation::Static.new(result) unless result.is_a? Translation::Static
+            result.set_meta meta
+            result
+          when Hash
+            Hash[*result.map do |key, value|
+              [key, translation(value, meta)]
+            end.flatten]
+          when Array
+            result.map do |value|
+              translation(value, meta)
+            end
+          else
+            result
+            # raise "unexpected translation type: #{result.inspect}"
+          end
+        end
+    end
+  end
+end

data/lib/globalize/i18n/missing_translations_log_handler.rb

@@ -0,0 +1,41 @@
+# A simple exception handler that behaves like the default exception handler
+# but additionally logs missing translations to a given log.
+#
+# Useful for identifying missing translations during testing.
+# 
+# E.g. 
+#
+#   require 'globalize/i18n/missing_translations_log_handler
+#   I18n.missing_translations_logger = RAILS_DEFAULT_LOGGER
+#   I18n.exception_handler = :missing_translations_log_handler
+#
+# To set up a different log file:
+#
+#   logger = Logger.new("#{RAILS_ROOT}/log/missing_translations.log")
+#   I18n.missing_translations_logger = logger
+
+module I18n
+  @@missing_translations_logger = nil
+  
+  class << self
+    def missing_translations_logger
+      @@missing_translations_logger ||= begin
+        require 'logger' unless defined?(Logger)
+        Logger.new(STDOUT)
+      end
+    end
+  
+    def missing_translations_logger=(logger)
+      @@missing_translations_logger = logger
+    end
+  
+    def missing_translations_log_handler(exception, locale, key, options)
+      if MissingTranslationData === exception
+        missing_translations_logger.warn(exception.message)
+        return exception.message 
+      else
+        raise exception
+      end
+    end
+  end
+end

data/lib/globalize/i18n/missing_translations_raise_handler.rb

@@ -0,0 +1,27 @@
+# A simple exception handler that behaves like the default exception handler
+# but also raises on missing translations.
+#
+# Useful for identifying missing translations during testing.
+# 
+# E.g. 
+#
+#   require 'globalize/i18n/missing_translations_raise_handler
+#   I18n.exception_handler = :missing_translations_raise_handler
+module I18n
+  class << self
+    def missing_translations_raise_handler(exception, locale, key, options)
+      raise exception
+    end
+  end
+  
+#  self.exception_handler = :missing_translations_raise_handler
+end
+
+I18n.exception_handler = :missing_translations_raise_handler
+
+ActionView::Helpers::TranslationHelper.module_eval do
+  def translate(key, options = {})
+    I18n.translate(key, options)
+  end
+  alias :t :translate
+end

data/lib/globalize/load_path.rb

@@ -0,0 +1,63 @@
+# Locale load_path and Locale loading support.
+#
+# To use this include the Globalize::LoadPath::I18n module to I18n like this:
+#
+#   I18n.send :include, Globalize::LoadPath::I18n
+#
+# Clients can add load_paths using:
+#
+#   I18n.load_path.add load_path, 'rb', 'yml'   # pass any number of extensions like this
+#   I18n.load_path << 'path/to/dir'             # usage without an extension, defaults to 'yml'
+#
+# And load locale data using either of:
+#
+#   I18n.load_locales 'en-US', 'de-DE'
+#   I18n.load_locale 'en-US'
+# 
+# This will lookup all files named like:
+#
+#   'path/to/dir/all.yml'
+#   'path/to/dir/en-US.yml'
+#   'path/to/dir/en-US/*.yml'
+#
+# The filenames will be passed to I18n.load_translations which delegates to 
+# the backend. So the actual behaviour depends on the implementation of the
+# backend. I18n::Backend::Simple will be able to read YAML and plain Ruby 
+# files. See the documentation for I18n.load_translations for details.
+
+module Globalize
+  class LoadPath < Array
+    def extensions
+      @extensions ||= ['rb', 'yml']
+    end
+    attr_writer :extensions
+  
+    def locales
+      @locales ||= ['*']
+    end
+    attr_writer :locales
+  
+    def <<(path)
+      push path
+    end
+  
+    def push(*paths)
+      super(*paths.map{|path| filenames(path) }.flatten.uniq.sort)
+    end
+  
+    protected
+  
+      def filenames(path)
+        return [path] if File.file? path
+        patterns(path).map{|pattern| Dir[pattern] }
+      end
+  
+      def patterns(path)
+        locales.map do |locale|
+          extensions.map do |extension|
+            %W(#{path}/all.#{extension} #{path}/#{locale}.#{extension} #{path}/#{locale}/**/*.#{extension})
+          end
+        end.flatten.uniq
+      end
+  end
+end

data/lib/globalize/locale/fallbacks.rb

@@ -0,0 +1,63 @@
+require 'globalize/locale/language_tag'
+
+module I18n
+  @@fallbacks = nil
+    
+  class << self
+    # Returns the current fallbacks. Defaults to +Globalize::Locale::Fallbacks+.
+    def fallbacks
+      @@fallbacks ||= Globalize::Locale::Fallbacks.new
+    end
+    
+    # Sets the current fallbacks. Used to set a custom fallbacks instance.
+    def fallbacks=(fallbacks) 
+      @@fallbacks = fallbacks
+    end
+  end
+end
+
+module Globalize
+  module Locale
+    class Fallbacks < Hash
+      def initialize(*defaults)
+        @map = {}
+        map defaults.pop if defaults.last.is_a?(Hash)
+        
+        defaults = [I18n.default_locale.to_sym] if defaults.empty?
+        self.defaults = defaults 
+      end
+      
+      def defaults=(defaults)
+        @defaults = defaults.map{|default| compute(default, false) }.flatten << :root
+      end
+      attr_reader :defaults
+      
+      def [](tag)
+        tag = tag.to_sym
+        has_key?(tag) ? fetch(tag) : store(tag, compute(tag))
+      end
+    
+      def map(mappings)
+        mappings.each do |from, to|
+          from, to = from.to_sym, Array(to)
+          to.each do |to|
+            @map[from] ||= []
+            @map[from] << to.to_sym
+          end
+        end
+      end
+      
+      protected
+    
+      def compute(tags, include_defaults = true)
+        result = Array(tags).collect do |tag|
+          tags = LanguageTag::tag(tag.to_sym).parents(true).map! {|t| t.to_sym }
+          tags.each{|tag| tags += compute(@map[tag]) if @map[tag] }
+          tags
+        end.flatten
+        result.push *defaults if include_defaults
+        result.uniq
+      end
+    end
+  end
+end

data/lib/globalize/locale/language_tag.rb

@@ -0,0 +1,81 @@
+# for specifications see http://en.wikipedia.org/wiki/IETF_language_tag
+#
+# SimpleParser does not implement advanced usages such as grandfathered tags
+
+module Globalize
+  module Locale
+    module Rfc4646
+      SUBTAGS = [:language, :script, :region, :variant, :extension, :privateuse, :grandfathered]
+      FORMATS = {:language => :downcase, :script => :capitalize, :region => :upcase, :variant => :downcase}
+    end
+    
+    class LanguageTag < Struct.new(*Rfc4646::SUBTAGS)
+      class << self
+        def parser
+          @@parser ||= SimpleParser
+        end
+    
+        def parser=(parser)
+          @@parser = parser
+        end
+    
+        def tag(tag)
+          matches = parser.match(tag)
+          new *matches if matches
+        end
+      end
+  
+      Rfc4646::FORMATS.each do |name, format|
+        define_method(name) { self[name].send(format) unless self[name].nil? }
+      end
+      
+      def to_sym
+        to_s.to_sym
+      end
+      
+      def to_s
+        @tag ||= to_a.compact.join("-")
+      end
+  
+      def to_a
+        members.collect {|attr| self.send(attr) }
+      end
+  
+      def parent
+        segs = to_a.compact
+        segs.length < 2 ? nil : LanguageTag.tag(segs[0..(segs.length-2)].join('-'))
+      end
+      
+      def parents(include_self = true)
+        result, parent = [], self.dup
+        result << parent if include_self
+        while parent = parent.parent
+          result << parent
+        end
+        result
+      end
+  
+      module SimpleParser
+        PATTERN = %r{\A(?:
+          ([a-z]{2,3}(?:(?:-[a-z]{3}){0,3})?|[a-z]{4}|[a-z]{5,8}) # language
+          (?:-([a-z]{4}))?                                        # script
+          (?:-([a-z]{2}|\d{3}))?                                  # region
+          (?:-([0-9a-z]{5,8}|\d[0-9a-z]{3}))*                     # variant
+          (?:-([0-9a-wyz](?:-[0-9a-z]{2,8})+))*                   # extension
+          (?:-(x(?:-[0-9a-z]{1,8})+))?|                           # privateuse subtag
+          (x(?:-[0-9a-z]{1,8})+)|                                 # privateuse tag
+          /* ([a-z]{1,3}(?:-[0-9a-z]{2,8}){1,2}) */               # grandfathered
+          )\z}xi 
+
+        class << self
+          def match(tag)
+            c = PATTERN.match(tag.to_s).captures
+            c[0..4] << (c[5].nil? ? c[6] : c[5])  << c[7] # TODO c[7] is grandfathered, throw a NotImplemented exception here?
+          rescue
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/globalize/model/active_record.rb

@@ -0,0 +1,56 @@
+require 'globalize/translation'
+require 'globalize/locale/fallbacks'
+require 'globalize/model/active_record/adapter'
+require 'globalize/model/active_record/translated'
+
+module Globalize
+  module Model
+    module ActiveRecord
+      class << self
+        def create_proxy_class(klass)
+          module_names = klass.name.split('::')
+          klass_name   = module_names.pop
+          target       = module_names.empty? ? Object : module_names.join('::').constantize
+
+          proxy_class_name = "#{klass_name}Translation"
+          proxy_class = nil
+          begin
+            proxy_class = proxy_class_name.constantize
+          rescue NameError
+            proxy_class = target.const_set proxy_class_name, Class.new(::ActiveRecord::Base)
+          end
+
+          proxy_class.instance_eval do
+            belongs_to "#{klass.name.underscore.gsub('/', '_')}".intern
+          end
+          proxy_class.class_eval do
+            def locale
+              read_attribute(:locale).to_sym
+            end
+
+            def locale=(locale)
+              write_attribute(:locale, locale.to_s)
+            end
+          end
+
+          return proxy_class
+        end
+
+        def define_accessors(klass, attr_names)
+          attr_names.each do |attr_name|
+            klass.send :define_method, attr_name, lambda {
+              globalize.fetch self.class.locale, attr_name
+            }
+            klass.send :define_method, "#{attr_name}_before_type_cast", lambda {
+              globalize.fetch self.class.locale, attr_name
+            }
+            klass.send :define_method, "#{attr_name}=", lambda {|val|
+              globalize.stash self.class.locale, attr_name, val
+              self[attr_name] = val
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/globalize/model/active_record/adapter.rb

@@ -0,0 +1,100 @@
+module Globalize
+  module Model
+    class AttributeStash < Hash
+      def contains?(locale, attr_name)
+        locale = locale.to_sym
+        self[locale] ||= {}
+        self[locale].has_key? attr_name
+      end
+
+      def read(locale, attr_name)
+        locale = locale.to_sym
+        self[locale] ||= {}
+        self[locale][attr_name]
+      end
+
+      def write(locale, attr_name, value)
+        locale = locale.to_sym
+        self[locale] ||= {}
+        self[locale][attr_name] = value
+      end
+    end
+
+    class Adapter
+      def initialize(record)
+        @record = record
+
+        # TODO what exactly are the roles of cache and stash
+        @cache = AttributeStash.new
+        @stash = AttributeStash.new
+      end
+
+      def fetch(locale, attr_name)
+        # locale = I18n.locale
+        is_cached = @cache.contains?(locale, attr_name)
+        is_cached ? @cache.read(locale, attr_name) : begin
+          value = fetch_attribute locale, attr_name
+          @cache.write locale, attr_name, value if value && value.locale == locale
+          value
+        end
+      end
+
+      def stash(locale, attr_name, value)
+        @stash.write locale, attr_name, value
+        @cache.write locale, attr_name, value
+      end
+
+      def update_translations!
+        @stash.each do |locale, attrs|
+          translation = @record.globalize_translations.find_or_initialize_by_locale(locale.to_s)
+          attrs.each{|attr_name, value| translation[attr_name] = value }
+          translation.save!
+        end
+        @stash.clear
+      end
+
+      # Clears the cache
+      def clear
+        @cache.clear
+        @stash.clear
+      end
+
+      def clear_cache
+        @cache.clear
+      end
+      
+      private
+
+      def fetch_attribute(locale, attr_name)
+        fallbacks = I18n.fallbacks[locale].map{|tag| tag.to_s}.map(&:to_sym)
+        
+        # If the translations were included with 
+        # :include => globalize_translations
+        # there is no need to query them again.
+        unless @record.globalize_translations.loaded?
+          translations = @record.globalize_translations.by_locales(fallbacks) 
+        else
+          translations = @record.globalize_translations
+        end
+        result, requested_locale = nil, locale
+
+        # Walk through the fallbacks, starting with the current locale itself, and moving
+        # to the next best choice, until we find a match.
+        # Check the @globalize_set_translations cache first to see if we've just changed the
+        # attribute and not saved yet.
+        fallbacks.each do |fallback|
+          # TODO should we be checking stash or just cache?
+          result = @cache.read(fallback, attr_name) || begin
+            translation = translations.detect {|tr| tr.locale == fallback }
+            translation && translation.send(attr_name)
+          end
+          if result
+            locale = fallback
+            break
+          end
+        end
+        result && Translation::Attribute.new(result, :locale => locale, :requested_locale => requested_locale)
+      end
+    end
+  end
+end