awesome_translations 0.0.2

data/app/views/awesome_translations/groups/show.html.haml

@@ -0,0 +1,28 @@
+%h1= "Show group: #{@group.name}"
+
+= form_for :group, url: handler_group_path(@handler, @group), method: :put do |f|
+  %table
+    %thead
+      %th Key
+      - I18n.available_locales.each do |locale|
+        %th= locale
+    %tbody
+      - @translations.each do |translation|
+        %tr
+          %td= translation.key
+
+          - I18n.available_locales.each do |locale|
+            %td
+              = text_field "t", "#{translation.key}[#{locale}]", value: translation.value(locale: locale)
+
+        - if translation.file_line_content?
+          %tr.line-content-row
+            %td.line-content{colspan: 1 + I18n.available_locales.length}
+              %pre= translation.file_line_content
+          %tr
+            %td.line-spacer{colspan: 1 + I18n.available_locales.length}
+      - if @translations.empty?
+        %tr
+          %td.error{colspan: 2} No translations were found.
+
+  = f.submit "Save"

data/app/views/awesome_translations/handlers/index.html.haml

@@ -0,0 +1,13 @@
+%h1 Handlers
+
+%table
+  %thead
+    %tr
+      %th Handler
+  %tbody
+    - @handlers.each do |handler|
+      %tr
+        %td= link_to handler.name, handler_path(handler)
+    - if @handlers.empty?
+      %tr
+        %td.error{colspan: 1} No handlers were found.

data/app/views/awesome_translations/handlers/show.html.haml

@@ -0,0 +1,12 @@
+%h1= "Show handler: #{@handler.name}"
+
+%table
+  %thead
+    %th Group
+  %tbody
+    - @groups.each do |group|
+      %tr
+        %td= link_to group.name, handler_group_path(@handler, group)
+    - if @groups.empty?
+      %tr
+        %td.error{colspan: 2} No groups were found.

data/app/views/layouts/awesome_translations/application.html.haml

@@ -0,0 +1,24 @@
+!!! 5
+%html
+%head
+  %title AwesomeTranslations
+
+  = stylesheet_link_tag "awesome_translations/application", media: "all"
+  = stylesheet_link_tag "http://fonts.googleapis.com/css?family=Open+Sans:400"
+  = stylesheet_link_tag "http://fonts.googleapis.com/css?family=Raleway:400"
+
+  = javascript_include_tag "awesome_translations/application"
+
+  = csrf_meta_tags
+
+%body{class: ["controller_#{controller_name}", "action_#{action_name}"]}
+  %table.main-table
+    %tbody
+      %tr
+        %td.main-logo Awesome Translations
+      %tr
+        %td.main-menu
+          .menu-item= link_to "Handlers", handlers_path
+      %tr
+        %td.main-content
+          = yield

data/config/routes.rb

@@ -0,0 +1,7 @@
+AwesomeTranslations::Engine.routes.draw do
+  resources :handlers, only: [:index, :show] do
+    resources :groups, only: [:show, :update]
+  end
+
+  root to: "handlers#index"
+end

data/lib/awesome_translations.rb

@@ -0,0 +1,18 @@
+require "awesome_translations/engine"
+require "haml"
+require "string-cases"
+require "array_enumerator"
+
+module AwesomeTranslations
+  autoload :Config, "#{File.dirname(__FILE__)}/awesome_translations/config"
+  autoload :ErbInspector, "#{File.dirname(__FILE__)}/awesome_translations/erb_inspector"
+  autoload :Handlers, "#{File.dirname(__FILE__)}/awesome_translations/handlers"
+  autoload :ObjectExtensions, "awesome_translations/object_extensions"
+  autoload :ModelInspector, "awesome_translations/model_inspector"
+
+  def self.config
+    @config ||= AwesomeTranslations::Config.new
+  end
+end
+
+Object.__send__(:include, AwesomeTranslations::ObjectExtensions)

data/lib/awesome_translations/config.rb

@@ -0,0 +1,7 @@
+class AwesomeTranslations::Config
+  attr_accessor :paths_to_translate
+
+  def initialize
+    @paths_to_translate = [Rails.root.to_s]
+  end
+end

data/lib/awesome_translations/engine.rb

@@ -0,0 +1,3 @@
+class AwesomeTranslations::Engine < ::Rails::Engine
+  isolate_namespace AwesomeTranslations
+end

data/lib/awesome_translations/erb_inspector.rb

