motiro 0.6.3

data/vendor/plugins/globalize/lib/globalize/localization/locale.rb

@@ -0,0 +1,173 @@
+module Globalize
+
+  class NoBaseLanguageError < StandardError; end
+
+=begin rdoc
+  Locale defines the currenctly active _locale_. You'll mostly use it like this:
+    Locale.set("en-US")
+
+  +en+ is the code for English, and +US+ is the country code. The country code is 
+  optional, but you'll need to define it to get a lot of the localization features.
+=end   
+  class Locale
+    attr_reader :language, :country, :code
+    attr_accessor :date_format, :currency_format, :currency_code,
+      :thousands_sep, :decimal_sep, :currency_decimal_sep,
+      :number_grouping_scheme
+
+    @@cache = {}
+    @@translator_class = DbViewTranslator
+    @@translator = {}
+    @@active = nil
+    @@base_language = nil
+    @@base_language_code = nil
+    @@translator = @@translator_class.instance
+
+    # Is there an active locale?
+    def self.active?; !@@active.nil? end
+
+    # This is the focal point of the class. Sets the locale in the familiar
+    # RFC 3066 format (see: http://www.faqs.org/rfcs/rfc3066.html). It can
+    # also take a Locale object. Set it to the +nil+ object, to deactivate 
+    # the locale.
+    def self.set(locale)
+      if locale.kind_of? Locale
+        @@active = locale
+      elsif locale.nil?
+        @@active = nil
+      else
+        @@active = ( @@cache[locale] ||= Locale.new(locale) )
+      end
+    end
+
+    # Clears the locale cache -- used mostly for testing.
+    def self.clear_cache
+      @@cache.clear
+    end
+
+    # Returns the active locale.
+    def self.active; @@active end
+
+    # Sets the base language. The base language is the language that has
+    # complete coverage in the database. For instance, if you have a +Category+
+    # model with a +name+ field, the base language is the language in which names
+    # are stored in the model itself, and not in the translations table.
+    #
+    # Takes either a language code (valid RFC 3066 code like +en+ or <tt>en-US</tt>) 
+    # or a language object.
+    #
+    # May be set with a language code in environment.rb, without accessing the db.
+    def self.set_base_language(lang)
+      if lang.kind_of? Language
+        @@base_language = lang
+      else
+        @@base_language_code = RFC_3066.parse lang
+      end
+    end
+
+    # Returns the base language. Raises an exception if none is set.
+    def self.base_language 
+      @@base_language ? @@base_language :
+        (@@base_language_code ? 
+        (@@base_language = Language.pick(@@base_language_code)) :
+        raise(NoBaseLanguageError, "base language must be defined"))
+    end
+
+    # Is the currently active language the base language?
+    def self.base?
+      active ? active.language == base_language : true
+    end
+
+    # Returns the currently active language model or +nil+.
+    def self.language
+      active? ? active.language : nil
+    end
+
+    # Returns the currently active language code or +nil+.
+    def self.language_code
+      active? ? language.code : nil
+    end
+
+    # Returns the currently active country model or +nil+.
+    def self.country
+      active? ? active.country : nil
+    end
+
+    # Creates a new locale object by looking up an RFC 3066 code in the database.
+    def initialize(code)
+      if code.nil?
+        return
+      end
+
+      rfc = RFC_3066.parse(code)
+      @code = rfc.locale
+
+      @language = Language.pick(rfc)
+      @country = Country.pick(rfc) 
+
+      setup_fields
+    end
+
+    # Sets the translation for +key+.
+    #
+    # :call-seq:
+    #   Locale.set_translation(key, language, *translations) 
+    #   Locale.set_translation(key, *translations) 
+    #
+    # If +language+ is given, define a translation using that language
+    # model, otherwise use the active language.
+    #
+    # Multiple translation strings may be given, in order to define plural forms.
+    # In English, there are only two plural forms, singular and plural, so you 
+    # would provide two strings at the most. The order is determined by the 
+    # formula in the languages database. For English, the order is: singular form,
+    # then plural.
+    #
+    # Example: 
+    #   Locale.set_translation("There are %d items in your cart", 
+    #   "There is one item in your cart", "There are %d items in your cart")
+    def self.set_translation(key, *options)
+      key = key.to_s.gsub('_', ' ') if key.kind_of? Symbol
+      if options.first.kind_of? Language
+        language = options.shift
+      else
+        language = self.language
+      end
+
+      raise ArgumentError, "No translations given" if options.empty?
+      translator.set(key, language, *options)
+    end
+
+    def self.set_pluralized_translation(key, *options)
+      key = key.to_s.gsub('_', ' ') if key.kind_of? Symbol
+      if options.first.kind_of? Language
+        language = options.shift
+      else
+        language = self.language
+      end
+
+      raise ArgumentError, "No translations given" if options.empty?
+      translator.set_pluralized(key, language, *options)
+    end
+    
+    def self.translate(key, default = nil, arg = nil) # :nodoc:
+      key = key.to_s.gsub('_', ' ') if key.kind_of? Symbol
+
+      translator.fetch(key, self.language, default, arg)
+    end
+
+    # Returns the translator object -- mostly for testing and adjusting the cache.
+    def self.translator; @@translator end 
+
+    private
+
+      def setup_fields
+        return if !@country
+
+        [:date_format, :currency_format, :currency_code, :thousands_sep, 
+          :decimal_sep, :currency_decimal_sep, :number_grouping_scheme
+        ].each {|f| instance_variable_set "@#{f}", @country.send(f) }
+      end
+  end
+end
+

