annotranslate 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9844e84f3c73277b845c29446f59abaf97a5920d
+  data.tar.gz: ed9e7b2bd804335cd33699f6c526de3a8e4ceee1
+SHA512:
+  metadata.gz: 5efe9d3b9ebeee917e8799b2d6b332c0f1c81cc7829644b1661c2cb4951c8d2bfb163af0d634122a750ae7ab394a3ed75da3b8f2fd6ad20f07b6aee146356f84
+  data.tar.gz: 7cbb6539e463afcf867d90d81e20141424c5e590093e20e1d8ad9a047c87907c0bf148b53eceafe0ec5a86034c23201fcddb745c9a51e4f9ccaaf9fd3d3d661f

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Atomic Object
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,4 @@
+annotranslate
+=============
+
+Rails plugin which provides annotation of translatable strings

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+
+desc 'Generate documentation for AnnoTranslate plugin'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'AnnoTranslate - annotate translations for i18n-based rails apps'
+  rdoc.options << '--line-numbers' << '--inline-source' << '--webcvs=https://github.com/atomicobject/annotranslate/tree/master'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+def git(cmd)
+  safe_system("git " + cmd)
+end
+
+def safe_system(cmd)
+  if !system(cmd)
+    puts "Failed: #{cmd}"
+    exit
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require 'annotranslate'

data/install.rb

@@ -0,0 +1,3 @@
+unless Rails::VERSION::MAJOR >= 2 && Rails::VERSION::MINOR >= 2
+  raise "This version of AnnoTranslate requires Rails 2.2 or higher."
+end

data/lib/annotranslate.rb