@@ -0,0 +1,45 @@
+# Used to find translations in the Rails app by inspecting .erb- and .haml-files.
+class AwesomeTranslations::ErbInspector
+  autoload :FileInspector, "#{File.dirname(__FILE__)}/erb_inspector/file_inspector"
+  autoload :TranslationInspector, "#{File.dirname(__FILE__)}/erb_inspector/translation_inspector"
+
+  def initialize(args = {})
+    if args[:dirs]
+      @dirs = args[:dirs]
+    else
+      @dirs = AwesomeTranslations.config.paths_to_translate
+    end
+  end
+
+  # Yields all relevant .erb- and .haml-files.
+  def files
+    Enumerator.new do |yielder|
+      @dirs.each do |dir|
+        scan_dir("", dir, yielder)
+      end
+    end
+  end
+
+private
+
+  def scan_dir(path, root_path, yielder)
+    Dir.foreach("#{root_path}/#{path}") do |file|
+      next if file == "." || file == ".."
+      file_path = "#{path}"
+      file_path << "/" unless file_path.empty?
+      file_path << file
+
+      full_path = "#{root_path}/#{file_path}"
+      ext = File.extname(file_path)
+
+      if File.directory?(full_path)
+        scan_dir(file_path, root_path, yielder)
+      elsif ext == ".erb" || ext == ".haml"
+        yielder << AwesomeTranslations::ErbInspector::FileInspector.new(
+          file_path: file_path,
+          root_path: root_path
+        )
+      end
+    end
+  end
+end

data/lib/awesome_translations/erb_inspector/file_inspector.rb