data/vendor/plugins/globalize/lib/globalize/localization/rfc_3066.rb

@@ -0,0 +1,40 @@
+module Globalize 
+  class RFC_3066 # :nodoc:
+    attr_accessor :country, :language, :locale
+    def self.parse(locale)
+      # check for validity
+      raise ArgumentError, "bad format for #{locale}, not rfc-3066 compliant" if
+        locale !~ /^[a-zA-Z0-9\-]+$/  
+
+      # split/assign
+      lang, country, remain = locale.split('-', 3)
+      raise ArgumentError, "bad format for #{locale}, not rfc-3066 compliant" if
+        lang !~ /^[a-zA-Z]{1,8}$/
+      new_language = lang if lang.size == 2 || lang.size == 3
+      raise ArgumentError, "bad format for #{locale}, not rfc-3066 compliant" if
+        !new_language && lang != 'i' && lang != 'x'
+      
+      raise ArgumentError, "bad format for #{locale}, not rfc-3066 compliant" if
+        country && (country.size < 2 || country.size > 8)
+      new_country = country if country && country.size == 2
+
+      rfc = self.new
+      rfc.country = new_country
+      rfc.language = new_language
+      rfc.locale = locale
+
+      return rfc
+    end
+
+    def self.valid?(locale)
+      begin
+        parse(locale)
+      rescue ArgumentError
+        return false
+      else
+        return true
+      end
+    end
+
+  end
+end

data/vendor/plugins/globalize/lib/globalize/models/country.rb

@@ -0,0 +1,24 @@
+module Globalize
+  class Country < ActiveRecord::Base # :nodoc:
+    set_table_name "globalize_countries"
+
+    def self.reloadable?; false end
+
+    def self.pick(rfc)
+
+      # assume it's a country code string
+      if rfc.kind_of?(String)
+        find_by_code(rfc)  
+      elsif rfc.kind_of?(RFC_3066)
+        rfc.country ? find_by_code(rfc.country) : nil
+      else
+        raise ArgumentError, "argument must be String or RFC_3066 object"
+      end
+    end
+
+    def number_grouping_scheme
+      attr = read_attribute(:number_grouping_scheme)
+      attr ? attr.intern : nil
+    end
+  end
+end

data/vendor/plugins/globalize/lib/globalize/models/currency.rb

