Add a linter for PO files

3 files changed, 212 insertions, 0 deletions

diff --git a/lib/gitlab/po_linter.rb b/lib/gitlab/po_linter.rb
new file mode 100644
index 00000000000..54594949711
--- /dev/null
+++ b/lib/gitlab/po_linter.rb
@@ -0,0 +1,168 @@
+require 'simple_po_parser'
+
+module Gitlab
+  class PoLinter
+    attr_reader :po_path, :entries, :locale
+
+    VARIABLE_REGEX = /%{\w*}|%[a-z]/.freeze
+
+    def initialize(po_path, locale = I18n.locale.to_s)
+      @po_path = po_path
+      @locale = locale
+    end
+
+    def errors
+      @errors ||= validate_po
+    end
+
+    def validate_po
+      if parse_error = parse_po
+        return 'PO-syntax errors' => [parse_error]
+      end
+
+      validate_entries
+    end
+
+    def parse_po
+      @entries = SimplePoParser.parse(po_path)
+      nil
+    rescue SimplePoParser::ParserError => e
+      @entries = []
+      e.message
+    end
+
+    def validate_entries
+      errors = {}
+
+      entries.each do |entry|
+        # Skip validation of metadata
+        next if entry[:msgid].empty?
+
+        errors_for_entry = validate_entry(entry)
+        errors[join_message(entry[:msgid])] = errors_for_entry if errors_for_entry.any?
+      end
+
+      errors
+    end
+
+    def validate_entry(entry)
+      errors = []
+
+      validate_flags(errors, entry)
+      validate_variables(errors, entry)
+      validate_newlines(errors, entry)
+
+      errors
+    end
+
+    def validate_newlines(errors, entry)
+      message_id = join_message(entry[:msgid])
+
+      if entry[:msgid].is_a?(Array)
+        errors << "<#{message_id}> is defined over multiple lines, this breaks some tooling."
+      end
+    end
+
+    def validate_variables(errors, entry)
+      if entry[:msgid_plural].present?
+        validate_variables_in_message(errors, entry[:msgid], entry['msgstr[0]'])
+        validate_variables_in_message(errors, entry[:msgid_plural], entry['msgstr[1]'])
+      else
+        validate_variables_in_message(errors, entry[:msgid], entry[:msgstr])
+      end
+    end
+
+    def validate_variables_in_message(errors, message_id, message_translation)
+      message_id = join_message(message_id)
+      required_variables = message_id.scan(VARIABLE_REGEX)
+
+      validate_unnamed_variables(errors, required_variables)
+      validate_translation(errors, message_id, required_variables)
+
+      message_translation = join_message(message_translation)
+      unless message_translation.empty?
+        validate_variable_usage(errors, message_translation, required_variables)
+      end
+    end
+
+    def validate_translation(errors, message_id, used_variables)
+      variables = fill_in_variables(used_variables)
+
+      begin
+        Gitlab::I18n.with_locale(locale) do
+          translated = if message_id.include?('|')
+                         FastGettext::Translation.s_(message_id)
+                       else
+                         FastGettext::Translation._(message_id)
+                       end
+
+          translated % variables
+        end
+
+      # `sprintf` could raise an `ArgumentError` when invalid passing something
+      # other than a Hash when using named variables
+      #
+      # `sprintf` could raise `TypeError` when passing a wrong type when using
+      # unnamed variables
+      #
+      # FastGettext::Translation could raise `RuntimeError` (raised as a string),
+      # or as subclassess `NoTextDomainConfigured` & `InvalidFormat`
+      #
+      # `FastGettext::Translation` could raise `ArgumentError` as subclassess
+      # `InvalidEncoding`, `IllegalSequence` & `InvalidCharacter`
+      rescue ArgumentError, TypeError, RuntimeError => e
+        errors << "Failure translating to #{locale} with #{variables}: #{e.message}"
+      end
+    end
+
+    def fill_in_variables(variables)
+      if variables.empty?
+        []
+      elsif variables.any? { |variable| unnamed_variable?(variable) }
+        variables.map do |variable|
+          variable == '%d' ? Random.rand(1000) : Gitlab::Utils.random_string
+        end
+      else
+        variables.inject({}) do |hash, variable|
+          variable_name = variable[/\w+/]
+          hash[variable_name] = Gitlab::Utils.random_string
+          hash
+        end
+      end
+    end
+
+    def validate_unnamed_variables(errors, variables)
+      if  variables.size > 1 && variables.any? { |variable_name| unnamed_variable?(variable_name) }
+        errors << 'is combining multiple unnamed variables'
+      end
+    end
+
+    def validate_variable_usage(errors, translation, required_variables)
+      found_variables = translation.scan(VARIABLE_REGEX)
+
+      missing_variables = required_variables - found_variables
+      if missing_variables.any?
+        errors << "<#{translation}> is missing: [#{missing_variables.to_sentence}]"
+      end
+
+      unknown_variables = found_variables - required_variables
+      if unknown_variables.any?
+        errors << "<#{translation}> is using unknown variables: [#{unknown_variables.to_sentence}]"
+      end
+    end
+
+    def unnamed_variable?(variable_name)
+      !variable_name.start_with?('%{')
+    end
+
+    def validate_flags(errors, entry)
+      if flag = entry[:flag]
+        errors << "is marked #{flag}"
+      end
+    end
+
+    def join_message(message)
+      Array(message).join
+    end
+  end
+end
diff --git a/lib/gitlab/utils.rb b/lib/gitlab/utils.rb
index 9670c93759e..abb3d3a02c3 100644
--- a/lib/gitlab/utils.rb
+++ b/lib/gitlab/utils.rb
@@ -42,5 +42,9 @@ module Gitlab
         'No'
       end
     end
+
+    def random_string
+      Random.rand(Float::MAX.to_i).to_s(36)
+    end
   end
 end
diff --git a/lib/tasks/gettext.rake b/lib/tasks/gettext.rake
index b48e4dce445..b75da6bf2fc 100644
--- a/lib/tasks/gettext.rake
+++ b/lib/tasks/gettext.rake
@@ -19,4 +19,44 @@ namespace :gettext do
     Rake::Task['gettext:pack'].invoke
     Rake::Task['gettext:po_to_json'].invoke
   end
+
+  desc 'Lint all po files in `locale/'
+  task lint: :environment do
+    FastGettext.silence_errors
+    files = Dir.glob(Rails.root.join('locale/*/gitlab.po'))
+
+    linters = files.map do |file|
+      locale = File.basename(File.dirname(file))
+
+      Gitlab::PoLinter.new(file, locale)
+    end
+
+    pot_file = Rails.root.join('locale/gitlab.pot')
+    linters.unshift(Gitlab::PoLinter.new(pot_file))
+
+    failed_linters = linters.select { |linter| linter.errors.any? }
+
+    if failed_linters.empty?
+      puts 'All PO files are valid.'
+    else
+      failed_linters.each do |linter|
+        report_errors_for_file(linter.po_path, linter.errors)
+      end
+
+      raise "Not all PO-files are valid: #{failed_linters.map(&:po_path).to_sentence}"
+    end
+  end
+
+  def report_errors_for_file(file, errors_for_file)
+    puts "Errors in `#{file}`:"
+
+    errors_for_file.each do |message_id, errors|
+      puts "  #{message_id}"
+      errors.each do |error|
+        spaces = ' ' * 4
+        error = error.lines.join("#{spaces}")
+        puts "#{spaces}#{error}"
+      end
+    end
+  end
 end