peak_flow_utils 0.0.1 → 0.1.6

data/app/migrations/20150907070909_create_groups.rb

@@ -0,0 +1,12 @@
+class CreateGroups < PeakFlowUtils::ApplicationMigration
+  def change
+    create_table :peak_flow_utils_groups do |t|
+      t.references :handler, null: false
+      t.string :identifier, index: true
+      t.string :name
+      t.timestamps
+    end
+
+    add_foreign_key :peak_flow_utils_groups, :peak_flow_utils_handlers, column: "handler_id"
+  end
+end

data/app/migrations/20150907090900_create_handlers.rb

@@ -0,0 +1,9 @@
+class CreateHandlers < PeakFlowUtils::ApplicationMigration
+  def change
+    create_table :peak_flow_utils_handlers do |t|
+      t.string :identifier, index: true, null: false
+      t.string :name, null: false
+      t.timestamps
+    end
+  end
+end

data/app/migrations/20150908085500_create_translation_values.rb

@@ -0,0 +1,13 @@
+class CreateTranslationValues < PeakFlowUtils::ApplicationMigration
+  def change
+    create_table :peak_flow_utils_translation_values do |t|
+      t.references :translation_key, null: false
+      t.string :file_path
+      t.string :locale, index: true
+      t.string :value
+      t.timestamps
+    end
+
+    add_foreign_key :peak_flow_utils_translation_values, :peak_flow_utils_translation_keys, column: "translation_key_id"
+  end
+end

data/app/migrations/20150908090800_create_handler_texts.rb

@@ -0,0 +1,22 @@
+class CreateHandlerTexts < PeakFlowUtils::ApplicationMigration
+  def change
+    create_table :peak_flow_utils_handler_texts do |t|
+      t.belongs_to :handler, null: false
+      t.belongs_to :translation_key, index: false, null: false
+      t.belongs_to :group, null: false
+      t.string :key_show
+      t.string :file_path
+      t.integer :line_no
+      t.string :full_path, index: true
+      t.string :dir
+      t.string :default
+      t.timestamps
+    end
+
+    add_index :peak_flow_utils_handler_texts, :handler_id, name: "index_handler_translations_handler_id"
+
+    add_foreign_key :peak_flow_utils_handler_texts, :peak_flow_utils_handlers, column: "handler_id"
+    add_foreign_key :peak_flow_utils_handler_texts, :peak_flow_utils_translation_keys, column: "translation_key_id"
+    add_foreign_key :peak_flow_utils_handler_texts, :peak_flow_utils_groups, column: "group_id"
+  end
+end

data/app/migrations/20160411190500_create_scanned_files.rb

@@ -0,0 +1,10 @@
+class CreateScannedFiles < PeakFlowUtils::ApplicationMigration
+  def change
+    create_table :peak_flow_utils_scanned_files do |t|
+      t.string :file_path, index: true, null: false
+      t.integer :file_size, null: false
+      t.datetime :last_changed_at, null: false
+      t.timestamps
+    end
+  end
+end

data/app/migrations/peak_flow_utils/application_migration.rb

@@ -0,0 +1,5 @@
+class PeakFlowUtils::ApplicationMigration < ActiveRecord::Migration[5.1]
+  def connection
+    PeakFlowUtils::ApplicationRecord.connection
+  end
+end

data/app/models/peak_flow_utils/application_record.rb

@@ -0,0 +1,9 @@
+class PeakFlowUtils::ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+  self.table_name_prefix = "peak_flow_utils_"
+
+  establish_connection(
+    adapter: "sqlite3",
+    database: "db/peak_flow_utils.sqlite3"
+  )
+end

data/app/models/peak_flow_utils/group.rb

@@ -0,0 +1,22 @@
+class PeakFlowUtils::Group < PeakFlowUtils::ApplicationRecord
+  attr_writer :at_group
+
+  belongs_to :handler
+
+  has_many :handler_translations, dependent: :destroy
+  has_many :translation_keys, dependent: :destroy
+
+  validates :name, :handler, presence: true
+
+  def at_handler
+    @at_handler ||= handler.at_handler
+  end
+
+  def at_group
+    @at_group ||= PeakFlowUtils::GroupService.find_by_handler_and_id(at_handler, identifier) # rubocop:disable Rails/DynamicFindBy
+  end
+
+  def to_param
+    identifier
+  end
+end

