refinerycms 0.9.7.15 → 0.9.8

data/vendor/plugins/translate/init.rb

@@ -1,8 +0,0 @@
-require 'translate'
-
-# TODO: Use new method available_locales once Rails is upgraded, see:
-# http://github.com/svenfuchs/i18n/commit/411f8fe7c8f3f89e9b6b921fa62ed66cb92f3af4
-def I18n.valid_locales
-  I18n.backend.send(:init_translations) unless I18n.backend.initialized?
-  backend.send(:translations).keys.reject { |locale| locale == :root }
-end

data/vendor/plugins/translate/lib/tasks/translate.rake

@@ -1,193 +0,0 @@
-require 'yaml'
-
-class Hash
-  def deep_merge(other)
-    # deep_merge by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
-    merger = proc { |key, v1, v2| (Hash === v1 && Hash === v2) ? v1.merge(v2, &merger) : v2 }
-    merge(other, &merger)
-  end
-
-  def set(keys, value)
-    key = keys.shift
-    if keys.empty?
-      self[key] = value
-    else
-      self[key] ||= {}
-      self[key].set keys, value
-    end
-  end
-
-  if ENV['SORT']
-    # copy of ruby's to_yaml method, prepending sort.
-    # before each so we get an ordered yaml file
-    def to_yaml( opts = {} )
-      YAML::quick_emit( self, opts ) do |out|
-        out.map( taguri, to_yaml_style ) do |map|
-          sort.each do |k, v| #<- Adding sort.
-            map.add( k, v )
-          end
-        end
-      end
-    end
-  end
-end
-
-namespace :translate do
-
-  def find_missing_translations(locale)
-    keys        = []
-    result      = []
-    locale_hash = {}
-
-    puts "Searching for missing translations for the locale: #{locale}"
-    default_locale_files = Dir.glob(Rails.root.join('vendor', 'plugins', '*', 'config', 'locales', "#{locale}.yml"))
-    default_locale_files += Dir.glob(File.join(Translate.locales_dir, "**","#{locale}.yml"))
-
-    default_locale_files.each do |locale_file_name|
-      yaml = YAML::load(File.open(locale_file_name))
-      locale_hash = locale_hash.deep_merge(yaml[locale.to_s])
-    end
-
-    lookup_pattern = /\b(?:I18n\.t|I18n\.translate|t)(?:\s|\():?'([a-z0-9_]*.[a-z0-9_.]+)'\)?/
-    (Dir.glob(File.join("app", "**","*.{erb,rb}")) + Dir.glob(File.join("vendor", "plugins", "**", "app", "**", "*.{erb,rb}"))).each do |file_name|
-      File.open(file_name, "r+").each do |line|
-        line.scan(lookup_pattern) do |key_string|
-          # qualify the namespace if beginning with . like t('.log_out')
-          if key_string.first =~ /^\./
-            namespace = file_name.gsub(/vendor\/plugins\/.+?\//, "").gsub(/^app\/(models|views|controllers|helpers)\//, '').split('/')
-            namespace = namespace | [namespace.pop.gsub(/^\_/, '').split('.').first]
-            key_string = ["#{namespace.join('.')}#{key_string.first}"]
-          end
-          
-          unless key_exist?(key_string.first.split("."), locale_hash)
-            result << "#{key_string} in \t  #{file_name} \t is not in any #{locale} locale file"
-          end
-        end
-      end unless file_name =~ /translate\/spec/
-    end
-    puts result.empty? ? "No missing translations for locale: #{locale}" : "#{result.join("\n")}\n\nNumber of missing translations for #{locale}: #{result.length}"
-  end
-
-  desc "Show I18n keys that are missing in the specified locale YAML file. Defaults to I18n.default_locale, unless LOCALE env is specified"
-  task :lost_in_translation => :environment do
-    locale      = ENV['LOCALE'] || I18n.default_locale
-    find_missing_translations(locale)
-  end
-
-  desc "Show I18n keys that are missing in all locale YAML files."
-  task :lost_in_translation_all => :environment do
-    ::Refinery::I18n.locales.keys.each do |locale|
-      find_missing_translations(locale)
-      puts "--"
-    end
-  end
-
-  def key_exist?(key_arr, locale_hash)
-    key = key_arr.slice!(0)
-    if key
-      key_exist?(key_arr, locale_hash[key]) if locale_hash && locale_hash.include?(key)
-    elsif locale_hash
-      true
-    else
-      false
-    end
-  end
-
-  desc "Merge I18n keys from log/translations.yml into config/locales/*.yml (for use with the Rails I18n TextMate bundle)"
-  task :merge_keys => :environment do
-    I18n.backend.send(:init_translations)
-    new_translations = YAML::load(IO.read(File.join(Rails.root, "log", "translations.yml")))
-    raise("Can only merge in translations in single locale") if new_translations.keys.size > 1
-    locale = new_translations.keys.first
-
-    overwrites = false
-    Translate::Keys.new.send(:extract_i18n_keys, new_translations[locale]).each do |key|
-      new_text = key.split(".").inject(new_translations[locale]) { |hash, sub_key| hash[sub_key] }
-      existing_text = I18n.backend.send(:lookup, locale.to_sym, key)
-      if existing_text && new_text != existing_text
-        puts "ERROR: key #{key} already exists with text '#{existing_text.inspect}' and would be overwritten by new text '#{new_text}'. " +
-          "Set environment variable OVERWRITE=1 if you really want to do this."
-        overwrites = true
-      end
-    end
-
-    if !overwrites || ENV['OVERWRITE']
-      I18n.backend.store_translations(locale, new_translations[locale])
-      Translate::Storage.new(locale).write_to_file
-    end
-  end
-
-  desc "Apply Google translate to auto translate all texts in locale ENV['FROM'] to locale ENV['TO']"
-  task :google => :environment do
-    raise "Please specify FROM and TO locales as environment variables" if ENV['FROM'].blank? || ENV['TO'].blank?
-
-    # Depends on httparty gem
-    # http://www.robbyonrails.com/articles/2009/03/16/httparty-goes-foreign
-    class GoogleApi
-      include HTTParty
-      base_uri 'ajax.googleapis.com'
-      def self.translate(string, to, from)
-        tries = 0
-        begin
-          get("/ajax/services/language/translate",
-            :query => {:langpair => "#{from}|#{to}", :q => string, :v => 1.0},
-            :format => :json)
-        rescue
-          tries += 1
-          puts("SLEEPING - retrying in 5...")
-          sleep(5)
-          retry if tries < 10
-        end
-      end
-    end
-
-    I18n.backend.send(:init_translations)
-
-    start_at = Time.now
-    translations = {}
-    Translate::Keys.new.i18n_keys(ENV['FROM']).each do |key|
-      from_text = I18n.backend.send(:lookup, ENV['FROM'], key).to_s
-      to_text = I18n.backend.send(:lookup, ENV['TO'], key)
-      if !from_text.blank? && to_text.blank?
-        print "#{key}: '#{from_text[0, 40]}' => "
-        if !translations[from_text]
-          response = GoogleApi.translate(from_text, ENV['TO'], ENV['FROM'])
-          translations[from_text] = response["responseData"] && response["responseData"]["translatedText"]
-        end
-        if !(translation = translations[from_text]).blank?
-          translation.gsub!(/\(\(([a-z_.]+)\)\)/i, '{{\1}}')
-          # Google translate sometimes replaces {{foobar}} with (()) foobar. We skip these
-          if translation !~ /\(\(\)\)/
-            puts "'#{translation[0, 40]}'"
-            I18n.backend.store_translations(ENV['TO'].to_sym, Translate::Keys.to_deep_hash({key => translation}))
-          else
-            puts "SKIPPING since interpolations were messed up: '#{translation[0,40]}'"
-          end
-        else
-          puts "NO TRANSLATION - #{response.inspect}"
-        end
-      end
-    end
-
-    puts "\nTime elapsed: #{(((Time.now - start_at) / 60) * 10).to_i / 10.to_f} minutes"
-    Translate::Storage.new(ENV['TO'].to_sym).write_to_file
-  end
-
-  desc "List keys that have changed I18n texts between YAML file ENV['FROM_FILE'] and YAML file ENV['TO_FILE']. Set ENV['VERBOSE'] to see changes"
-  task :changed => :environment do
-    from_hash = Translate::Keys.to_shallow_hash(Translate::File.new(ENV['FROM_FILE']).read)
-    to_hash = Translate::Keys.to_shallow_hash(Translate::File.new(ENV['TO_FILE']).read)
-    from_hash.each do |key, from_value|
-      if (to_value = to_hash[key]) && to_value != from_value
-        key_without_locale = key[/^[^.]+\.(.+)$/, 1]
-        if ENV['VERBOSE']
-          puts "KEY: #{key_without_locale}"
-          puts "FROM VALUE: '#{from_value}'"
-          puts "TO VALUE: '#{to_value}'"
-        else
-          puts key_without_locale
-        end
-      end
-    end
-  end
-end

data/vendor/plugins/translate/lib/translate.rb

@@ -1,13 +0,0 @@
-module Translate
-  def self.locales_dir=(dir)
-    @locales_dir = dir.to_s
-  end
-
-  def self.locales_dir
-    @locales_dir || Rails.root.join("config", "locales").to_s
-  end
-end
-
-Dir[File.join(File.dirname(__FILE__), "translate", "*.rb")].each do |file|
-  require file
-end

data/vendor/plugins/translate/lib/translate/file.rb

@@ -1,35 +0,0 @@
-require 'fileutils'
-
-class Translate::File
-  attr_accessor :path
-
-  def initialize(path)
-    self.path = path
-  end
-
-  def write(keys)
-    FileUtils.mkdir_p File.dirname(path)
-    File.open(path, "w") do |file|
-      file.puts keys_to_yaml(Translate::File.deep_stringify_keys(keys))
-    end
-  end
-
-  def read
-    File.exists?(path) ? YAML::load(IO.read(path)) : {}
-  end
-
-  # Stringifying keys for prettier YAML
-  def self.deep_stringify_keys(hash)
-    hash.inject({}) { |result, (key, value)|
-      value = deep_stringify_keys(value) if value.is_a? Hash
-      result[(key.to_s rescue key) || key] = value
-      result
-    }
-  end
-
-  private
-  def keys_to_yaml(keys)
-    # Using ya2yaml, if available, for UTF8 support
-    keys.respond_to?(:ya2yaml) ? keys.ya2yaml(:escape_as_utf8 => true) : keys.to_yaml
-  end
-end

data/vendor/plugins/translate/lib/translate/keys.rb

@@ -1,123 +0,0 @@
-require 'pathname'
-
-class Translate::Keys
-  # Allows keys extracted from lookups in files to be cached
-  def self.files
-    @@files ||= Translate::Keys.new.files
-  end
-
-  # Allows flushing of the files cache
-  def self.files=(files)
-    @@files = files
-  end
-
-  def files
-    @files ||= extract_files
-  end
-  alias_method :to_hash, :files
-
-  def keys
-    files.keys
-  end
-  alias_method :to_a, :keys
-
-  def i18n_keys(locale)
-    I18n.backend.send(:init_translations) unless I18n.backend.initialized?
-    extract_i18n_keys(I18n.backend.send(:translations)[locale.to_sym]).sort
-  end
-
-  # Convert something like:
-  #
-  # {
-  #  :pressrelease => {
-  #    :label => {
-  #      :one => "Pressmeddelande"
-  #    }
-  #   }
-  # }
-  #
-  # to:
-  #
-  #  {'pressrelease.label.one' => "Pressmeddelande"}
-  #
-  def self.to_shallow_hash(hash)
-    hash.inject({}) do |shallow_hash, (key, value)|
-      if value.is_a?(Hash)
-        to_shallow_hash(value).each do |sub_key, sub_value|
-          shallow_hash[[key, sub_key].join(".")] = sub_value
-        end
-      else
-        shallow_hash[key.to_s] = value
-      end
-      shallow_hash
-    end
-  end
-
-  # Convert something like:
-  #
-  #  {'pressrelease.label.one' => "Pressmeddelande"}
-  #
-  # to:
-  #
-  # {
-  #  :pressrelease => {
-  #    :label => {
-  #      :one => "Pressmeddelande"
-  #    }
-  #   }
-  # }
-  def self.to_deep_hash(hash)
-    hash.inject({}) do |deep_hash, (key, value)|
-      keys = key.to_s.split('.').reverse
-      leaf_key = keys.shift
-      key_hash = keys.inject({leaf_key.to_sym => value}) { |hash, key| {key.to_sym => hash} }
-      deep_merge!(deep_hash, key_hash)
-      deep_hash
-    end
-  end
-
-  # deep_merge by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
-  def self.deep_merge!(hash1, hash2)
-    merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
-    hash1.merge!(hash2, &merger)
-  end
-
-  private
-  def extract_i18n_keys(hash, parent_keys = [])
-    hash.inject([]) do |keys, (key, value)|
-      full_key = parent_keys + [key]
-      if value.is_a?(Hash)
-        # Nested hash
-        keys += extract_i18n_keys(value, full_key)
-      elsif value.present?
-        # String leaf node
-        keys << full_key.join(".")
-      end
-      keys
-    end
-  end
-
-  def extract_files
-    files_to_scan.inject(HashWithIndifferentAccess.new) do |files, file|
-      IO.read(file).scan(i18n_lookup_pattern).flatten.map(&:to_sym).each do |key|
-        files[key] ||= []
-        path = Pathname.new(File.expand_path(file)).relative_path_from(Pathname.new(Rails.root)).to_s
-        files[key] << path unless files[key].include?(path)
-      end
-      files
-    end
-  end
-
-  def i18n_lookup_pattern
-    /\b(?:I18n\.t|I18n\.translate|t)(?:\s|\():?'([a-z0-9_]+.[a-z0-9_.]+)'\)?/
-  end
-
-  def files_to_scan
-    Dir.glob(File.join(files_root_dir, "{app,config,lib}", "**","*.{rb,erb,rhtml}")) +
-      Dir.glob(File.join(files_root_dir, "public", "javascripts", "**","*.js"))
-  end
-
-  def files_root_dir
-    Rails.root
-  end
-end

data/vendor/plugins/translate/lib/translate/log.rb

@@ -1,39 +0,0 @@
-require 'fileutils'
-class Translate::Log
-  attr_accessor :from_locale, :to_locale, :keys
-
-  def initialize(from_locale, to_locale, keys)
-    self.from_locale = from_locale
-    self.to_locale = to_locale
-    self.keys = keys
-  end
-
-  def write_to_file
-    current_texts = File.exists?(file_path) ? file.read : {}
-    current_texts.merge!(from_texts)
-    file.write(current_texts)
-  end
-
-  def read
-    file.read
-  end
-
-  private
-  def file
-    @file ||= Translate::File.new(file_path)
-  end
-
-  def from_texts
-    Translate::File.deep_stringify_keys(Translate::Keys.to_deep_hash(keys.inject({}) do |hash, key|
-      hash[key] = I18n.backend.send(:lookup, from_locale, key)
-      hash
-    end))
-  end
-
-  def file_path
-    #make sure diff log dir exists
-    translate_log_dir = File.join(RAILS_ROOT,  'log', 'translate')
-    FileUtils.mkdir_p(translate_log_dir)
-    File.join(translate_log_dir, "from_#{from_locale}_to_#{to_locale}.yml")
-  end
-end

data/vendor/plugins/translate/lib/translate/storage.rb

@@ -1,20 +0,0 @@
-class Translate::Storage
-  attr_accessor :locale
-
-  def initialize(locale)
-    self.locale = locale.to_sym
-  end
-
-  def write_to_file
-    Translate::File.new(file_path).write(keys)
-  end
-
-  private
-  def keys
-    {locale => I18n.backend.send(:translations)[locale]}
-  end
-
-  def file_path
-    File.join(Translate.locales_dir, "#{locale}.yml")
-  end
-end