i18nliner 0.0.1 → 0.0.2

data/README.md

@@ -1,15 +1,12 @@
 # I18nliner
 
+[<img src="https://secure.travis-ci.org/jenseng/i18nliner.png" />](http://travis-ci.org/jenseng/i18nliner)
+
 yay readme-driven development!
 
 ## TODO
 
-* inferred placeholders (instance vars and methods)
-* ERB pre-processor
-  * wrapper inference
-  * helper/placeholder extraction
 * rake tasks
-  * dump
   * diff
   * import
 
@@ -19,30 +16,36 @@ I18nliner is I18n made simple.
 
 No .yml files. Inline defaults. Optional keys. Inferred interpolation values.
 Wrappers and blocks, so your templates look template-y and your translations
-HTML-free.
+stay HTML-free.
 
 ## TL;DR
 
 I18nliner lets you do stuff like this:
 
-    t "Ohai %{@user.name}, my default translation is right here in the code. " +
-      "Inferred keys and placeholder values, oh my!"
+```ruby
+t "Ohai %{@user.name}, my default translation is right here in the code. " \
+  "Inferred keys and placeholder values, oh my!"
+```
 
 and even this:
 
-    <%= t do %>
-      Hey <%= amigo %>!
-      Although I am <%= link_to "linking to something", random_path %> and
-      have some <strong>bold text</strong>, the translators will see
-      <strong><em>absolutely no markup</em></strong> and will only have a
-      single string to translate :o
-    <% end %>
+```erb
+<%= t do %>
+  Hey <%= amigo %>!
+  Although I am <%= link_to "linking to something", random_path %> and
+  have some <strong>bold text</strong>, the translators will see
+  <strong><em>absolutely no markup</em></strong> and will only have a
+  single string to translate :o
+<% end %>
+```
 
 ## Installation
 
 Add the following to your Gemfile:
 
-    gem 'i18nliner'
+```ruby
+gem 'i18nliner'
+```
 
 ## Features
 
@@ -50,11 +53,15 @@ Add the following to your Gemfile:
 
 Instead of maintaining .yml files and doing stuff like this:
 
-    I18n.t :account_page_title
+```ruby
+I18n.t :account_page_title
+```
 
 Forget the .yml and just do:
 
-    I18n.t :account_page_title, "My Account"
+```ruby
+I18n.t :account_page_title, "My Account"
+```
 
 Regular I18n options follow the (optional) default translation, so you can do
 the usual stuff (placeholders, etc.).
@@ -63,7 +70,9 @@ the usual stuff (placeholders, etc.).
 
 Sure, but *you* don't need to write it. Just run:
 
-    rake i18nliner:dump
+```bash
+rake i18nliner:dump
+```
 
 This extracts all default translations from your codebase, merges them with any
 other ones (from rails or pre-existing .yml files), and outputs them to
@@ -74,7 +83,9 @@ other ones (from rails or pre-existing .yml files), and outputs them to
 Why waste time coming up with keys that are less descriptive than the default
 translation? I18nliner makes keys optional, so you can just do this:
 
-    I18n.t "My Account"
+```ruby
+I18n.t "My Account"
+```
 
 I18nliner will create a [unique key](CONFIG.md) based on the translation (e.g.
 `:my_account`), so you don't have to.
@@ -91,18 +102,22 @@ Interpolation values may be inferred by I18nliner if not provided. So long as
 it's an instance variable or method (or chain), you don't need to specify its
 value. So this:
 
-    <p>
-      <%= t "Hello, %{user}. This request was a %{request_method}.", 
-            :user => @user.name,
-            :request_method => request.method
-      %>
-    </p>
+```erb
+<p>
+  <%= t "Hello, %{user}. This request was a %{request_method}.", 
+        user: @user.name,
+        request_method: request.method
+  %>
+</p>
+```
 
 Can just be this:
 
-    <p>
-      <%= t "Hello, %{@user.name}. This request was a %{request.method}." %>
-    </p>
+```erb
+<p>
+  <%= t "Hello, %{@user.name}. This request was a %{request.method}." %>
+</p>
+```
 
 Note that local variables cannot be inferred.
 
@@ -112,19 +127,23 @@ Note that local variables cannot be inferred.
 
 Suppose you have something like this in your ERB:
 
-    <p>
-      You can <%= link_to "lead", new_discussion_path %> a new discussion or
-      <%= link_to "join", discussion_search_path %> an existing one.
-    </p>
+```erb
+<p>
+  You can <%= link_to "lead", new_discussion_path %> a new discussion or
+  <%= link_to "join", discussion_search_path %> an existing one.
+</p>
+```
 
 You might try something like this:
 
-    <p>
-      <%= t "You can %{lead} a new discussion or %{join} an existing one.",
-            :lead => link_to(t("lead"), new_discussion_path),
-            :join => link_to(t("join"), discussion_search_path)
-      %>
-    </p>
+```erb
+<p>
+  <%= t("You can %{lead} a new discussion or %{join} an existing one.",
+        lead: link_to(t("lead"), new_discussion_path),
+        join: link_to(t("join"), discussion_search_path)).html_safe
+  %>
+</p>
+```
 
 This is not great, because:
 
@@ -136,14 +155,16 @@ This is not great, because:
 
 So you might try this instead:
 
-    <p>
-      <%= t :discussion_html,
-            "You can <a href="%{lead_url}">lead</a> a new discussion or " +
-            "<a href="%{join_url}">join</a> an existing one.",
-            :lead_url => new_discussion_path,
-            :join_url => discussion_search_path
-      %>
-    </p>
+```erb
+<p>
+  <%= t :discussion_html,
+        "You can <a href="%{lead_url}">lead</a> a new discussion or " \
+        "<a href="%{join_url}">join</a> an existing one.",
+        lead_url: new_discussion_path,
+        join_url: discussion_search_path
+  %>
+</p>
+```
 
 This isn't much better, because now you have HTML in your translations. If you
 want to add a class to the link, you have to go update all the translations.
@@ -157,14 +178,16 @@ So what do you do?
 I18nliner lets you specify wrappers, so you can keep HTML out the translations,
 while still just having a single string needing translation:
 
-    <p>
-      <%= t "You can *lead* a new discussion or **join** an existing one.",
-            :wrappers => [
-              link_to('\1', new_discussion_path),
-              link_to('\1', discussion_search_path)
-            ]
-      %>
-    </p>
+```erb
+<p>
+  <%= t "You can *lead* a new discussion or **join** an existing one.",
+        wrappers: [
+          link_to('\1', new_discussion_path),
+          link_to('\1', discussion_search_path)
+        ]
+  %>
+</p>
+```
 
 Default delimiters are increasing numbers of asterisks, but you can specify
 any string as a delimiter by using a hash rather than an array.
@@ -175,50 +198,60 @@ But wait, there's more!
 
 Perhaps you want your templates to look like, well, templates. Try this:
 
-    <p>
-      <%= t do %>
-        Welcome to the internets, <%= user.name %>
-      <% end %>
-    </p>
+```erb
+<p>
+  <%= t do %>
+    Welcome to the internets, <%= user.name %>
+  <% end %>
+</p>
+```
 
 Or even this:
 
-    <p>
-      <%= t do %>
-        <b>Ohai <%= user.name %>,</b>
-        you can <%= link_to "lead", new_discussion_path %> a new discussion or
-        <%= link_to "join", discussion_search_path %> an existing one.
-      <% end %>
-    </p>
+```erb
+<p>
+  <%= t do %>
+    <b>Ohai <%= user.name %>,</b>
+    you can <%= link_to "lead", new_discussion_path %> a new discussion or
+    <%= link_to "join", discussion_search_path %> an existing one.
+  <% end %>
+</p>
+```
 
 In case you're curious about the man behind the curtain, I18nliner adds an ERB
 pre-processor that turns the second example into something like this right
 before it hits ERB:
 
-    <p>
-      <%= t :some_unique_key,
-            "*Ohai %{user_name}*, you can **lead** a new discussion or ***join*** an existing one.",
-            :user_name => @user.name,
-            :wrappers => [
-              '<b>\1</b>',
-              link_to('\1', new_discussion_path),
-              link_to('\1', discussion_search_path)
-            ]
-      %>
-    </p>
+```erb
+<p>
+  <%= t :some_unique_key,
+        "*Ohai %{user_name}*, you can **lead** a new discussion or ***join*** an existing one.",
+        user_name: user.name,
+        wrappers: [
+          '<b>\1</b>',
+          link_to('\1', new_discussion_path),
+          link_to('\1', discussion_search_path)
+        ]
+  %>
+</p>
+```
 
 In other words, it will infer wrappers from your (balanced) markup and
 [`link_to` calls](INFERRED_WRAPPERS.md), and will create placeholders for any
-other ERB expressions. ERB statements (e.g.
-`<% if some_condition %>...`) are *not* supported inside block translations, with
-the notable exception of nested translations, e.g.
-
-    <%= t do %>
-      Be sure to
-      <a href="/account/" title="<%= t do %>Account Settings<% end %>">
-        set up your account
-      </a>.
-    <% end %>
+other (inline) ERB expressions. ERB statements (e.g.
+`<% if some_condition %>...`) and block expressions (e.g.
+`<%= form_for @person do %>...`) are *not* supported within a block
+translation. The only exception to this rule is nested translation
+calls, e.g. this is totally fine:
+
+```erb
+<%= t do %>
+  Be sure to
+  <a href="/account/" title="<%= t do %>Account Settings<% end %>">
+    set up your account
+  </a>.
+<% end %>
+```
 
 #### HTML Safety
 
@@ -232,28 +265,29 @@ escaped.
 Pluralization can be tricky, but [I18n gives you some flexibility](http://guides.rubyonrails.org/i18n.html#pluralization).
 I18nliner brings this inline with a default translation hash, e.g.
 
-    t({:one => "There is one light!", :other => "There are %{count} lights!"},
-      :count => picard.visible_lights.count)
+```ruby
+t({one: "There is one light!", other: "There are %{count} lights!"},
+  count: picard.visible_lights.count)
+```
 
 Note that the :count interpolation value needs to be explicitly set when doing
-pluralization. On the ERB side, I18nliner enhances pluralize to take a block,
-so you can do this:
-
-    <%= pluralize picard.visible_lights.count do %>
-      <% one do %>There is one light!<% end %>
-      <% other do %>There are <%= count %> lights!<% end %>
-    <% end %>
+pluralization.
 
 If you just want to pluralize a single word, there's a shortcut:
 
-    t "person", :count => users.count
+```ruby
+t "person", count: users.count
+```
 
 This is equivalent to:
 
-    t({:one => "1 person", :other => "%{count} people"},
-      :count => users.count)
+```ruby
+t({one: "1 person", other: "%{count} people"},
+  count: users.count)
+```
 
-I18nliner uses the pluralize helper to determine the default one/other values,
+I18nliner uses [`String#pluralize`](http://edgeguides.rubyonrails.org/active_support_core_extensions.html#pluralize)
+to determine the default one/other values,
 so if your `I18n.default_locale` is something other than English, you may need
 to [add some inflections](https://gist.github.com/838188).
 
@@ -271,6 +305,16 @@ Does an i18nliner:check, and then extracts all default translations from your
 codebase, merges them with any other ones (from rails or pre-existing .yml
 files), and outputs them to `config/locales/generated/en.yml`.
 
+### Dynamic Translations
+
+Note that check and dump commands require all translation keys and
+defaults to be literals. This is because it reads your code, it doesn't
+run it. If you know what you are doing and want to pass in a variable or
+other expression, you can use the `t!` (or `translate!`) command. It works
+the same as `t` at runtime, but signals to the extractor that it shouldn't
+complain. You should only do this if you are sure that the specified
+key/string is extracted elsewhere or already in your yml.
+
 ### i18nliner:diff
 
 Does an i18nliner:dump and creates a diff from a previous one (path or git
@@ -294,7 +338,9 @@ though it supports
 If you only want to check a particular file/directory/pattern, you can set the
 environment variable `ONLY` when you run the command, e.g.
 
-    rake i18nliner:check ONLY=/app/**/user*
+```bash
+rake i18nliner:check ONLY=/app/**/user*
+```
 
 ## Compatibility
 
@@ -307,7 +353,8 @@ I18nliner requires at least Ruby 1.9.3 and Rails 3.
 
 ## What about JavaScript/Handlebars?
 
-Coming soon. I18nliner was inspired by some [I18n extensions](https://github.com/instructure/canvas-lms/tree/master/lib/i18n_extraction)
+[Coming](https://github.com/jenseng/i18nliner-js) [soon](https://github.com/fivetanley/i18ninliner-handlebars).
+I18nliner was inspired by some [I18n extensions](https://github.com/instructure/canvas-lms/tree/master/lib/i18n_extraction)
 I did in [Canvas-LMS](https://github.com/instructure/canvas-lms). While
 it also has the JavaScript/Handlebars equivalents, they are tightly
 coupled to Canvas-LMS and are written in Ruby. So basically we're talking
@@ -317,4 +364,4 @@ that is js_extractor.
 
 ## License
 
-Copyright (c) 2013 Jon Jensen, released under the MIT license
+Copyright (c) 2014 Jon Jensen, released under the MIT license

data/lib/i18nliner/base.rb

@@ -0,0 +1,47 @@
+require 'i18n'
+
+module I18nliner
+  def self.ignore
+    @ignore ||= begin
+      path = File.join(base_path, ".i18nignore")
+      File.exist?(path) ?
+        File.read(path).split(/\r?\n|\r/) :
+        []
+    end
+  end
+
+  def self.translations
+  end
+
+  def self.manual_translations
+    # TODO: support additional backends
+    I18n.backend.send(:translations)
+  end
+
+  def self.look_up(key)
+    I18n.exists?(I18n.locale, key)
+  end
+
+  def self.setting(key, value)
+    instance_eval <<-CODE
+      def #{key}(value = nil)
+        if value && block_given?
+          begin
+            value_was = @#{key}
+            @#{key} = value
+            yield
+          ensure
+            @#{key} = value_was
+          end
+        else
+          @#{key} = #{value.inspect} if @#{key}.nil?
+          @#{key}
+        end
+      end
+    CODE
+  end
+
+  setting :inferred_key_format,        :underscored_crc32
+  setting :infer_interpolation_values, true
+  setting :base_path,                  "./"
+end

data/lib/i18nliner/call_helpers.rb

@@ -1,14 +1,14 @@
-require 'iconv'
 require 'zlib'
+require 'i18n'
+require 'i18nliner/base'
 
 module I18nliner
   module CallHelpers
     ALLOWED_PLURALIZATION_KEYS = [:zero, :one, :few, :many, :other]
     REQUIRED_PLURALIZATION_KEYS = [:one, :other]
 
-    def normalize_key(key, scope, receiver)
-      key = key.to_s
-      scope.normalize_key(key)
+    def normalize_key(key, scope = Scope.root)
+      scope.normalize_key(key.to_s)
     end
 
     def normalize_default(default, translate_options = {})
@@ -25,21 +25,22 @@ module I18nliner
     end
 
     def infer_key(default, translate_options = {})
+      return unless default && (default.is_a?(String) || default.is_a?(Hash))
       default = default[:other].to_s if default.is_a?(Hash)
       keyify(normalize_default(default, translate_options))
     end
 
     def keyify_underscored(string)
-      Iconv.iconv('ascii//translit//ignore', 'utf-8', string).
-        to_s.
-        downcase.
-        gsub(/[^a-z0-9_\.]+/, '_').
-        gsub(/\A_|_\z/, '')[0..50]
+      key = I18n.transliterate(string, :locale => I18n.default_locale).to_s
+      key.downcase!
+      key.gsub!(/[^a-z0-9_]+/, '_')
+      key.gsub!(/\A_|_\z/, '')
+      key[0..50]
     end
 
     def keyify_underscored_crc32(string)
-      checksum = Zlib.crc32(string.size.to_s + ":" + string).to_s(16) 
-      keyify_underscored(string) + "_#{checksum}"
+      checksum = Zlib.crc32("#{string.size.to_s}:#{string}").to_s(16)
+      "#{keyify_underscored(string)}_#{checksum}"
     end
 
     def keyify(string)
@@ -57,13 +58,38 @@ module I18nliner
     # key, default_hash, options
     # default_string [, options]
     # default_hash, options
-    def key_provided?(scope, receiver, key_or_default = nil, default_or_options = nil, maybe_options = nil, *others)
+    def key_provided?(key_or_default = nil, default_or_options = nil, maybe_options = nil, *others)
       return false if key_or_default.is_a?(Hash)
       return true if key_or_default.is_a?(Symbol)
       return true if default_or_options.is_a?(String)
       return true if maybe_options
-      return true if I18nliner.look_up(normalize_key(key_or_default, scope, receiver))
+      return true if key_or_default =~ /\A\.?(\w+\.)+\w+\z/
       false
     end
+
+    def pluralization_hash?(hash)
+      hash.is_a?(Hash) &&
+      hash.size > 0 &&
+      (hash.keys - ALLOWED_PLURALIZATION_KEYS).size == 0
+    end
+
+    def infer_arguments(args)
+      if args.size == 2 && args[1].is_a?(Hash) && args[1][:default]
+        return args
+      end
+
+      has_key = key_provided?(*args)
+      args.unshift infer_key(args[0]) unless has_key
+
+      default_or_options = args[1]
+      if args[2] || default_or_options.is_a?(String) || pluralization_hash?(default_or_options)
+        options = args[2] ||= {}
+        options[:default] = args.delete_at(1) if options.is_a?(Hash)
+      end
+      args << {} if args.size == 1
+      args
+    end
+
+    extend self
   end
 end

data/lib/i18nliner/commands/check.rb

@@ -1,17 +1,25 @@
+require 'i18nliner/commands/generic_command'
+require 'i18nliner/extractors/translation_hash'
+require 'active_support/core_ext/enumerable'
+Dir[File.join(File.dirname(__FILE__), "../processors/*.rb")].each do |file|
+  require "i18nliner/processors/#{File.basename(file)}"
+end
+
 module I18nliner
   module Commands
     class Check < GenericCommand
-      attr_reader :translations
+      attr_reader :translations, :errors
 
       def initialize(options)
         super
         @errors = []
-        @translations = TranslationHash.new(I18nliner.manual_translations)
+        @translations = I18nliner::Extractors::TranslationHash.new(I18nliner.manual_translations)
       end
 
       def processors
         @processors ||= I18nliner::Processors.all.map do |klass|
-          klass.new :only => @options[:only],
+          klass.new @translations,
+                    :only => @options[:only],
                     :translations => @translations,
                     :checker => method(:check_file)
         end
@@ -22,14 +30,16 @@ module I18nliner
       end
 
       def check_file(file)
-        print green(".") if yield file
+        if yield file
+          print green(".") unless @options[:silent]
+        end
       rescue SyntaxError, StandardError, ExtractionError
         @errors << "#{$!}\n#{file}"
-        print red("F")
+        print red("F") unless @options[:silent]
       end
 
-      def failure
-        @errors.size > 0
+      def success?
+        @errors.empty?
       end
 
       def print_summary
@@ -46,13 +56,13 @@ module I18nliner
 
         print "Finished in #{Time.now - @start} seconds\n\n"
         summary = "#{file_count} files, #{translation_count} strings, #{@errors.size} failures"
-        puts failure ? red(summary) : green(summary)
+        puts success? ? green(summary) : red(summary)
       end
 
       def run
         check_files
-        print_summary
-        raise "check command encountered errors" if failure
+        print_summary unless @options[:silent]
+        success?
       end
     end
   end

data/lib/i18nliner/commands/dump.rb

@@ -1,7 +1,24 @@
+require 'ya2yaml'
+require 'fileutils'
+
 module I18nliner
   module Commands
     class Dump < GenericCommand
+      attr_reader :yml_file
+
+      def initialize(options)
+        super
+        @translations = @options[:translations]
+        @yml_file = @options[:file] ||
+          File.join(I18nliner.base_path, "config", "locales", "generated", "#{I18n.default_locale}.yml")
+      end
+
       def run
+        FileUtils.mkdir_p File.dirname(yml_file)
+        File.open(yml_file, "w") do |file|
+          file.write({I18n.default_locale.to_s => @translations}.ya2yaml(:syck_compatible => true))
+        end
+        puts "Wrote default translations to #{yml_file}" unless @options[:silent]
       end
     end
   end

data/lib/i18nliner/commands/generic_command.rb

@@ -1,3 +1,6 @@
+require 'i18nliner/commands/basic_formatter'
+require 'i18nliner/commands/color_formatter'
+
 module I18nliner
   module Commands
     class GenericCommand
@@ -9,8 +12,14 @@ module I18nliner
         extend ColorFormatter if $stdout.tty?
       end
 
+      def success?
+        true
+      end
+
       def self.run(options)
-        new(options).run
+        command = new(options)
+        command.run
+        command
       end
     end
   end