data/app/models/peak_flow_utils/handler.rb

@@ -0,0 +1,14 @@
+class PeakFlowUtils::Handler < PeakFlowUtils::ApplicationRecord
+  has_many :groups, dependent: :destroy
+  has_many :handler_texts, dependent: :destroy
+
+  validates :name, presence: true
+
+  def at_handler
+    @at_handler ||= PeakFlowUtils::HandlerHelper.find(identifier)
+  end
+
+  def to_param
+    identifier
+  end
+end

data/app/models/peak_flow_utils/handler_text.rb

@@ -0,0 +1,46 @@
+class PeakFlowUtils::HandlerText < PeakFlowUtils::ApplicationRecord
+  belongs_to :group
+  belongs_to :handler
+  belongs_to :translation_key
+
+  validates :handler, :translation_key, presence: true
+
+  delegate :key, :last_key, to: :translation_key
+  delegate :value, to: :translation, prefix: true
+  delegate :array_translation?, :file_line_content, :file_line_content?, :translated_value_for_locale, to: :translation
+
+  def key_show_with_fallback
+    key_show.presence || last_key
+  end
+
+  def translation
+    @translation ||= PeakFlowUtils::Translation.new(
+      key: key,
+      dir: dir,
+      full_path: full_path,
+      file_path: file_path,
+      line_no: line_no
+    )
+  end
+
+  def finished?
+    @_finished = translation.finished? if @finished.nil?
+    @_finished
+  end
+
+  def unfinished?
+    !finished?
+  end
+
+  def array_key
+    return unless (match = key.match(/\A(.+)\[(\d+)\]\Z/))
+
+    match[1]
+  end
+
+  def array_no
+    return unless (match = key.match(/\A(.+)\[(\d+)\]\Z/))
+
+    match[2].to_i
+  end
+end

data/app/models/peak_flow_utils/scanned_file.rb

@@ -0,0 +1,2 @@
+class PeakFlowUtils::ScannedFile < PeakFlowUtils::ApplicationRecord
+end

data/app/models/peak_flow_utils/translation_key.rb

@@ -0,0 +1,8 @@
+class PeakFlowUtils::TranslationKey < PeakFlowUtils::ApplicationRecord
+  has_many :handler_translations, dependent: :destroy
+  has_many :translation_values, dependent: :destroy
+
+  def last_key
+    key.to_s.split(".").last
+  end
+end

data/app/models/peak_flow_utils/translation_value.rb

@@ -0,0 +1,24 @@
+class PeakFlowUtils::TranslationValue < PeakFlowUtils::ApplicationRecord
+  belongs_to :translation_key
+
+  validates :translation_key, presence: true
+
+  delegate :key, to: :translation_key
+
+  def calculated_translation_file_path
+    "#{handler_translation.dir}/#{locale}.yml" if handler_translation
+  end
+
+  def handler_translation
+    @handler_translation ||= PeakFlowUtils::HandlerText
+      .find_by(translation_key_id: translation_key_id)
+  end
+
+  def migrate_to_awesome_translations_namespace!
+    PeakFlowUtils::TranslationMigrator.new(
+      translation_key: translation_key,
+      handler_translation: handler_translation,
+      translation_value: self
+    ).execute
+  end
+end

data/app/services/peak_flow_utils/application_service.rb

@@ -0,0 +1,2 @@
+class PeakFlowUtils::ApplicationService < ServicePattern::Service
+end

data/app/services/peak_flow_utils/attribute_service.rb

@@ -0,0 +1,32 @@
+class PeakFlowUtils::AttributeService
+  attr_reader :name, :model_inspector
+
+  def initialize(model_inspector, name)
+    @model_inspector = model_inspector
+    @name = name
+  end
+
+  def i18n_key
+    "activerecord.attributes.#{@model_inspector.snake_name}.#{@name}"
+  end
+
+  def simple_form_include_blank_key
+    "simple_form.include_blanks.#{@model_inspector.snake_name}.#{@name}"
+  end
+
+  def simple_form_label_key
+    "simple_form.labels.#{@model_inspector.snake_name}.#{@name}"
+  end
+
+  def simple_form_hint_key
+    "simple_form.hints.#{@model_inspector.snake_name}.#{@name}"
+  end
+
+  def simple_form_placeholder_key
+    "simple_form.placeholders.#{@model_inspector.snake_name}.#{@name}"
+  end
+
+  def simple_form_prompt_key
+    "simple_form.prompts.#{@model_inspector.snake_name}.#{@name}"
+  end
+end