@@ -0,0 +1,188 @@
+module Globalize
+
+=begin rdoc
+  This is what you use for representing money in your ActiveRecord models.
+  It stores values as integers internally and in the database, to safeguard 
+  precision and rounding.
+
+  More importantly for globalization freaks, it prints out the amount correctly
+  in the current locale, via the handy #format method. Try it!
+
+  Example:
+
+    class Product < ActiveRecord::Base
+      composed_of :price, :class_name => "Globalize::Currency", 
+        :mapping => [ %w(price cents) ]
+    end
+
+    product.price -> "SFr. 483'232.43"
+=end
+  class Currency
+    include Comparable
+
+    attr_reader :cents
+    
+    class CurrencyError < StandardError# :nodoc:
+    end
+
+    # Creates a new Currency object, given cents. This is used to tie into
+    # the ActiveRecord aggregation stuff.
+    def initialize(cents)
+      @cents = cents.nil? ? nil : cents.to_i
+    end
+
+    @@no_cents = false
+    def self.no_cents; @@no_cents end
+    def self.no_cents=(val); @@no_cents = val end
+
+    @@free = Currency.new(0)
+    @@free.freeze
+
+    # Returns the Currency object representing a price of 0.
+    def self.free
+      @@free
+    end
+
+    @@na = Currency.new(nil)
+    @@na.freeze
+
+    # Returns the Currency object representing an unknown price.
+    def self.na
+      @@na
+    end
+
+    def <=>(other)
+      if other.respond_to? :cents
+        if na?
+          other.na? ? 0 : 1
+        else
+          other.na? ? -1 : cents <=> other.cents
+        end
+      elsif other.kind_of? Integer
+        na? ? 1 : cents <=> other
+      else
+        raise "can only compare with money or integer"
+      end      
+    end
+
+    def +(other_money)
+      raise TypeError, "parameter to Currency#+ must be Currency object" unless
+        other_money.kind_of? Currency
+      (na? || other_money.na?) ? Currency.na :
+        Currency.new(cents + other_money.cents)
+    end
+
+    def -(other_money)
+      raise TypeError, "parameter to Currency#+ must be Currency object" unless
+        other_money.kind_of? Currency
+      (na? || other_money.na?) ? Currency.na :
+        Currency.new(cents - other_money.cents)
+    end
+
+    # Multiply money by amount
+    def *(amount)
+      return Currency.new(nil) if na?
+      new_cents = amount * cents;
+      new_cents = new_cents.round if new_cents.respond_to? :round
+      Currency.new(new_cents)
+    end
+
+    # Divide money by amount
+    def /(amount)
+      return Currency.new(nil) if na?
+      new_cents = cents / amount;
+      new_cents = new_cents.round if new_cents.respond_to? :round
+      Currency.new(new_cents)
+    end
+
+    # Returns the formatted version of the amount in local currency.
+    # If <tt>:code => true</tt> is specified, format using international
+    # 3-letter currency code. If <tt>:country</tt> is specified as well, 
+    # use that country's currency code for formatting.
+    def format(options = {})
+      return :no_price_available.t("call for price") if na?
+
+      force_cents = options[:force_cents]
+			if options[:code]
+        currency_code = options[:country] ? 
+          options[:country].currency_code : 
+          ( Locale.active? ? Locale.active.currency_code : nil )
+        currency_code ? 
+					self.amount(false, force_cents) + " " + currency_code : 
+					self.amount(false, force_cents)
+      else
+        if Locale.active?
+          fmt = Locale.active.currency_format || '$%n'
+          fmt.sub('%n', self.amount(false, force_cents))
+        else
+          self.amount false, force_cents
+        end
+      end
+    end
+
+    # Returns the formatted version of the amount, but without the currency symbol.
+    # If +unlocalized+ is true, do not format the number according to the current locale,
+    # so <tt>Currency.new(1234567) -> 12345.67</tt>. This is useful for sending the 
+    # amount to payment gateways.
+    def amount(unlocalized = false, force_cents = false)
+      return nil if na?
+      decimal_sep = unlocalized ?
+        '.' :
+        (Locale.active? ? 
+          (Locale.active.currency_decimal_sep || Locale.active.decimal_sep || '.') :
+          '.')
+      dollar_str = unlocalized ? dollar_part.to_s : dollar_part.localize
+      result = dollar_str
+      result << decimal_sep + sprintf("%02d", cent_part) unless 
+        self.class.no_cents && !force_cents
+      return result
+    end
+
+    # Same as #format with no arguments.
+    def to_s
+      self.format
+    end
+
+    # Parse a string or number into a currency object. Easier to use than #new.
+    def self.parse(num)
+      case
+      when num.is_a?(String)
+        raise ArgumentError, "Not an amount (#{num})" if num.delete("^0-9").empty?
+        _dollars, _cents = num.delete("^0-9.").split('.', 2)
+        _cents = _cents ? _cents[0,2] : 0
+        Currency.new(_dollars.to_i * 100 + _cents.to_i)
+      when num.is_a?(Numeric)
+        Currency.new(num * 100)
+      when num.is_a?(NilClass)
+        Currency.na
+      else
+        raise ArgumentError, "Unrecognized object #{num.class.name} for Currency"
+      end
+    end
+
+    # Conversion to self
+    def to_currency
+      self
+    end
+
+    # Is the value 0? Is it free?
+    def empty?
+      cents == 0
+    end
+
+    # Is the value unknown?
+    def na?
+      cents.nil?
+    end
+
+    private
+      def dollar_part
+        na? ? nil : cents / 100
+      end
+
+      def cent_part
+        na? ? nil : cents % 100
+      end
+
+  end
+end