@@ -0,0 +1,400 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__))
+
+require 'rails/all'
+require 'active_support'
+require 'action_view/helpers/translation_helper'
+require 'logger'
+require 'import_export'
+require 'version'
+
+# Extentions to make internationalization (i18n) of a Rails application simpler.
+# Support the method +translate+ (or shorter +t+) in models/view/controllers/mailers.
+module AnnoTranslate
+
+  # Error for use within AnnoTranslate
+  class AnnoTranslateError < StandardError #:nodoc:
+  end
+
+  # Define empty logger until instanced
+  @@log_file = nil
+  @@logger = nil
+
+  # Whether to pseudo-translate all fetched strings
+  @@pseudo_translate = false
+
+  # Pseudo-translation text to prend to fetched strings.
+  # Used as a visible marker. Default is "["
+  @@pseudo_prepend = "["
+
+  # Pseudo-translation text to append to fetched strings.
+  # Used as a visible marker. Default is "]"
+  @@pseudo_append = "]"
+
+  # An optional callback to be notified when there are missing translations in views
+  @@missing_translation_callback = nil
+
+  # Plugin-specific Rails logger
+  def self.log
+    # Create logger if it doesn't exist yet
+    if @@logger.nil?
+      log_file = Rails.root.join('log', 'annotranslate.log').to_s
+      puts "AnnoTranslate is logging to: #{log_file}"
+      @@logger = Logger.new(File.open(log_file, "w", encoding: 'UTF-8'))
+      @@logger.info "Started new AnnoTranslate logging session!"
+    end
+    # Return the logger instance
+    @@logger
+  end
+
+  class TagHelper
+    include Singleton
+    include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::AssetTagHelper
+  end
+
+  def self.tag_helper
+    TagHelper.instance
+  end
+
+  # Invokes the missing translation callback, if it is defined
+  def self.missing_translation_callback(exception, key, options = {}) #:nodoc:
+    @@missing_translation_callback.call(exception, key, options) if !@@missing_translation_callback.nil?
+  end
+
+  # Set an optional block that gets called when there's a missing translation within a view.
+  # This can be used to log missing translations in production.
+  #
+  # Block takes two required parameters:
+  # - exception (original I18n::MissingTranslationData that was raised for the failed translation)
+  # - key (key that was missing)
+  # - options (hash of options sent to annotranslate)
+  # Example:
+  #   set_missing_translation_callback do |ex, key, options|
+  #     logger.info("Failed to find #{key}")
+  #   end
+  def self.set_missing_translation_callback(&block)
+    @@missing_translation_callback = block
+  end
+
+  def self.translate_with_annotation(scope, path, key, options={})
+    AnnoTranslate.log.info "translate_with_annotation(scope=#{scope}, path=#{path}, key=#{key}, options=#{options.inspect})"
+
+    scope ||= [] # guard against nil scope
+
+    # Let Rails 2.3 handle keys starting with "."
+    # raise AnnoTranslateError, "Skip keys with leading dot" if key.to_s.first == "."
+
+    # Keep the original options clean
+    original_scope = scope.dup
+    scoped_options = {}.merge(options)
+
+    # Raise to know if the key was found
+    scoped_options[:raise] = true
+
+    # Remove any default value when searching with scope
+    scoped_options.delete(:default)
+
+    str = nil # the string being looked for
+
+    # Apply scoping to partial keys
+    key = AnnoTranslate.scope_key_by_partial(key, path)
+
+    # Loop through each scope until a string is found.
+    # Example: starts with scope of [:blog_posts :show] then tries scope [:blog_posts] then
+    # without any automatically added scope ("[]").
+    while str.nil?
+      # Set scope to use for search
+      scoped_options[:scope] = scope
+
+      begin
+        # try to find key within scope (dup the options because I18n modifies the hash)
+        str = I18n.translate(key, scoped_options.dup)
+      rescue I18n::MissingTranslationData => exc
+        # did not find the string, remove a layer of scoping.
+        # break when there are no more layers to remove (pop returns nil)
+        break if scope.pop.nil?
+      end
+    end
+
+    # If a string is not yet found, potentially check the default locale if in fallback mode.
+    if str.nil? && AnnoTranslate.fallback? && (I18n.locale != I18n.default_locale) && options[:locale].nil?
+      # Recurse original request, but in the context of the default locale
+      str ||= AnnoTranslate.translate_with_scope(original_scope, key, options.merge({:locale => I18n.default_locale}))
+    end
+
+    # If a string was still not found, fall back to trying original request (gets default behavior)
+    str ||= I18n.translate(key, options)
+
+    # If pseudo-translating, prepend / append marker text
+    if AnnoTranslate.pseudo_translate? && !str.nil?
+      str = AnnoTranslate.pseudo_prepend + str + AnnoTranslate.pseudo_append
+    end
+
+    tag = tag_helper.content_tag('span', str, :class => 'translation_annotated', :title => key)
+    AnnoTranslate.log.info "  => full_key=#{key}, translation=#{str}, tag=#{tag.inspect}"
+    tag
+  end
+
+  def self.scope_key_by_partial(key, path)
+    if key.to_s.first == "."
+      if path
+        path.gsub(%r{/_?}, ".") + key.to_s
+      else
+        error = "Cannot use t(#{key.inspect}) shortcut because path is not available"
+        AnnoTranslate.log.error error
+        raise error
+      end
+    else
+      key
+    end
+  end
+
+  class << AnnoTranslate
+
+    # Generic translate method that mimics <tt>I18n.translate</tt> (e.g. no automatic scoping) but includes locale fallback
+    # and strict mode behavior.
+    def translate(key, options={})
+      AnnoTranslate.translate_with_annotation(key, @virtual_path, options)
+    end
+
+    alias :t :translate
+  end
+
+  # When fallback mode is enabled if a key cannot be found in the set locale,
+  # it uses the default locale. So, for example, if an app is mostly localized
+  # to Spanish (:es), but a new page is added then Spanish users will continue
+  # to see mostly Spanish content but the English version (assuming the <tt>default_locale</tt> is :en)
+  # for the new page that has not yet been translated to Spanish.
+  def self.fallback(enable = true)
+    @@fallback_mode = enable
+  end
+
+  # If fallback mode is enabled
+  def self.fallback?
+    @@fallback_mode
+  end
+
+  # Toggle whether to true an exception on *all* +MissingTranslationData+ exceptions
+  # Useful during testing to ensure all keys are found.
+  # Passing +true+ enables strict mode, +false+ installs the default exception handler which
+  # does not raise on +MissingTranslationData+
+  def self.strict_mode(enable_strict = true)
+    @@strict_mode = enable_strict
+
+    if enable_strict
+      # Switch to using contributed exception handler
+      I18n.exception_handler = :strict_i18n_exception_handler
+    else
+      I18n.exception_handler = :default_exception_handler
+    end
+  end
+
+  # Get if it is in strict mode
+  def self.strict_mode?
+    @@strict_mode
+  end
+
+  # Toggle a pseudo-translation mode that will prepend / append special text
+  # to all fetched strings. This is useful during testing to view pages and visually
+  # confirm that strings have been fully extracted into locale bundles.
+  def self.pseudo_translate(enable = true)
+    @@pseudo_translate = enable
+  end
+
+  # If pseudo-translated is enabled
+  def self.pseudo_translate?
+    @@pseudo_translate
+  end
+
+  # Pseudo-translation text to prepend to fetched strings.
+  # Used as a visible marker. Default is "[["
+  def self.pseudo_prepend
+    @@pseudo_prepend
+  end
+
+  # Set the pseudo-translation text to prepend to fetched strings.
+  # Used as a visible marker.
+  def self.pseudo_prepend=(v)
+    @@pseudo_prepend = v
+  end
+
+  # Pseudo-translation text to append to fetched strings.
+  # Used as a visible marker. Default is "]]"
+  def self.pseudo_append
+    @@pseudo_append
+  end
+
+  # Set the pseudo-translation text to append to fetched strings.
+  # Used as a visible marker.
+  def self.pseudo_append=(v)
+    @@pseudo_append = v
+  end
+
+  # Additions to TestUnit to make testing i18n easier
+  module Assertions
+
+    # Assert that within the block there are no missing translation keys.
+    # This can be used in a more tailored way that the global +strict_mode+
+    #
+    # Example:
+    #   assert_translated do
+    #     str = "Test will fail for #{I18n.t('a_missing_key')}"
+    #   end
+    #
+    def assert_translated(msg = nil, &block)
+
+      # Enable strict mode to force raising of MissingTranslationData
+      AnnoTranslate.strict_mode(true)
+
+      msg ||= "Expected no missing translation keys"
+
+      begin
+        yield
+        # Credtit for running the assertion
+        assert(true, msg)
+      rescue I18n::MissingTranslationData => e
+        # Fail!
+        error = build_message(msg, "Exception raised:\n?", e)
+        AnnoTranslate.log.error
+        assert_block(error) {false}
+      ensure
+        # uninstall strict exception handler
+        AnnoTranslate.strict_mode(false)
+      end
+
+    end
+  end
+
+  module I18nExtensions
+    # Add an strict exception handler for testing that will raise all exceptions
+    def strict_i18n_exception_handler(exception, locale, key, options)
+      # Raise *all* exceptions
+      raise exception
+    end
+
+  end
+end
+
+module ActionView #:nodoc:
+  class Base
+    # Redefine the +translate+ method in ActionView (contributed by TranslationHelper) that is
+    # context-aware of what view (or partial) is being rendered.
+    # Initial scoping will be scoped to [:controller_name :view_name]
+    def translate_with_annotation(key, options={})
+      # default to an empty scope
+      scope = []
+
+      # In the case of a missing translation, fall back to letting TranslationHelper
+      # put in span tag for a translation_missing.
+      begin
+        AnnoTranslate.translate_with_annotation(scope, @virtual_path, key, options.merge({:raise => true}))
+      rescue AnnoTranslate::AnnoTranslateError, I18n::MissingTranslationData => exc
+        # Call the original translate method
+        str = translate_without_annotation(key, options)
+
+        # View helper adds the translation missing span like:
+        # In strict mode, do not allow TranslationHelper to add "translation missing" span like:
+        # <span class="translation_missing">en, missing_string</span>
+        if str =~ /span class\=\"translation_missing\"/
+          # In strict mode, do not allow TranslationHelper to add "translation missing"
+          raise if AnnoTranslate.strict_mode?
+
+          # Invoke callback if it is defined
+          AnnoTranslate.missing_translation_callback(exc, key, options)
+        end
+
+        str
+      end
+    end
+
+    alias_method_chain :translate, :annotation
+    alias :t :translate
+  end
+end
+
+module ActionController #:nodoc:
+  class Base
+
+    # Add a +translate+ (or +t+) method to ActionController
+    def translate_with_annotation(key, options={})
+      AnnoTranslate.translate_with_annotation([self.controller_name, self.action_name], @virtual_path, key, options)
+    end
+
+    alias_method_chain :translate, :annotation
+    alias :t :translate
+  end
+end
+
+module ActiveRecord #:nodoc:
+  class Base
+    # Add a +translate+ (or +t+) method to ActiveRecord
+    def translate(key, options={})
+      AnnoTranslate.translate_with_annotation([self.class.name.underscore], @virtual_path, key, options)
+    end
+
+    alias :t :translate
+
+    # Add translate as a class method as well so that it can be used in validate statements, etc.
+    class << Base
+
+      def translate(key, options={}) #:nodoc:
+        AnnoTranslate.translate_with_annotation([self.name.underscore], @virtual_path, key, options)
+      end
+
+      alias :t :translate
+    end
+  end
+end
+
+module ActionMailer #:nodoc:
+  class Base
+
+    # Add a +translate+ (or +t+) method to ActionMailer
+    def translate(key, options={})
+      AnnoTranslate.translate_with_annotation([self.mailer_name, self.action_name], @virtual_path, key, options)
+    end
+
+    alias :t :translate
+  end
+end
+
+module I18n
+  # Install the strict exception handler for testing
+  extend AnnoTranslate::I18nExtensions
+
+  module Backend
+    module Fallbacks
+      def translate(locale, key, options={})
+        AnnoTranslate.translate_with_annotation([], @virtual_path, key, options)
+      end
+    end
+  end
+
+  # Override +translate+ (and +t+) method to I18n
+  def translate(key, options={})
+    AnnoTranslate.translate_with_annotation([], @virtual_path, key, options)
+  end
+
+  alias :t :translate
+end
+
+module ActiveSupport
+  module Inflector
+    def humanize(lower_case_and_underscored_word, options = {})
+      raise "ActiveSupport::Inflector.humanize is disabled!"
+    end
+  end
+end
+
+module Test # :nodoc: all
+  module Unit
+    class TestCase
+      include AnnoTranslate::Assertions
+    end
+  end
+end
+
+# In test environment, enable strict exception handling for missing translations
+if (defined? RAILS_ENV) && (RAILS_ENV == "test")
+  AnnoTranslate.strict_mode(true)
+end