data/app/services/peak_flow_utils/configuration_service.rb

@@ -0,0 +1,11 @@
+class PeakFlowUtils::ConfigurationService
+  attr_accessor :paths_to_translate
+
+  def self.current
+    @current ||= PeakFlowUtils::ConfigurationService.new
+  end
+
+  def initialize
+    @paths_to_translate = [Rails.root.to_s]
+  end
+end

data/app/services/peak_flow_utils/database_initializer_service.rb

@@ -0,0 +1,39 @@
+class PeakFlowUtils::DatabaseInitializerService < PeakFlowUtils::ApplicationService
+  def execute
+    path = File.realpath("#{File.dirname(__FILE__)}/../../migrations")
+    create_schema_table unless schema_table_exists?
+
+    Dir["#{path}/[0-9]*_*.rb"].sort.map do |filename|
+      match = filename.match(/migrations\/(\d+)_(.+)\.rb\Z/)
+      next unless match
+
+      version = match[1]
+      next if version_migrated?(version)
+
+      require filename
+      migration = match[2].camelize.constantize
+      migration.migrate(:up)
+      register_migration_migrated(version)
+    end
+
+    ServicePattern::Response.new(success: true)
+  end
+
+private
+
+  def create_schema_table
+    PeakFlowUtils::ApplicationRecord.connection.execute("CREATE TABLE schema_migrations (version VARCHAT)")
+  end
+
+  def register_migration_migrated(version)
+    PeakFlowUtils::ApplicationRecord.connection.execute("INSERT INTO schema_migrations (version) VALUES ('#{version}')")
+  end
+
+  def schema_table_exists?
+    PeakFlowUtils::ApplicationRecord.connection.execute("SELECT * FROM sqlite_master WHERE type = 'table' AND name = 'schema_migrations'").any?
+  end
+
+  def version_migrated?(version)
+    PeakFlowUtils::ApplicationRecord.connection.execute("SELECT * FROM schema_migrations WHERE version = '#{version}'").any?
+  end
+end

data/app/services/peak_flow_utils/erb_inspector.rb

@@ -0,0 +1,71 @@
+class PeakFlowUtils::ErbInspector
+  def initialize(args = {})
+    @args = args
+    @args[:exts] ||= [".erb", ".haml", ".liquid", ".markerb", ".rb", ".rake", ".slim", "."] + PeakFlowUtils::ErbInspector::FileInspector::JS_FILE_EXTS
+
+    if @args[:dirs]
+      @dirs = @args[:dirs]
+    else
+      @dirs = PeakFlowUtils::ConfigurationService.current.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
+
+  def file(root_path, file_path)
+    PeakFlowUtils::ErbInspector::FileInspector.new(
+      file_path: file_path,
+      root_path: root_path
+    )
+  end
+
+private
+
+  def scan_dir(path, root_path, yielder)
+    Dir.foreach("#{root_path}/#{path}") do |file|
+      next if file == "." || file == ".."
+
+      file_path = path.clone
+      file_path << "/" unless file_path.empty?
+      file_path << file
+
+      file_path_with_path = "#{path}/#{file_path}"
+
+      full_path = "#{root_path}/#{file_path}"
+      ext = File.extname(file_path)
+
+      if File.directory?(full_path)
+        scan_dir(file_path, root_path, yielder)
+      elsif @args[:exts].include?(ext)
+        scanned_file = PeakFlowUtils::ScannedFile.find_or_initialize_by(file_path: file_path_with_path)
+        file_size = File.size(full_path)
+        last_changed_at = File.mtime(full_path)
+
+        changed = false
+        changed = true unless file_size == scanned_file.file_size
+        changed = true unless last_changed_at.to_s == scanned_file.last_changed_at.to_s
+
+        if changed
+          scanned_file.assign_attributes(
+            file_size: file_size,
+            last_changed_at: last_changed_at
+          )
+          scanned_file.save!
+        end
+
+        yielder << PeakFlowUtils::ErbInspector::FileInspector.new(
+          file_path: file_path,
+          root_path: root_path,
+          changed: changed
+        )
+      end
+    end
+  end
+end