data/vendor/plugins/globalize/lib/globalize/models/language.rb

@@ -0,0 +1,84 @@
+module Globalize
+  class Language < ActiveRecord::Base # :nodoc:
+    set_table_name "globalize_languages"
+
+    validates_presence_of :english_name
+
+    validates_uniqueness_of :iso_639_1, :if => :iso_639_1
+    validates_uniqueness_of :iso_639_2, :if => :iso_639_2
+    validates_uniqueness_of :iso_639_3, :if => :iso_639_3
+    validates_uniqueness_of :rfc_3066,  :if => :rfc_3066
+
+    validates_length_of :pluralization, :maximum => 200, :if => :pluralization
+    validates_format_of :pluralization, :with => /^[c=\d?:%!<>&|() ]+$/, :if => :pluralization,
+      :message => " has invalid characters. Allowed characters are: " + 
+        "'c', '=', 0-9, '?', ':', '%', '!', '<', '>', '&', '|', '(', ')', ' '."
+
+    def self.reloadable?; false end
+
+    def after_initialize
+      if !pluralization.nil? && pluralization.size > 200
+        raise SecurityError, "Pluralization field for #{self.english_name} language " +
+          "contains potentially harmful code. " +
+          "Must be less than 200 characters in length. Was #{pluralization.size} characters."
+      end
+
+      if !pluralization.nil? && pluralization !~ /^[c=\d?:%!<>&|() ]+$/
+        raise SecurityError, "Pluralization field ('#{pluralization}') for #{self.english_name} language " +
+          "contains potentially harmful code. " +
+          "Must only use the characters: 'c', '=', 0-9, '?', ':', " +
+          "'%', '!', '<', '>', '&', '|', '(', ')', ' '."
+      end
+    end
+
+    def self.pick(rfc)
+      if rfc.kind_of? String then rfc = RFC_3066.parse(rfc) end
+      if rfc.locale.include? '-'
+        lang = find_by_rfc_3066(rfc.locale)
+        return lang if lang
+      end
+
+      code = rfc.language
+      if code.size == 2
+        lang = find_by_iso_639_1(code)
+      elsif code.size == 3
+        lang = find_by_iso_639_3(code)
+      end
+
+      lang
+    end
+
+    def code; iso_639_1 || iso_639_3 || rfc_3066; end
+    
+    def code=(new_code)
+      if new_code =~ /-/
+        self.rfc_3066 = new_code
+      else
+        raise ArgumentError, 
+          "code must be in rfc_3066 format, with a hyphen character; was #{new_code}"
+      end
+    end
+
+    def native_name; self['native_name'] || self['english_name'] end
+
+    def ==(other)
+      return false if !other.kind_of? Language
+      self.code == other.code
+    end
+
+    def plural_index(num)
+
+      # number is not defined, so we assume no pluralization
+      return 1 if num.nil?
+
+      c = num
+      expr = pluralization || 'c == 1 ? 2 : 1'
+
+      instance_eval(expr)
+    end
+
+    def to_s;    english_name end
+    def inspect; english_name end
+
+  end
+end

data/vendor/plugins/globalize/lib/globalize/models/model_translation.rb

@@ -0,0 +1,4 @@
+module Globalize
+  class ModelTranslation < Translation # :nodoc:
+  end
+end

data/vendor/plugins/globalize/lib/globalize/models/translation.rb

@@ -0,0 +1,9 @@
+module Globalize # :nodoc:
+  class Translation < ActiveRecord::Base  # :nodoc:
+    set_table_name "globalize_translations"    
+
+    def self.reloadable?; false end
+
+    belongs_to :language
+  end
+end

data/vendor/plugins/globalize/lib/globalize/models/view_translation.rb

@@ -0,0 +1,14 @@
+module Globalize
+  # Represents a view translation in the DB, which is a translation of a string
+  # in the rails application itself. This includes error messages, controllers,
+  # views, and flashes, but not database content.
+  class ViewTranslation < Translation # :nodoc:
+
+    def self.pick(key, language, idx)
+      find(:first, :conditions => [ 
+        'tr_key = ? AND language_id = ? AND pluralization_index = ?', 
+        key, language.id, idx ])
+    end
+
+  end
+end

