interpret 0.2.0 → 0.2.1

data/.rspec

@@ -0,0 +1 @@
+--colour

data/.travis.yml

@@ -0,0 +1,14 @@
+env: "RAILS_ENV=test DISPLAY=:99.0"
+rvm:
+  - 1.8.7
+  - ree
+  - 1.9.2
+  - 1.9.3
+
+before_script:
+  - "sh -c 'cd test_app && bundle && bundle exec rake db:drop db:migrate'"
+  - "sh -e /etc/init.d/xvfb start"
+
+branches:
+  only:
+    - master

data/README.md

@@ -1,5 +1,7 @@
 Interpret
 =========
+[![Build Status](https://secure.travis-ci.org/rogercampos/interpret.png)](http://travis-ci.org/rogercampos/interpret)
+
 
 Interpret is a rails 3 engine to help you manage your application
 translations, also allowing you to have editable contents in live. In order to

data/app/controllers/interpret/base_controller.rb

@@ -1,14 +1,16 @@
 class Interpret::BaseController < eval(Interpret.parent_controller.classify)
   before_filter :set_locale
-  before_filter :interpret_set_current_user
+  before_filter { authorize! :use, :interpret }
+  before_filter :check_authorized_language
   layout 'interpret'
 
 protected
-  def require_admin
-    if @interpret_user && !@interpret_admin
-      redirect_to interpret_root_url, :alert => "Not authorized"
-      return
-    end
+  def current_interpret_user
+    @current_interpret_user ||= eval(Interpret.current_user)
+  end
+
+  def current_ability
+    @current_ability ||= Interpret.ability.new(current_interpret_user)
   end
 
 private
@@ -16,14 +18,8 @@ private
     I18n.locale = params[:locale] if params[:locale]
   end
 
-  def interpret_set_current_user
-    if Interpret.current_user && defined?(Interpret.current_user.to_sym)
-      @interpret_user = eval(Interpret.current_user)
-      @interpret_admin = true
-      if Interpret.admin && @interpret_user.respond_to?(Interpret.admin)
-        @interpret_admin = @interpret_user.send(Interpret.admin)
-      end
-    end
+  def check_authorized_language
+    authorize! :use, :"interpret_in_#{I18n.locale}"
   end
 end
 

data/app/controllers/interpret/missing_translations_controller.rb

@@ -1,15 +1,46 @@
 class Interpret::MissingTranslationsController < Interpret::BaseController
   def index
-    unless I18n.locale == I18n.default_locale
-      res = ActiveRecord::Base.connection.execute("select t.value, t.key from
-                                                  translations t where
-                                                  t.locale ='#{I18n.default_locale}'
-                                                  and (select count(*) from
-                                                       translations t2 where
-                                                       t2.key = t.key and
-                                                       t2.locale ='#{I18n.locale}') =
-                                                         0")
-      @missing_translations = res.map{|x| {:ref_value => YAML.load(x["value"]), :key => x["key"]}}
+    authorize! :read, :missing_translations
+    return if I18n.locale == I18n.default_locale
+
+    case ActiveRecord::Base.connection.adapter_name
+    when "Mysql2"
+      res = ActiveRecord::Base.connection.execute("select t.id from translations t where t.locale ='#{I18n.default_locale}' and (select count(*) from translations t2 where t2.key = t.key and t2.locale ='#{I18n.locale}') = 0")
+
+    when "SQLite"
+      res = ActiveRecord::Base.connection.execute("select t.id from translations t where t.locale ='#{I18n.default_locale}' and (select count(*) from translations t2 where t2.key = t.key and t2.locale ='#{I18n.locale}') = 0")
+
+    else
+      raise NotImplementedError, "database adapter not supported"
     end
+
+    ids = res.map{|x| x.first}
+    translations = Interpret::Translation.allowed.where(:id => ids).order("translations.key ASC").all
+    translations = translations.select{|x| x.value.present?}
+    @missing_translations = translations.map{|x| {:ref_value => x.value, :key => x.key, :source => x}}
+  end
+
+  def blank
+    authorize! :read, :blank_translations
+    @blank_translations = Interpret::Translation.allowed.locale(I18n.locale).where(:value => "--- \"\"\n")
+    @ref_translations = Interpret::Translation.allowed.locale(I18n.default_locale).where(:key => @blank_translations.map{|x| x.key})
+
+    @blank_translations.map do |x|
+      foo = @ref_translations.detect{|y| x.key == y.key}
+      [x, foo ? foo.value : nil]
+    end
+  end
+
+  def unused
+    authorize! :read, :unused_translations
+    used_keys = Interpret::Translation.allowed.locale(I18n.default_locale).all.map{|x| x.key}
+    @unused_translations = Interpret::Translation.allowed.locale(I18n.locale).where("translations.key NOT IN (?)", used_keys)
+  end
+
+  def stale
+    authorize! :read, :stale_translations
+    @stale_translations = Interpret::Translation.allowed.stale.locale(I18n.locale).order("translations.key ASC")
+    refs = Interpret::Translation.locale(I18n.default_locale).where(:key => @stale_translations.map{|x| x.key})
+    @stale_translations.map!{|x| [x, refs.detect{|y| y.key == x.key}]}
   end
 end

data/app/controllers/interpret/search_controller.rb

@@ -1,4 +1,6 @@
 class Interpret::SearchController < Interpret::BaseController
+  before_filter { authorize! :use, :search }
+
   def index
     if request.post?
       opts = {}
@@ -7,10 +9,20 @@ class Interpret::SearchController < Interpret::BaseController
       redirect_to interpret_search_url(opts)
     else
       if params[:key].present? || params[:value].present?
+        sanitizer = case ActiveRecord::Base.connection.adapter_name
+                    when "SQLite"
+                      if Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new("1.9")
+                        lambda {|x| "%#{x}%"}
+                      else
+                        lambda {|x| "%#{CGI.escape(x)}%"}
+                      end
+                    else
+                      lambda {|x| "%#{CGI.escape(x)}%"}
+                    end
         t = Interpret::Translation.arel_table
-        search_key = params[:key].present? ? params[:key].split(" ").map{|x| "%#{CGI.escape(x)}%"} : []
-        search_value = params[:value].present? ? params[:value].split(" ").map{|x| "%#{CGI.escape(x)}%"} : []
-        @translations = Interpret::Translation.locale(I18n.locale).where(t[:key].matches_all(search_key).or(t[:value].matches_all(search_value))  )
+        search_key = params[:key].present? ? params[:key].split(" ").map{|x| sanitizer.call(x)} : []
+        search_value = params[:value].present? ? params[:value].split(" ").map{|x| sanitizer.call(x)} : []
+        @translations = Interpret::Translation.allowed.locale(I18n.locale).where(t[:key].matches_all(search_key).or(t[:value].matches_all(search_value))).order("translations.key ASC")
       end
     end
   end

data/app/controllers/interpret/tools_controller.rb

@@ -1,5 +1,5 @@
 class Interpret::ToolsController < Interpret::BaseController
-  before_filter :require_admin
+  before_filter { authorize! :use, :tools }
 
   def dump
     Interpret::Translation.dump
@@ -16,7 +16,7 @@ class Interpret::ToolsController < Interpret::BaseController
     hash = Interpret::Translation.export(translations)
     text = hash.ya2yaml
 
-    send_data text[5..text.length], :filename => "#{I18n.locale}.yml"
+    send_data text[5..text.length], :filename => "#{I18n.locale}.yml", :type => "text/plain", :disposition => "attachment"
   end
 
   def run_update

data/app/controllers/interpret/translations_controller.rb

@@ -1,28 +1,27 @@
 class Interpret::TranslationsController < Interpret::BaseController
   before_filter :get_tree, :only => :index
+  authorize_resource :class => "Interpret::Translation"
 
   def index
     key = params[:key]
     t = Interpret::Translation.arel_table
     if key
-      @translations = Interpret::Translation.locale(I18n.locale).where(t[:key].matches("#{CGI.escape(key)}.%"))
+      @translations = Interpret::Translation.allowed.locale(I18n.locale).where(t[:key].matches("#{CGI.escape(key)}.%")).order("translations.key ASC")
       if I18n.locale != I18n.default_locale
-        @references = Interpret::Translation.locale(I18n.default_locale).where(t[:key].matches("#{CGI.escape(key)}.%"))
+        @references = Interpret::Translation.allowed.locale(I18n.default_locale).where(t[:key].matches("#{CGI.escape(key)}.%")).order("translations.key ASC")
       end
     else
-      @translations = Interpret::Translation.locale(I18n.locale).where(t[:key].does_not_match("%.%"))
+      @translations = Interpret::Translation.allowed.locale(I18n.locale).where(t[:key].does_not_match("%.%")).order("translations.key ASC")
       if I18n.locale != I18n.default_locale
-        @references = Interpret::Translation.locale(I18n.default_locale).where(t[:key].does_not_match("%.%"))
+        @references = Interpret::Translation.allowed.locale(I18n.default_locale).where(t[:key].does_not_match("%.%")).order("translations.key ASC")
       end
     end
-    if @interpret_user
-      @translations = @translations.where(:protected => false) if !@interpret_admin
-      @references = @references.where(:protected => false) if @references && !@interpret_admin
-    end
 
     # not show translations inside nested folders, \w avoids dots
     @translations = @translations.select{|x| x.key =~ /#{key}\.\w+$/} if key
     @references = @references.select{|x| x.key =~ /#{key}\.\w+$/} if key && @references
+
+    @total_keys_number = Interpret::Translation.locale(I18n.locale).count
   end
 
   def edit
@@ -30,10 +29,6 @@ class Interpret::TranslationsController < Interpret::BaseController
   end
 
   def update
-    if @interpret_user && !@interpret_admin && params[:interpret_translation].has_key?(:protected)
-      head :error
-      return
-    end
     @translation = Interpret::Translation.find(params[:id])
     old_value = @translation.value
 
@@ -67,6 +62,14 @@ class Interpret::TranslationsController < Interpret::BaseController
     end
   end
 
+  def destroy
+    @translation = Interpret::Translation.find(params[:id])
+
+    @translation.destroy
+    flash[:notice] = "Translation #{@translation.key} destroyed."
+    redirect_to request.env["HTTP_REFERER"]
+  end
+
   def live_edit
     blobs = params[:key].split(".")
     locale = blobs.first

data/app/models/interpret/ability.rb

@@ -0,0 +1,9 @@
+module Interpret
+  class Ability
+    include CanCan::Ability
+
+    def initialize(user)
+      can :manage, :all
+    end
+  end
+end

data/app/models/interpret/translation.rb

@@ -4,7 +4,37 @@ module Interpret
     default_scope order('locale ASC')
     validates_uniqueness_of :key, :scope => :locale
 
+    after_update :set_stale
+
+    scope :stale, where(:stale => true)
+
+    private
+
+    # If this translations is in the main language, mark this translation in
+    # other languages as stale, so the translators know that they must change
+    # it.
+    def set_stale
+      return unless locale == I18n.default_locale.to_s
+
+      Translation.where(:key => key).where(Translation.arel_table[:locale].not_eq(locale)).update_all({:stale => true})
+    end
+
     class << self
+
+      def allowed
+        s = order("")
+        if Interpret.wild_blacklist.any?
+          black_keys = Interpret.wild_blacklist.map{|x| "#{CGI.escape(x)}%"}
+          s = s.where(arel_table[:key].does_not_match_all(black_keys))
+        end
+        if Interpret.fixed_blacklist.any?
+          black_keys = Interpret.fixed_blacklist.map{|x| "#{CGI.escape(x)}"}
+          s = s.where(arel_table[:key].does_not_match_all(black_keys))
+        end
+        s
+      end
+
+
       # Generates a hash representing the tree structure of the translations
       # for the given locale. It includes only "folders" in the sense of
       # locale keys that includes some real translations, or other keys.
@@ -40,10 +70,9 @@ module Interpret
 
       # Import the contents of the given .yml locale file into the database
       # backend. If a given key already exists in database, it will be
-      # overwritten, otherwise it won't be touched. This means that  it won't
+      # overwritten, otherwise it won't be touched. This means that it won't
       # delete any existing translation, it only overwrites the ones you give
       # in the file.
-      # If the given file has new translations, these will be ignored.
       #
       # The language will be obtained from the first unique key of the yml
       # file.
@@ -53,12 +82,18 @@ module Interpret
 
         lang = hash.keys.first
 
+        unless lang.to_s == I18n.locale.to_s
+          raise ArgumentError, "the language doesn't match"
+        end
+
         records = parse_hash(hash.first[1], lang)
         transaction do
           records.each do |x|
             if tr = locale(lang).find_by_key(x.key)
               tr.value = x.value
-              tr.save(:validate => false)
+              tr.save!
+            else
+              x.save!
             end
           end
         end

data/app/views/interpret/missing_translations/blank.html.erb

@@ -0,0 +1,35 @@
+<% if @blank_translations.empty? %>
+  <p>There are no blank translations</p>
+<% else %>
+  <p>There are <%= @blank_translations.size %> blank translations in this
+  language [ <%= I18n.locale %> ]. These are translations that exists but are
+  empty strings, so I show you them in case you want to take some action.</p>
+  <table>
+    <thead>
+      <tr class="header">
+        <th>Key</th>
+        <th>Value in [ <%= I18n.default_locale %> ]</th>
+        <th>Your translation to [ <%= I18n.locale %> ]</th>
+        <th>Delete</th>
+      </tr>
+    </thead>
+    <% @blank_translations.each do |trans, ref| %>
+      <tr>
+        <td><%= trans.key %></td>
+        <td><%= ref || "It's empty" %></td>
+        <td>
+          <%= form_for Interpret::Translation.new, :url => interpret_translations_path do |f| %>
+            <%= f.hidden_field "locale", :value => I18n.locale %>
+            <%= f.hidden_field "key", :value => trans.key %>
+            <%= f.text_area :value, :rows => 4, :cols => 60 %>
+            <%= submit_tag "Create" %>
+          <% end %>
+        </td>
+        <td>
+          <%= link_to "Destroy it", trans, :method => :delete, :confirm => "Are you sure?" %>
+        </td>
+      </tr>
+    <% end %>
+  </table>
+<% end %>
+

data/app/views/interpret/missing_translations/index.html.erb

@@ -7,27 +7,38 @@
   create them below and you can see the translation key and also the original
   content in the reference language [ <%= I18n.default_locale %> ]
   </p>
-  <table>
+  <table id='missing_translations'>
     <thead>
       <tr class="header">
         <th>Key</th>
         <th>Value in [ <%= I18n.default_locale %> ]</th>
         <th>Your translation to [ <%= I18n.locale %> ]</th>
+        <% if can? :destroy, Interpret::Translation %>
+          <th>Delete</th>
+        <% end %>
       </tr>
     </thead>
-    <% @missing_translations.each do |trans| %>
-      <tr>
-        <td><%= trans[:key] %></td>
-        <td><%= trans[:ref_value] %></td>
-        <td>
-          <%= form_for Interpret::Translation.new, :url => interpret_translations_path do |f| %>
-            <%= f.hidden_field "locale", :value => I18n.locale %>
-            <%= f.hidden_field "key", :value => trans[:key] %>
-            <%= f.text_area :value, :rows => 4, :cols => 60 %>
-            <%= submit_tag "Create" %>
+    <tbody>
+      <% @missing_translations.each do |trans| %>
+        <tr>
+          <td><%= trans[:key] %></td>
+          <td><%= trans[:ref_value] %></td>
+          <td>
+            <%= form_for Interpret::Translation.new, :url => interpret_translations_path do |f| %>
+              <%= f.hidden_field "locale", :value => I18n.locale %>
+              <%= f.hidden_field "key", :value => trans[:key] %>
+              <%= f.text_area :value, :rows => 4, :cols => 60 %>
+              <%= submit_tag "Create" %>
+            <% end %>
+          </td>
+          <% if can? :destroy, trans[:source] %>
+            <td>
+              <%= link_to "Destroy", trans[:source], :method => :delete, :confirm => "Are you sure?" %>
+              the original [ <%= I18n.default_locale %> ] translation.
+            </td>
           <% end %>
-        </td>
-      </tr>
-    <% end %>
+        </tr>
+      <% end %>
+    </tbody>
   </table>
 <% end %>

data/app/views/interpret/missing_translations/stale.html.erb

@@ -0,0 +1,43 @@
+<% if I18n.locale == I18n.default_locale %>
+  <p>There can't be stale translations for the main language</p>
+
+<% elsif @stale_translations.empty? %>
+  <p>There are no stale translations</p>
+
+<% else %>
+  <p>There are <%= @stale_translations.size %> stale translations in [<%= I18n.locale %>].</p>
+  <p>
+    They have been modified in the master language (<%= I18n.default_locale %>)
+    so probably you want to change them in the current languge too.
+    Once you think your new adaptation is correct click on "Mark as OK" button and that translation will no longer appear as stale.
+  </p>
+  <table id='stale_translations'>
+    <thead>
+      <tr class="header">
+        <th>Key</th>
+        <th>Value in [ <%= I18n.default_locale %> ]</th>
+        <th>Your translation to [ <%= I18n.locale %> ]</th>
+        <th>Actions</th>
+      </tr>
+    </thead>
+    <% @stale_translations.each do |trans, ref| %>
+      <tr>
+        <td class='key'><%= trans.key %></td>
+        <td><%= ref.value %></td>
+        <td class='content' id='translation_<%= trans.id %>'>
+            <%= best_in_place trans, :value,
+                :type => :textarea,
+                :path => interpret_translation_path(trans),
+                :activator => "#translation_#{trans.id}",
+                :sanitize => false %>
+        </td>
+        <td>
+          <%= form_for trans, :url => interpret_translation_path(trans) do |f| %>
+            <%= f.hidden_field :stale, :value => false %>
+            <%= submit_tag "Mark as OK" %>
+          <% end %>
+        </td>
+      </tr>
+    <% end %>
+  </table>
+<% end %>