data/lib/import_export.rb

@@ -0,0 +1,288 @@
+require 'yaml'
+require 'csv'
+require 'rake'
+
+module AnnoTranslate
+
+  class TranslationsExporter
+
+    def self.export(file_prefix, export_to=nil)
+      exporter = self.new(file_prefix, export_to)
+      exporter.export_translations
+    end
+
+    def initialize(file_prefix, export_to=nil)
+      # Format pertinent paths for files
+      here = File.expand_path(File.dirname(__FILE__))
+      config = File.expand_path(File.join(here, "..", "..", "config"))
+      @locales_folder = File.join(config, "locales")
+      @base_yml_file = File.join(@locales_folder, "en.yml")
+      @prefix = file_prefix
+      @translations_support = File.join(config, "translations")
+      @duplicates_file = File.join(@translations_support, "#{@prefix}_shared_strings.yml")
+      @export_folder = export_to ? export_to : File.join(@translations_support, "export")
+
+      @base_locale = YAML.load_file(@base_yml_file)
+      @cache = YAML.load_file(@duplicates_file)
+
+      FileUtils.rm_f Dir["#{@export_folder}/*.csv"]
+
+      # Create supported foreign languages collection
+      @foreign_languages = FOREIGN_LOCALES.keys.map do |code|
+        source_yml = File.join(@locales_folder, "#{code}.yml")
+        dest_csv = File.join(@export_folder, "#{@prefix}.#{code}.csv")
+        {code: code, name: FOREIGN_LOCALES[code], yml: source_yml, csv: dest_csv}
+      end
+    end
+
+    def export_translations
+      # Load English strings first to use as golden copy of all translatable strings/keys
+      load_english_strings
+
+      # Generate CSV export files for each foreign language
+      @foreign_languages.each do |lang|
+        puts "Exporting #{lang[:name]} (#{lang[:code]}) translations"
+        puts "  from:  #{lang[:yml]}" if File.exist? lang[:yml]
+        puts "  using: #{@base_yml_file}"
+        puts "  to:    #{lang[:csv]}"
+
+        # Export keys/translations to the proper CSV file
+        CSV.open(lang[:csv], "wb", encoding: 'UTF-8') do |csv|
+          csv << ["Key", "String#", "English Version", "#{lang[:name]} Translation"]
+          index = 0
+          load_translations(lang).each do |id, translation|
+            csv << [id, index+1, @english[index].last, translation]
+            index += 1
+          end
+        end
+      end
+    end
+
+    private
+
+    def load_english_strings
+      @cache = {}
+      new_hash = YAML.load_file(@base_yml_file)
+      @english = hash_to_pairs(new_hash, @cache)
+      linked_keys = @cache.values.select{|r| r.count > 1}
+
+      # Create empty translations template with keys from English
+      @valid_ids = []
+      @template = []
+      @english.each do |id, string|
+        @valid_ids << replace_id_locale(id)
+        @template << [id, '']
+      end
+
+      # Report duplicated strings for sharing translations
+      if !linked_keys.empty?
+        puts "#{linked_keys.count} duplicate strings found! (see #{@duplicates_file} for details)"
+      else
+        puts "No duplicate strings detected"
+      end
+      File.open(@duplicates_file, "wb") do |cf|
+        cf.print YAML.dump(linked_keys)
+      end
+      puts "Found a total of #{@english.count} translatable strings"
+    end
+
+    def load_translations(config)
+      # Create from template
+      translations = @template.dup.map{|id, translation| [replace_id_locale(id, config[:code]), translation]}
+
+      # Merge in existing translations, if they exist
+      if File.exist? config[:yml]
+        hash_to_pairs(YAML.load_file(config[:yml])).each do |id, translation|
+          found_at = @valid_ids.index(replace_id_locale(id))
+          raise "Invalid translation ID '#{id}' found in #{config[:yml]}" unless found_at
+          translations[found_at] = [id, translation]
+        end
+      end
+
+      translations
+    end
+
+    private
+
+    def replace_id_locale(id, replacement='')
+      replacement += '.' if !replacement.empty? && !replacement !~ /\.$/
+      id.dup.sub(/^[a-z]{2,2}-?[A-Z]{0,2}\./, replacement)
+    end
+
+    def hash_to_pairs(h, cache={}, prefix=nil)
+      h.flat_map do |k,v|
+        k = "#{prefix}.#{k}" if prefix
+        case v
+        when Hash
+          hash_to_pairs v, cache, k
+        else
+          cache[v] ||= []
+          cache[v] << k
+          if cache[v].count > 1
+            # The string content has already been tracked; let's just make a note in the cache
+            # that this key also refers to the current string.
+            #puts "#{v.inspect} is referred to by multiple keys: #{cache[v].join(" ")}"
+            []
+          else
+            [[k,v]]
+          end
+        end
+      end
+    end
+
+  end
+
+  class TranslationsImporter
+    include Rake::DSL
+
+    def self.import(file_prefix, import_from=nil)
+      importer = self.new(file_prefix, import_from)
+      importer.import_translations
+    end
+
+    def initialize(file_prefix, import_from=nil)
+      # Format pertinent paths for files
+      here = File.expand_path(File.dirname(__FILE__))
+      config = File.expand_path(File.join(here, "../../config"))
+      @translations_support = File.join(config, "translations")
+      @import_folder = import_from ? import_from : File.join(@translations_support, "import")
+      @locales_folder = File.join(config, "locales")
+      @base_yml_file = File.join(@locales_folder, "en.yml")
+      @prefix = file_prefix
+      @duplicates_file = File.join(@translations_support, "#{@prefix}_shared_strings.yml")
+
+      @base_locale = YAML.load_file(@base_yml_file)
+      load_base_ids
+      @cache = YAML.load_file(@duplicates_file)
+
+      @foreign_languages = Dir[File.join(@import_folder, "*#{@prefix}*.csv")].map do |csv|
+        m = csv.match(/\.([a-z]{2,2}-?[A-Z]{0,2})\.csv$/)
+        raise "Failed parsing language code from #{csv}" if m.nil?
+        lang_code = m[1]
+        raise "Parsed language code '#{lang_code}' is not supported" if !FOREIGN_LOCALES[lang_code]
+        dest_yml = File.join(@locales_folder, "#{lang_code}.yml")
+        source_csv = File.join(@import_folder, "#{@prefix}.#{lang_code}.csv")
+        untranslated_strings_report = File.join(@import_folder, "#{@prefix}.missing.#{lang_code}.txt")
+        {
+          code: lang_code,
+          name: FOREIGN_LOCALES[lang_code],
+          yml: dest_yml,
+          csv: source_csv,
+          missing_translations: [],
+          untranslated_report: untranslated_strings_report,
+        }
+      end
+    end
+
+    def import_translations
+      raise "No CSV files to import\nimport folder: #{@import_folder}\n\n" if @foreign_languages.empty?
+      missing_translations = 0
+      @foreign_languages.each do |lang|
+        puts "Importing #{lang[:name]} (#{lang[:code]}) translations"
+        puts "  from: #{lang[:csv]}"
+        puts "  to:   #{lang[:yml]}"
+        csv_to_yml(lang)
+        not_translated = lang[:missing_translations].count
+        puts "  WARNING: #{not_translated} untranslated strings found!" if not_translated > 0
+        missing_translations += not_translated
+      end
+      puts "\n#{missing_translations} untranslated strings\nImport complete"
+    end
+
+    private
+
+    def load_base_ids
+      @valid_ids = {}
+      hash_to_ids(@base_locale.dup)
+    end
+
+    def hash_to_ids(h, prefix=nil)
+      h.each do |k,v|
+        k = "#{prefix}.#{k}" if prefix
+        case v
+        when Hash
+          hash_to_ids v, k
+        else
+          common_key = replace_id_locale(k)
+          @valid_ids[common_key] = v
+        end
+      end
+    end
+
+    def replace_id_locale(id, replacement='')
+      replacement += '.' if !replacement.empty? && !replacement !~ /\.$/
+      id.dup.sub(/^[a-zA-Z_-]+\./, replacement)
+    end
+
+    def csv_to_yml(config)
+      load_translations(config).tap do |translations|
+        result = translate_it(config, @base_locale.dup, translations, '')
+        File.open(config[:yml], "wb") do |cf|
+          cf.print YAML.dump(result)
+        end
+
+        # Report untranslated strings
+        FileUtils.rm_f config[:untranslated_report]
+        if !config[:missing_translations].empty?
+          File.open(config[:untranslated_report], "wb", encoding: 'UTF-8') do |report|
+            report.puts "Untranslated String ID"
+            report.puts "======================"
+            config[:missing_translations].each{|id| report.puts id}
+          end
+          puts "  Missing translations report: #{config[:untranslated_report]}"
+        end
+      end
+    end
+
+    def load_translations(config)
+      {}.tap do |translations|
+        CSV.foreach(config[:csv], headers: true, encoding: 'UTF-8') do |row|
+          id = row[0] # id = row["Key"]
+          translation = row[3] # translation = row["Translated Version"]
+          raise "Invalid translation ID found: #{id} - #{translation}" if @valid_ids[replace_id_locale(id)].nil?
+          translations[id] = translation
+        end
+
+        # Populate keys for duplicated strings with common translation
+        @cache.each do |keys|
+          primary_key = keys.first
+          foreign_key = replace_id_locale(primary_key, config[:code])
+          raise "Whoa! No value for #{primary_key}" unless translations.has_key?(foreign_key)
+          keys.select{|k| k != primary_key}.each do |dup_key|
+            dup_key = replace_id_locale(dup_key, config[:code])
+            translations[dup_key] = translations[foreign_key]
+          end
+        end
+      end
+    end
+
+    def translate_it(config, input, translations, base_key)
+      input.keys.each do |key|
+
+        value = input[key]
+        if base_key && !base_key.empty?
+          full_key = "#{base_key}.#{key}"
+        else
+          full_key = key
+        end
+
+        case value
+        when Hash
+          translate_it(config, value, translations, full_key)
+        else
+          foreign_key = replace_id_locale(full_key, config[:code])
+          translation = translations[foreign_key]
+          if !translation || translation.empty?
+            config[:missing_translations] << foreign_key
+          end
+          input[key] = translation
+        end
+
+      end
+
+      input
+    end
+
+  end
+
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module AnnoTranslate
+  VERSION = "0.2.0"
+end