data/vendor/plugins/globalize/lib/globalize/rails/action_mailer.rb

@@ -0,0 +1,125 @@
+# Search for translated templates or fall back to the default one
+module ActionMailer # :nodoc:
+
+  # Globalize overrides the create! method to support multiple templates
+  # for different locales. For example, for English it will select the template:
+  #   signup_notification.en-US.text.html.rhtml
+  #
+  # It will look for the currently active locale code (en-US) first, 
+  # then the language code (en).
+  #
+  # If neither of those are found, it will use the regular name:
+  #   signup_notification.text.html.rhtml
+  #
+  # It is fully backwards compatible with the original Rails version.
+  class Base
+
+    # Initialize the mailer via the given +method_name+. The body will be
+    # rendered and a new TMail::Mail object created.
+    #
+    # This method is overriden by Globalize to support multiple templates
+    # for different locales. For example, use:
+    #   signup_notification.en-US.text.html.rhtml
+    # It is fully backwards compatible with the original rails version.
+    def create!(method_name, *parameters) #:nodoc:
+      initialize_defaults(method_name)
+      send(method_name, *parameters)
+      
+      # If an explicit, textual body has not been set, we check assumptions.
+      unless String === @body
+        # First, we look to see if there are any likely templates that match,
+        # which include the content-type in their file name (i.e.,
+        # "the_template_file.text.html.rhtml", etc.). Only do this if parts
+        # have not already been specified manually.
+        if @parts.empty?
+          append_localized_parts
+          unless @parts.empty?
+            @content_type = "multipart/alternative"
+            @charset = nil
+            @parts = sort_parts(@parts, @implicit_parts_order)
+          end
+        end
+        
+        # Then, if there were such templates, we check to see if we ought to
+        # also render a "normal" template (without the content type). If a
+        # normal template exists (or if there were no implicit parts) we render
+        # it.
+        render_localized_normal_template
+
+        # Finally, if there are other message parts and a textual body exists,
+        # we shift it onto the front of the parts and set the body to nil (so
+        # that create_mail doesn't try to render it in addition to the parts).
+        if !@parts.empty? && String === @body
+          @parts.unshift Part.new(:charset => charset, :body => @body)
+          @body = nil
+        end
+      end
+
+      # If this is a multipart e-mail add the mime_version if it is not
+      # already set.
+      @mime_version ||= "1.0" if !@parts.empty?
+
+      # build the mail object itself
+      @mail = create_mail
+
+    end
+
+    private
+      def append_localized_parts
+        codes = locale_codes
+        codes.each do |code|
+          if code
+            templates = Dir.glob("#{template_path}/#{@template}.#{code}.*")
+          else
+            templates = Dir.glob("#{template_path}/#{@template}.*")
+          end
+          templates.each do |path|
+            sections = File.basename(path).split(".")[0..-2] || []
+
+            # skip if this is some other language
+            next if !code && Globalize::RFC_3066.valid?(sections[1])
+
+            # skip either template name and locale, or just template name
+            type_sections = code ? sections[2..-1] : sections[1..-1]
+            type = type_sections.join("/")
+            
+            next if type.empty?
+            @parts << Part.new(:content_type => type,
+              :disposition => "inline", :charset => charset,
+              :body => render_message(sections.join('.'), @body))
+          end
+          
+
+          # if we found templates at this stage, no need to continue to defaults
+          break if !templates.empty?
+        end
+      end
+
+      def render_localized_normal_template
+        template_exists = @parts.empty?
+        codes = locale_codes
+        codes.each do |code|
+          localized_name = @template
+          if !template_exists
+            if code 
+              localized_name = [ @template, code ].join(".")
+              template_exists ||= 
+                Dir.glob("#{template_path}/#{localized_name}.*").any? { |i| i.split(".").length == 3 }
+            else
+              template_exists ||= 
+                Dir.glob("#{template_path}/#{@template}.*").any? { |i| i.split(".").length == 2 }
+            end
+          end
+          @body = render_message(localized_name, @body) if template_exists
+          break if template_exists
+        end
+      end
+
+      def locale_codes
+        loc = Globalize::Locale.active
+        lang = Globalize::Locale.language
+        codes = [ loc, lang ].compact.map {|o| o.code }.uniq
+        codes << nil # look for default path, with no localization
+      end
+  end
+end