@@ -0,0 +1,88 @@
+class AwesomeTranslations::ErbInspector::FileInspector
+  METHOD_NAMES = ["t"]
+  VALID_BEGINNING = '(^|\s+|\(|\{|<%=\s*)'
+
+  attr_reader :root_path, :file_path
+
+  def initialize(args)
+    @args = args
+    @root_path, @file_path = args[:root_path], args[:file_path]
+  end
+
+  def translations
+    Enumerator.new do |yielder|
+      translations_found = {}
+
+      File.open(full_path, "r") do |fp|
+        line_no = 0
+        fp.each_line do |line|
+          line_no += 1
+          parse_content(line_no, line, translations_found, yielder)
+        end
+      end
+    end
+  end
+
+  def full_path
+    "#{@root_path}/#{@file_path}"
+  end
+
+  def basename
+    File.basename(@file_path).match(/\A(.+?)\./)[1]
+  end
+
+private
+
+  def parse_content(line_no, line, translations_found, yielder)
+    METHOD_NAMES.each do |method_name|
+      # Scan for the various valid formats.
+      line.scan(/#{VALID_BEGINNING}(#{Regexp.escape(method_name)})\s*\("(.+?)"/) do |match|
+        add_translation(line_no, match[1], match[2], translations_found, yielder)
+      end
+
+      line.scan(/#{VALID_BEGINNING}(#{Regexp.escape(method_name)})\s*"(.+?)"/) do |match|
+        add_translation(line_no, match[1], match[2], translations_found, yielder)
+      end
+
+      line.scan(/#{VALID_BEGINNING}(#{Regexp.escape(method_name)})\s*\('(.+?)'/) do |match|
+        add_translation(line_no, match[1], match[2], translations_found, yielder)
+      end
+
+      line.scan(/#{VALID_BEGINNING}(#{Regexp.escape(method_name)})\s*'(.+?)'/) do |match|
+        add_translation(line_no, match[1], match[2], translations_found, yielder)
+      end
+    end
+  end
+
+  def add_translation(line_no, method, key, translations_found, yielder)
+    translation_inspector = AwesomeTranslations::ErbInspector::TranslationInspector.new(
+      root_path: @root_path,
+      file_path: @file_path,
+      line_no: line_no,
+      method: method,
+      key: key
+    )
+
+    unless translation_with_key_exists?(translations_found, translation_inspector.key)
+      yielder << translation_inspector
+    end
+  end
+
+  def translation_with_key_exists?(translations_found, translation_key)
+    translations_found.select { |t| t.key == translation_key }.any?
+  end
+
+  def translation_key_from_dir_file_and_key(dir, file, key)
+    return key unless key.starts_with?(".")
+
+    file = file.gsub(/\A_/, "") # Remove partial indicator.
+
+    translation_key = dir
+    translation_key = translation_key.gsub(/\Aapp\//, "")
+    translation_key << "/#{file}"
+    translation_key.gsub!("/", ".")
+    translation_key << key
+
+    return translation_key
+  end
+end

data/lib/awesome_translations/erb_inspector/translation_inspector.rb

@@ -0,0 +1,69 @@
+class AwesomeTranslations::ErbInspector::TranslationInspector
+  attr_reader :dir, :file_path, :line_no, :method, :key, :full_key, :full_path, :root_path
+
+  def initialize(args)
+    @dir, @file_path, @full_path, @line_no = args[:dir], args[:file_path], args[:full_path], args[:line_no]
+    @method, @key, @root_path = args[:method], args[:key], args[:root_path]
+
+    @full_path = "#{@root_path}/#{@file_path}"
+
+    generate_dir
+    generate_full_key
+  end
+
+  def model
+    AwesomeTranslations::Translation.new(
+      key: @full_key,
+      dir: @dir,
+      full_path: @full_path,
+      file_path: @file_path,
+      line_no: @line_no
+    )
+  end
+
+private
+
+  def generate_full_key
+    if @method == "t" && @key.start_with?(".")
+      @full_key = File.dirname(@file_path)
+
+      if @full_key.start_with?("app/views/")
+        # Remove "app/views" from view-translations since that doesn't get used in keys.
+        @full_key = @full_key.gsub(/\Aapp\/views\//, "")
+      elsif @full_key.start_with?("app/")
+        # Remove "app" from controller- and helper-translations since that doesn't get used.
+        @full_key = @full_key.gsub(/\Aapp\//, "")
+      end
+
+      @full_key = @full_key.gsub("/", ".")
+      @full_key << "."
+      @full_key << file_key(@file_path)
+      @full_key << "."
+      @full_key << @key.gsub(/\A\./, "")
+    elsif @method == "t"
+      @full_key = @key
+    else
+      raise "Unknown method-name: '#{@method}'."
+    end
+  end
+
+  def file_key(file_path)
+    key = File.basename(file_path)
+
+    # Remove extension
+    key = key.match(/\A(.+?)\./)[1]
+
+    # Remove leading "_" from partials
+    key = key.gsub(/\A_/, "")
+
+    return key
+  end
+
+  def generate_dir
+    if @key.start_with?(".")
+      @dir = "#{Rails.root}/config/locales/awesome_translations/#{File.dirname(@file_path)}"
+    else
+      @dir = "#{Rails.root}/config/locales/awesome_translations"
+    end
+  end
+end

data/lib/awesome_translations/handlers.rb

@@ -0,0 +1,25 @@
+class AwesomeTranslations::Handlers
+  @handlers = []
+
+  Dir.foreach("#{File.dirname(__FILE__)}/handlers") do |file|
+    match = file.match(/\A(.+)_handler\.rb\Z/)
+    next unless match
+
+    const_name_snake = "#{match[1]}_handler"
+    const_name_camel = StringCases.snake_to_camel(const_name_snake)
+
+    autoload const_name_camel.to_sym, "#{File.dirname(__FILE__)}/handlers/#{const_name_snake}"
+
+    unless const_name_snake == "base_handler"
+      @handlers << AwesomeTranslations::Handler.new(
+        id: const_name_snake,
+        const_name: const_name_camel,
+        name: const_name_camel
+      )
+    end
+  end
+
+  def self.list
+    @handlers
+  end
+end

data/lib/awesome_translations/handlers/base_handler.rb

@@ -0,0 +1,2 @@
+class AwesomeTranslations::Handlers::BaseHandler
+end

data/lib/awesome_translations/handlers/erb_handler.rb

@@ -0,0 +1,35 @@
+class AwesomeTranslations::Handlers::ErbHandler < AwesomeTranslations::Handlers::BaseHandler
+  METHOD_NAMES = ["_", "t"]
+  VALID_BEGINNING = '(^|\s+|\(|\{|<%=\s*)'
+
+  def groups
+    ArrayEnumerator.new do |yielder|
+      erb_inspector = AwesomeTranslations::ErbInspector.new
+      erb_inspector.files.each do |file|
+        yielder << AwesomeTranslations::Group.new(
+          id: Base64.urlsafe_encode64(file.full_path),
+          handler: self,
+          data: {
+            name: file.file_path,
+            root_path: file.root_path,
+            full_path: file.full_path
+          }
+        )
+      end
+    end
+  end
+
+  def translations_for_group(group)
+    ArrayEnumerator.new do |yielder|
+      translations = []
+
+      # Parse views for translations.
+      erb_inspector = AwesomeTranslations::ErbInspector.new
+      file = erb_inspector.files.select { |file| file.full_path == group.data[:full_path] }.first
+
+      file.translations.each do |translation|
+        yielder << translation.model
+      end
+    end
+  end
+end

data/lib/awesome_translations/handlers/global_handler.rb

@@ -0,0 +1,31 @@
+class AwesomeTranslations::Handlers::GlobalHandler < AwesomeTranslations::Handlers::BaseHandler
+  def groups
+    ArrayEnumerator.new do |yielder|
+      yielder << AwesomeTranslations::Group.new(
+        id: "global",
+        handler: self,
+        data: {
+          name: "Global translations"
+        }
+      )
+    end
+  end
+
+  def translations_for_group(group)
+    ArrayEnumerator.new do |yielder|
+      translations_found = {}
+
+      erb_inspector = AwesomeTranslations::ErbInspector.new
+      erb_inspector.files.each do |file|
+        file.translations.each do |translation|
+          next if translation.key.start_with?(".")
+
+          unless translations_found.key?(translation.full_key)
+            translations_found[translation.full_key] = true
+            yielder << translation.model
+          end
+        end
+      end
+    end
+  end
+end

data/lib/awesome_translations/handlers/model_handler.rb

@@ -0,0 +1,95 @@
+class AwesomeTranslations::Handlers::ModelHandler < AwesomeTranslations::Handlers::BaseHandler
+  def groups
+    ArrayEnumerator.new do |yielder|
+      AwesomeTranslations::ModelInspector.model_classes.each do |model_inspector|
+        yielder << AwesomeTranslations::Group.new(
+          id: model_inspector.clazz.name,
+          handler: self
+        )
+      end
+    end
+  end
+
+  def translations_for_group(group)
+    ArrayEnumerator.new do |yielder|
+      model_inspector = AwesomeTranslations::ModelInspector.model_classes.select { |model_inspector| model_inspector.clazz.name == group.name }.first
+      raise "No inspector by that name: #{model_inspector.clazz.name}" unless model_inspector
+
+      model_names(model_inspector).each { |translation| yielder << translation }
+      active_record_attributes(model_inspector).each { |translation| yielder << translation }
+      paperclip_attachments(model_inspector).each { |translation| yielder << translation }
+      relationships(model_inspector).each { |translation| yielder << translation }
+    end
+  end
+
+private
+
+  def dir_path(model_inspector)
+    class_name = model_inspector.clazz.name
+    class_name = class_name.gsub("::", "_")
+    class_name = StringCases.camel_to_snake(class_name)
+
+    dir_path = "#{Rails.root}/config/locales/awesome_translations/models/#{class_name}"
+
+    return dir_path
+  end
+
+  def active_record_attributes(model_inspector)
+    result = []
+
+    model_inspector.attributes do |attribute|
+      translations = {}
+
+      I18n.available_locales.each do |locale|
+        translations[locale] = I18n.t(attribute.i18n_key, locale: locale)
+      end
+
+      result << AwesomeTranslations::Translation.new(
+        key: attribute.i18n_key,
+        dir: dir_path(model_inspector)
+      )
+    end
+
+    return result
+  end
+
+  def paperclip_attachments(model_inspector)
+    result = []
+
+    model_inspector.paperclip_attachments do |name|
+      result << AwesomeTranslations::Translation.new(
+        key: model_inspector.i18n_key(name),
+        dir: dir_path(model_inspector)
+      )
+    end
+
+    return result
+  end
+
+  def model_names(model_inspector)
+    result = []
+    result << AwesomeTranslations::Translation.new(
+      key: model_inspector.gettext_key_one,
+      dir: dir_path(model_inspector)
+    )
+    result << AwesomeTranslations::Translation.new(
+      key: model_inspector.gettext_key_other,
+      dir: dir_path(model_inspector)
+    )
+
+    return result
+  end
+
+  def relationships(model_inspector)
+    result = []
+
+    model_inspector.relationships do |key, reflection|
+      result << AwesomeTranslations::Translation.new(
+        key: model_inspector.i18n_key(reflection.name),
+        dir: dir_path(model_inspector)
+      )
+    end
+
+    return result
+  end
+end