data/tasks/annotranslate.rake

@@ -0,0 +1,61 @@
+require 'yaml'
+require 'csv'
+require 'fileutils'
+require_relative '../annotranslate'
+
+BASE_LOCALE = 'en' unless defined? BASE_LOCALE
+
+SUPPORTED_LOCALES =
+{
+  'en' => "English",
+  "de" => "German",
+  "fr" => "French",
+  "pt" => "Portuguese",
+  'es' => "Spanish",
+  "ja" => "Japanese",
+  "zh-CN" => "Mandarin Chinese",
+}
+
+FOREIGN_LOCALES = SUPPORTED_LOCALES.delete('en')
+
+namespace :translations do
+
+  file_prefix = "twweb"
+  here = File.expand_path(File.dirname(__FILE__))
+  root = File.expand_path(File.join(here, "..", ".."))
+  config_folder = File.join(root, "config")
+  directory(import_folder = File.join(config_folder, "translations", "import"))
+  directory(export_folder = File.join(config_folder, "translations", "export"))
+
+  desc "Import CSVs from #{import_folder.sub(/^#{root}/,'')}"
+  task :import => [import_folder] do
+    TranslationsImporter.import(file_prefix, import_folder)
+  end
+
+  desc "Export CSVs to #{export_folder.sub(/^#{root}/,'')}"
+  task :export => [export_folder] do
+    TranslationsExporter.export(file_prefix, export_folder)
+  end
+
+end
+
+# Internationalization tasks
+namespace :i18n do
+
+  desc "Validates YAML locale bundles"
+  task :validate_yml => [:environment] do |t, args|
+
+    # Grab all the yaml bundles in config/locales
+    bundles = Dir.glob(File.join(RAILS_ROOT, 'config', 'locales', '**', '*.yml'))
+
+    # Attempt to load each bundle
+    bundles.each do |bundle|
+      begin
+        YAML.load_file( bundle )
+      rescue Exception => exc
+        puts "Error loading: #{bundle}"
+        puts exc.to_s
+      end
+    end
+  end
+end

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: annotranslate
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Greg Williams
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-12 00:00:00.000000000 Z
+dependencies: []
+description: Rails plugin which provides annotation and import/export of translatable
+  strings to/from CSV files
+email: greg.williams@atomicobject.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- LICENSE
+- init.rb
+- install.rb
+- uninstall.rb
+- ./lib/annotranslate.rb
+- ./lib/import_export.rb
+- ./lib/version.rb
+- ./tasks/annotranslate.rake
+homepage: http://github.com/atomicobject/annotranslate
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+- tasks
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 2
+summary: Provides annotation and import/export for Rails translations
+test_files: []