peak_flow_utils 0.0.1 → 0.1.6

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

@@ -0,0 +1,100 @@
+class PeakFlowUtils::ErbInspector::TranslationInspector
+  attr_reader :dir, :file_path, :last_method, :line_no, :method, :key, :full_key, :full_path, :root_path
+
+  def initialize(args)
+    @file_path = args[:file_path]
+    @full_path = args[:full_path]
+    @line_no = args[:line_no]
+    @method = args[:method]
+    @key = args[:key]
+    @root_path = args[:root_path]
+    @last_method = args[:last_method]
+
+    @full_path = "#{@root_path}/#{@file_path}"
+
+    generate_full_key
+    generate_dir
+  end
+
+  def model
+    PeakFlowUtils::TranslationService.new(
+      key: @full_key,
+      dir: @dir,
+      full_path: @full_path,
+      file_path: @file_path,
+      line_no: @line_no
+    )
+  end
+
+  def global?
+    !relative? && !key.include?(".")
+  end
+
+  def relative?
+    key.start_with?(".")
+  end
+
+  def contains_interpolations?
+    key =~ /#\{(.+?)\}/
+  end
+
+private
+
+  def generate_full_key
+    if (@method == "t" || @method == "helper_t" || @method == "controller_t" || @method == "I18n-js.t") && @key.start_with?(".")
+      @full_key = File.dirname(@file_path).to_s
+
+      if @full_key.starts_with?("app/mailers")
+        @full_key.gsub!(/\Aapp\/mailers(\/|)/, "")
+        is_mailer = true
+      elsif @full_key.start_with?("app/views/")
+        # Remove "app/views" from view-translations since that doesn't get used in keys.
+        @full_key.gsub!(/\Aapp\/views\//, "")
+      elsif @full_key.start_with?("app/controllers")
+        # Remove "app/controllers" from controller-translations since that doesn't get used in keys.
+        @full_key.gsub!(/\Aapp\/controllers(\/?)/, "")
+        is_controller = true
+      elsif @full_key.start_with?("app/cells")
+        @full_key.gsub!(/\Aapp\/cells\//, "")
+      elsif @full_key.start_with?("app/")
+        # Remove "app" from controller- and helper-translations since that doesn't get used.
+        @full_key.gsub!(/\Aapp\//, "")
+      end
+
+      @full_key.tr!("/", ".")
+      @full_key << "." unless @full_key.empty?
+      @full_key << file_key(@file_path)
+      @full_key << ".#{@last_method}" if (is_mailer || is_controller) && @last_method && @method != "controller_t"
+      @full_key << "."
+      @full_key << @key.gsub(/\A\./, "")
+    elsif @method == "I18n-js.t" || @method == "t" || @method == "helper_t" || @method == "controller_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_/, "")
+
+    # Remove '_controller' from controllers
+    key = key.gsub(/_controller\Z/, "")
+
+    key
+  end
+
+  def generate_dir
+    parts = %w[config locales awesome_translations]
+
+    key_parts = @full_key.split(".").reject(&:blank?)
+    key_parts.pop
+
+    @dir = Rails.root.join(*(parts + key_parts)).to_s
+  end
+end

data/app/services/peak_flow_utils/group_service.rb

@@ -0,0 +1,50 @@
+class PeakFlowUtils::GroupService
+  attr_reader :handler, :id, :data
+
+  def self.find_by_handler_and_id(handler, id)
+    handler.groups.each do |group|
+      return group if group.id == id.to_s
+    end
+
+    raise ActiveRecord::RecordNotFound, "Group not found by handler and ID: '#{handler.name}', '#{id}'."
+  end
+
+  def initialize(args)
+    @handler = args.fetch(:handler)
+    @id = args.fetch(:id)
+    @data = args[:data] || {}
+    raise "Invalid ID: #{@id}" if @id.blank?
+  end
+
+  def translations(args = {})
+    translations_list = @handler.translations_for_group(self)
+
+    args.each do |key, value|
+      if key == :finished
+        translations_list = translations_list.select(&:finished?) if value
+      elsif key == :unfinished
+        translations_list = translations_list.select(&:unfinished?) if value
+      else
+        raise "Unknown key: #{key}"
+      end
+    end
+
+    translations_list
+  end
+
+  def to_param
+    id
+  end
+
+  def name
+    @data[:name].presence || id.presence
+  end
+
+  def to_s
+    "<PeakFlowUtils::GroupService id=\"#{@id}\" name=\"#{name}\">"
+  end
+
+  def inspect
+    to_s
+  end
+end

data/app/services/peak_flow_utils/handlers_finder_service.rb

@@ -0,0 +1,25 @@
+class PeakFlowUtils::HandlersFinderService < PeakFlowUtils::ApplicationService
+  def execute
+    handlers = []
+
+    Dir.foreach("#{File.dirname(__FILE__)}/../../handlers/peak_flow_utils") do |file|
+      match = file.match(/\A(.+)_handler\.rb\Z/)
+      next unless match
+
+      const_name_snake = "#{match[1]}_handler"
+      next if const_name_snake == "application_handler"
+
+      const_name_camel = const_name_snake.camelize
+
+      handler = PeakFlowUtils::HandlerHelper.new(
+        id: const_name_snake,
+        const_name: const_name_camel,
+        name: const_name_camel
+      )
+
+      handlers << handler if handler.instance.enabled?
+    end
+
+    ServicePattern::Response.new(result: handlers)
+  end
+end

data/app/services/peak_flow_utils/model_inspector.rb

@@ -0,0 +1,133 @@
+class PeakFlowUtils::ModelInspector
+  attr_reader :clazz
+  cattr_accessor :models_loaded
+
+  # Yields a model-inspector for each model found in the application.
+  def self.model_classes
+    # Make sure all models are loaded.
+    load_models
+
+    @scanned = {}
+    @yielded = {}
+    @skip = ["ActiveRecord::SchemaMigration"]
+
+    ArrayEnumerator.new do |yielder|
+      find_subclasses(ActiveRecord::Base) do |model_inspector|
+        next if !model_inspector.clazz.name || @skip.include?(model_inspector.clazz.name)
+
+        yielder << model_inspector
+      end
+    end
+  end
+
+  def initialize(clazz)
+    @clazz = clazz
+  end
+
+  def attributes
+    ArrayEnumerator.new do |yielder|
+      @clazz.attribute_names.each do |attribute_name|
+        yielder << PeakFlowUtils::AttributeService.new(self, attribute_name)
+      end
+    end
+  end
+
+  def paperclip_attachments
+    return unless ::Kernel.const_defined?("Paperclip")
+
+    Paperclip::AttachmentRegistry.names_for(@clazz).each do |name|
+      yield name
+    end
+  end
+
+  def money_attributes
+    return if !::Kernel.const_defined?("Money") || !@clazz.respond_to?(:monetized_attributes)
+
+    @clazz.monetized_attributes.each do |attribute|
+      yield attribute[0].to_s
+    end
+  end
+
+  def globalize_attributes
+    return if !::Kernel.const_defined?("Globalize") || !@clazz.respond_to?(:translated_attribute_names)
+
+    @clazz.translated_attribute_names.each do |attribute|
+      yield attribute.to_s
+    end
+  end
+
+  def snake_name
+    clazz.name.gsub("::", "/").split("/").map(&:underscore).join("/")
+  end
+
+  def class_key
+    "activerecord.models.#{snake_name}"
+  end
+
+  def class_key_one
+    "#{class_key}.one"
+  end
+
+  def class_key_other
+    "#{class_key}.other"
+  end
+
+  # TODO: Maybe this should yield a ModelInspector::Relationship instead?
+  def relationships
+    @clazz.reflections.each do |key, reflection|
+      yield key, reflection
+    end
+  end
+
+  def attribute_key(attribute_name)
+    "activerecord.attributes.#{snake_name}.#{attribute_name}"
+  end
+
+  def to_s
+    "<PeakFlowUtils::ModelInspector class-name: \"#{@clazz.name}\">"
+  end
+
+  def inspect
+    to_s
+  end
+
+  def self.find_subclasses(clazz, &blk)
+    return if @scanned[clazz.name]
+
+    @scanned[clazz.name] = true
+
+    clazz.subclasses.each do |subclass|
+      blk.call ::PeakFlowUtils::ModelInspector.new(subclass)
+      find_subclasses(subclass, &blk)
+    end
+  end
+
+  # Preloads all models for Rails app and all engines (if they aren't loaded, then they cant be inspected).
+  def self.load_models
+    return false if PeakFlowUtils::ModelInspector.models_loaded
+
+    PeakFlowUtils::ModelInspector.models_loaded = true
+
+    load_models_for(Rails.root)
+    engines.each do |engine|
+      load_models_for(engine.root)
+    end
+
+    true
+  end
+
+  def self.engines
+    ::Rails::Engine.subclasses.map(&:instance)
+  end
+
+  # Loads models for the given app-directory (Rails-root or engine).
+  def self.load_models_for(root)
+    Dir.glob("#{root}/app/models/**/*.rb") do |model_path|
+      require model_path
+    rescue StandardError => e
+      warn "Could not load model in #{model_path}"
+      warn e.inspect
+      warn e.backtrace
+    end
+  end
+end

data/app/services/peak_flow_utils/translation_service.rb

@@ -0,0 +1,138 @@
+class PeakFlowUtils::TranslationService
+  attr_reader :default, :dir, :key, :key_show, :file_path, :line_no, :full_path
+
+  def initialize(data)
+    @data = data
+    @dir = data[:dir]
+    @file_path = data[:file_path]
+    @full_path = data[:full_path]
+    @line_no = data[:line_no]
+    @key = data[:key]
+    @key_show = data[:key_show]
+    @default = data[:default]
+
+    raise "Dir wasn't valid: '#{@dir}'." if @dir.blank?
+  end
+
+  def last_key
+    key.to_s.split(".").last
+  end
+
+  def key_show_with_fallback
+    @key_show.presence || last_key
+  end
+
+  def array_translation?
+    return true if /\[(\d+)\]\Z/.match?(@key)
+
+    false
+  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
+
+  def to_param
+    id
+  end
+
+  def name
+    key
+  end
+
+  def translated_values
+    result = []
+
+    I18n.available_locales.each do |locale|
+      next unless value_for?(locale)
+
+      result << AwesomeTranslations::TranslatedValue.new(
+        file: "#{dir}/#{locale}.yml",
+        key: @key,
+        locale: locale,
+        value: value(locale: locale)
+      )
+    end
+
+    result
+  end
+
+  def finished?
+    I18n.available_locales.each do |locale|
+      next if value_for?(locale)
+
+      return false
+    end
+
+    true
+  end
+
+  def translated_value_for_locale(locale)
+    AwesomeTranslations::TranslatedValue.new(
+      file: "#{dir}/#{locale}.yml",
+      key: @key,
+      locale: locale,
+      value: value_for?(locale) ? value(locale: locale) : ""
+    )
+  end
+
+  def value_for?(locale)
+    if array_translation?
+      I18n.with_locale(locale) { I18n.exists?(array_key) && I18n.t(array_key)[array_no].present? }
+    else
+      I18n.with_locale(locale) { I18n.exists?(@key) }
+    end
+  end
+
+  def value(args = {})
+    locale = (args[:locale] || I18n.locale || I18n.default_locale).to_sym
+
+    return nil unless value_for?(locale)
+
+    if array_translation?
+      I18n.with_locale(locale) { I18n.t(array_key)[array_no] }
+    else
+      I18n.with_locale(locale) { I18n.t(@key) }
+    end
+  end
+
+  def file_line_content?
+    return true if @full_path && @line_no && File.exist?(@full_path)
+
+    false
+  end
+
+  def file_line_content
+    count = 0
+
+    File.open(@full_path, "r") do |fp|
+      fp.each_line do |line|
+        count += 1
+        return line if count == @line_no
+      end
+    end
+
+    nil
+  end
+
+  def to_s
+    "<PeakFlowUtils::TranslationService " \
+      "key=\"#{@key}\" " \
+      "dir=\"#{@dir}\" " \
+      "array_translation?=\"#{array_translation?}\" " \
+      "array_key=\"#{array_key}\" " \
+      "array_no=\"#{array_no}\">"
+  end
+
+  def inspect
+    to_s
+  end
+end