pseudo-localizer for i18n testing

run canvas with LOLCALIZE=true (no, that's not a typo) so you can easily
see which strings still need i18n. anything passing through ruby or js
I18n.t will be lol-calized (schizo-case, spurious lols, and exclamation
marks)

test plan:
N/A, this doesn't affect normal canvas usage

Change-Id: I206efa9ba6e5c67c09b0eef5ea73e0e17e2d3127
Reviewed-on: https://gerrit.instructure.com/23074
Tested-by: Jenkins <jenkins@instructure.com>
Reviewed-by: Mark Ericksen <marke@instructure.com>
Product-Review: Marc LeGendre <marc@instructure.com>
QA-Review: Marc LeGendre <marc@instructure.com>

Author: jenseng

app/coffeescripts/str/i18nLolcalize.coffee

@@ -0,0 +1,32 @@
+define [], ->
+
+  formatter =
+    0: 'toUpperCase'
+    1: 'toLowerCase'
+
+  # see also lib/i18n/lolcalize.rb
+  letThereBeLols = (str) ->
+    # don't want to mangle placeholders, wrappers, etc.
+    pattern = /(\s*%\{[^\}]+\}\s*|\s*[\n\\`\*_\{\}\[\]\(\)\#\+\-!]+\s*|^\s+)/
+    result = for token in str.split(pattern)
+      if token.match(pattern)
+        token
+      else
+        s = ''
+        for i in [0...token.length]
+          s += token[i][formatter[i % 2]]()
+        s = s.replace(/\.( |$)/, '!!?! ')
+        s = s.replace(/^(\w+)$/, '$1!')
+        s += " LOL!" if s.length > 2
+        s
+    result.join('')
+
+  i18nLolcalize = (strOrObj) ->
+    if typeof strOrObj is 'string'
+      letThereBeLols strOrObj
+    else
+      result = {}
+      for key, value of strOrObj
+        result[key] = letThereBeLols(value)
+      result
+

app/controllers/application_controller.rb

@@ -88,6 +88,7 @@ def js_env(hash = {})
         :AUTHENTICITY_TOKEN => form_authenticity_token,
         :files_domain => HostUrl.file_host(@domain_root_account || Account.default, request.host_with_port),
       }
+      @js_env[:lolcalize] = true if ENV['LOLCALIZE']
     end
 
     hash.each do |k,v|

config/initializers/i18n.rb

@@ -10,6 +10,8 @@
   I18n.backend.init_translations
 end
 
+I18n.send :extend, I18n::Lolcalize if ENV['LOLCALIZE']
+
 module I18nUtilities
   def before_label(text_or_key, default_value = nil, *args)
     if default_value

lib/i18n/lolcalize.rb

@@ -0,0 +1,41 @@
+module I18n
+  module Lolcalize
+    def translate_with_lols(key, options = {})
+      if options[:default]
+        key = :lols # so that it doesn't find a real translation
+        options[:default] = let_there_be_lols(options[:default]) if options[:default].present?
+      end
+      translate_without_lols(key, options)
+    end
+
+    # see also app/coffeescripts/str/i18nLolcalize.coffee
+    def let_there_be_lols(str)
+      # don't want to mangle placeholders, wrappers, etc.
+      pattern = /(\s*%\{[^\}]+\}\s*|\s*[\n\\`\*_\{\}\[\]\(\)\#\+\-!]+\s*|^\s+)/
+      result = str.split(pattern).map do |token|
+        if token =~ pattern
+          token
+        else
+          s = ''
+          token.chars.each_with_index do |c, i|
+            s << (i % 2 == 1 ? c.upcase : c.downcase)
+          end
+          s.gsub!(/\.( |\z)/, '!!?! ')
+          s.sub!(/\A(\w+)\z/, '\1!')
+          s << " LOL!" if s.length > 2
+          s
+        end
+      end
+      result.join('')
+    end
+
+    def self.extended(klass)
+      klass.class_eval do
+        class << self
+          alias_method_chain :translate, :lols
+          alias_method :t, :translate
+        end
+      end
+    end
+  end
+end

public/javascripts/i18nObj.js

@@ -3,8 +3,9 @@ define([
   'str/htmlEscape',
   'str/pluralize',
   'str/escapeRegex',
+  'compiled/str/i18nLolcalize',
   'vendor/date' /* Date.parse, Date.UTC */
-], function($, htmlEscape, pluralize, escapeRegex) {
+], function($, htmlEscape, pluralize, escapeRegex, i18nLolcalize) {
 
 // Instantiate the object, export globally for tinymce/specs
 var I18n = window.I18n = {};
@@ -532,6 +533,11 @@ I18n.l = I18n.localize;
 I18n.p = I18n.pluralize;
 
 
+var normalizeDefault = function(str) { return str };
+if (ENV && ENV.lolcalize) {
+  normalizeDefault = i18nLolcalize;
+}
+
 I18n.scoped = function(scope, callback) {
   var i18n_scope = new I18n.scope(scope);
   if (callback) {
@@ -558,7 +564,7 @@ I18n.scope.prototype = {
     if (typeof(options.count) != 'undefined' && typeof(defaultValue) == "string" && defaultValue.match(/^[\w\-]+$/)) {
       defaultValue = pluralize.withCount(options.count, defaultValue);
     }
-    options.defaultValue = defaultValue;
+    options.defaultValue = normalizeDefault(defaultValue);
     return I18n.translate(this.resolveScope(scope), options);
   },
   localize: function(scope, value) {