data/app/services/peak_flow_utils/erb_inspector/file_inspector.rb

@@ -0,0 +1,137 @@
+class PeakFlowUtils::ErbInspector::FileInspector
+  JS_FILE_EXTS = [".coffee", ".coffee.erb", ".es6", ".es6.erb", ".js", ".js.erb"].freeze
+  METHOD_NAMES = %w[t controller_t helper_t].freeze
+  VALID_BEGINNING = '(^|\s+|\(|\{|\[|<%=\s*|I18n\.)'.freeze
+
+  attr_reader :root_path, :file_path
+
+  def initialize(args)
+    @args = args
+    @root_path = args[:root_path]
+    @file_path = args[:file_path]
+    @method_names ||= ["t"]
+  end
+
+  def translations
+    Enumerator.new do |yielder|
+      File.open(full_path, "r") do |fp|
+        extname = File.extname(full_path)
+        translations_found = []
+        line_no = 0
+
+        fp.each_line do |line|
+          line_no += 1
+          line = force_utf8(line)
+
+          if extname == ".liquid"
+            parse_content_liquid(line_no, line, translations_found, yielder)
+          elsif JS_FILE_EXTS.include?(extname)
+            parse_content_js(line_no, line, translations_found, yielder)
+          else
+            parse_content(line_no, line, translations_found, yielder)
+          end
+        end
+      end
+    end
+  end
+
+  def full_path
+    "#{@root_path}/#{@file_path}"
+  end
+
+  def basename
+    File.basename(@file_path).match(/\A(.+?)\./)[1]
+  end
+
+  def changed?
+    @args.fetch(:changed)
+  end
+
+  def to_s
+    "<PeakFlowUtils::ErbInspector::FileInspector file_path=\"#{@file_path}\">"
+  end
+
+  def inspect
+    to_s
+  end
+
+private
+
+  def parse_content_liquid(line_no, line, translations_found, yielder)
+    line.scan(/\"([^\"]+?)\"\s+\|\s+t\s*(\%}|\}\}|\|)/) do |match|
+      add_translation(line_no, "t", match[0], translations_found, yielder)
+    end
+
+    line.scan(/\'([^\']+?)\'\s+\|\s+t\s*(\%}|\}\}|\|)/) do |match|
+      add_translation(line_no, "t", match[0], translations_found, yielder)
+    end
+
+    line.scan(/\"([^\"]+?)\"\s+\|\s+val:\s*\"([^\"]+?)\"\s*,\s*(.+?)\s*\|\s+t\s*/) do |match|
+      add_translation(line_no, "t", match[0], translations_found, yielder)
+    end
+
+    line.scan(/'([^\"]+?)'\s+\|\s+val:\s*'([^\"]+?)'\s*,\s*(.+?)\s*\|\s+t\s*/) do |match|
+      add_translation(line_no, "t", match[0], translations_found, yielder)
+    end
+  end
+
+  def parse_content_js(line_no, line, translations_found, yielder)
+    line.scan(/\I18n\.t\('(.+?)'\)/) do |match|
+      add_translation(line_no, "I18n.t", match[0], translations_found, yielder)
+    end
+
+    line.scan(/\I18n\.t\("(.+?)"\)/) do |match|
+      add_translation(line_no, "I18n-js.t", match[0], translations_found, yielder)
+    end
+  end
+
+  def parse_content(line_no, line, translations_found, yielder)
+    METHOD_NAMES.each do |method_name|
+      if (last_method_match = line.match(/def\s+(.+?)(\(|\n|\r\n)/))
+        @last_method = last_method_match[1]
+      end
+
+      # 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 = PeakFlowUtils::ErbInspector::TranslationInspector.new(
+      last_method: @last_method,
+      root_path: @root_path,
+      file_path: @file_path,
+      line_no: line_no,
+      method: method,
+      key: key
+    )
+
+    return if translation_inspector.contains_interpolations?
+    return if translation_with_key_exists?(translations_found, translation_inspector.full_key)
+
+    yielder << translation_inspector
+    translations_found << translation_inspector
+  end
+
+  def force_utf8(string)
+    string.encode("UTF-8", "binary", invalid: :replace, undef: :replace, replace: "")
+  end
+
+  def translation_with_key_exists?(translations_found, translation_full_key)
+    translations_found.select { |t| t.full_key == translation_full_key }.any?
+  end
+end