peak_flow_utils 0.0.1 → 0.1.6

data/app/services/peak_flow_utils/translations_parser_service.rb

@@ -0,0 +1,211 @@
+class PeakFlowUtils::TranslationsParserService < PeakFlowUtils::ApplicationService
+  attr_reader :db
+
+  def execute
+    PeakFlowUtils::DatabaseInitializerService.execute!
+
+    cache_translations_in_dir(Rails.root.join("config/locales"))
+    cache_translations_in_handlers
+
+    clean_up_not_found
+
+    ServicePattern::Response.new(success: true)
+  end
+
+  def with_transactioner
+    require "active-record-transactioner"
+
+    ActiveRecordTransactioner.new do |transactioner|
+      @transactioner = transactioner
+      yield
+    end
+  end
+
+  def self.database_path
+    @database_path ||= Rails.root.join("db/peak_flow_utils.sqlite3").to_s
+  end
+
+  def database_path
+    @database_path ||= self.class.database_path
+  end
+
+  def update_handlers
+    @handlers_found ||= {}
+
+    PeakFlowUtils::HandlersFinderService.execute!.each do |handler|
+      debug "Updating handler: #{handler.name}"
+      handler_model = PeakFlowUtils::Handler.find_or_initialize_by(identifier: handler.id)
+      handler_model.update!(name: handler.name)
+
+      @handlers_found[handler_model.id] = true
+
+      yield handler_model if block_given?
+    end
+  end
+
+  def update_groups_for_handler(handler_model)
+    @groups_found ||= {}
+    handler = handler_model.at_handler
+
+    handler.groups.each do |group|
+      debug "Updating group: #{group.name}"
+      group_model = PeakFlowUtils::Group.find_or_initialize_by(handler_id: handler_model.id, identifier: group.id)
+      group_model.update!(name: group.name)
+
+      @groups_found[group_model.id] = true
+
+      group_model.at_group = group
+      yield group_model if block_given?
+    end
+  end
+
+  def update_translations_for_group(handler_model, group_model)
+    group = group_model.at_group
+    @translation_keys_found ||= {}
+    @handler_translations_found ||= {}
+
+    group.translations.each do |translation|
+      debug "Updating translation: #{translation.key}"
+
+      translation_key = PeakFlowUtils::TranslationKey.find_or_create_by!(key: translation.key)
+
+      raise "KEY ERROR: #{translation_key.inspect}" unless translation_key.id.to_i.positive?
+
+      @translation_keys_found[translation_key.id] = true
+
+      handler_translation = PeakFlowUtils::HandlerText.find_or_initialize_by(
+        translation_key_id: translation_key.id,
+        handler_id: handler_model.id,
+        group_id: group_model.id
+      )
+      handler_translation.assign_attributes(
+        default: translation.default,
+        file_path: translation.file_path,
+        line_no: translation.line_no,
+        key_show: translation.key_show,
+        full_path: translation.full_path,
+        dir: translation.dir
+      )
+
+      if @transactioner && handler_translation.persisted?
+        @transactioner.save!(handler_translation)
+      else
+        handler_translation.save!
+      end
+
+      @handler_translations_found[handler_translation.id] = true
+    end
+  end
+
+private
+
+  def debug(message)
+    puts message.to_s if @debug # rubocop:disable Rails/Output
+  end
+
+  def execute_migrations
+    require "baza_migrations"
+
+    executor = BazaMigrations::MigrationsExecutor.new(db: @db)
+    executor.add_dir "#{File.dirname(__FILE__)}/../../db/baza_translations_migrations"
+    executor.execute_migrations
+  end
+
+  def cache_translations_in_handlers
+    with_transactioner do
+      update_handlers do |handler_model|
+        update_groups_for_handler(handler_model) do |group_model|
+          update_translations_for_group(handler_model, group_model)
+        end
+      end
+    end
+  end
+
+  def cache_translations_in_dir(dir_path)
+    debug "Looking for translations in #{dir_path}"
+    @translation_values_found ||= {}
+
+    Dir.foreach(dir_path) do |file|
+      next if file == "." || file == ".."
+
+      full_path = "#{dir_path}/#{file}"
+
+      if File.directory?(full_path)
+        cache_translations_in_dir(full_path)
+      elsif File.extname(full_path) == ".yml"
+        cache_translations_in_file(full_path)
+      end
+    end
+  end
+
+  def cache_translations_in_file(file_path)
+    @translation_keys_found ||= {}
+
+    debug "Cache translations in #{file_path}"
+
+    i18n_hash = YAML.load_file(file_path)
+    debug "Hash: #{i18n_hash}"
+
+    i18n_hash.each do |locale, translations|
+      cache_translations_in_hash(file_path, locale, translations)
+    end
+
+    debug "Done caching translations in #{file_path}"
+  end
+
+  def cache_translations_in_hash(file_path, locale, i18n_hash, keys = [])
+    i18n_hash.each do |key, value|
+      current_key = keys.clone
+      current_key << key
+
+      if value.is_a?(Hash)
+        debug "Found new hash: #{current_key.join(".")}"
+        cache_translations_in_hash(file_path, locale, value, current_key)
+      else
+        debug "Found new key: #{current_key.join(".")} translated to #{value}"
+
+        key = current_key.join(".")
+
+        translation_key = PeakFlowUtils::TranslationKey.find_or_create_by!(key: key)
+        @translation_keys_found[translation_key.id] = true
+        raise "KEY ERROR: #{translation_key.inspect}" unless translation_key.id.to_i.positive?
+
+        translation_value = PeakFlowUtils::TranslationValue.find_or_initialize_by(
+          translation_key_id: translation_key.id,
+          locale: locale,
+          file_path: file_path
+        )
+        translation_value.assign_attributes(value: value)
+        translation_value.save!
+
+        @translation_values_found[translation_value.id] = true
+      end
+    end
+  end
+
+  def clean_up_not_found
+    debug "Cleaning up not found"
+
+    PeakFlowUtils::ApplicationRecord.transaction do
+      PeakFlowUtils::Handler
+        .where.not(id: @handlers_found.keys)
+        .destroy_all
+
+      PeakFlowUtils::HandlerText
+        .where.not(id: @handler_translations_found.keys)
+        .destroy_all
+
+      PeakFlowUtils::Group
+        .where.not(id: @groups_found.keys)
+        .destroy_all
+
+      PeakFlowUtils::TranslationKey
+        .where.not(id: @translation_keys_found.keys)
+        .destroy_all
+
+      PeakFlowUtils::TranslationValue
+        .where.not(id: @translation_values_found.keys)
+        .destroy_all
+    end
+  end
+end

data/app/views/layouts/peak_flow_utils/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Peak flow utils</title>
+  <%= stylesheet_link_tag    "peak_flow_utils/application", media: "all" %>
+  <%= javascript_include_tag "peak_flow_utils/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/bin/peak_flow_rspec_files

@@ -13,7 +13,9 @@ end
 
 rspec_helper = PeakFlowUtils::RspecHelper.new(
   groups: args.fetch("groups").to_i,
-  group_number: args.fetch("group-number").to_i
+  group_number: args.fetch("group-number").to_i,
+  only_types: args["only-types"]&.split(","),
+  tags: args["tags"]&.split(",")
 )
 
-print rspec_helper.group_files.join(" ")
+print rspec_helper.group_files.map { |group_file| group_file.fetch(:path) }.join(" ")

data/config/routes.rb

@@ -0,0 +1,2 @@
+PeakFlowUtils::Engine.routes.draw do
+end

data/lib/peak_flow_utils.rb

@@ -1,3 +1,11 @@
-class PeakFlowUtils
-  autoload :RspecHelper, "#{File.dirname(__FILE__)}/peak_flow_utils/rspec_helper"
+require_relative "peak_flow_utils/engine"
+
+require "array_enumerator"
+require "service_pattern"
+
+module PeakFlowUtils
+  path = "#{File.dirname(__FILE__)}/peak_flow_utils"
+
+  autoload :RspecHelper, "#{path}/rspec_helper"
+  autoload :HandlerHelper, "#{path}/handler_helper"
 end

data/lib/peak_flow_utils/engine.rb

@@ -0,0 +1,7 @@
+require "rails"
+
+module PeakFlowUtils; end
+
+class PeakFlowUtils::Engine < ::Rails::Engine
+  isolate_namespace PeakFlowUtils
+end

data/lib/peak_flow_utils/handler_helper.rb

@@ -0,0 +1,39 @@
+class PeakFlowUtils::HandlerHelper
+  delegate :translations, to: :instance
+
+  def self.find(id)
+    PeakFlowUtils::HandlersFinderService.execute!.each do |handler|
+      return handler if handler.id == id.to_s
+    end
+
+    raise ActiveRecord::RecordNotFound, "Handlers not found: '#{id}'."
+  end
+
+  def initialize(data)
+    @data = data
+  end
+
+  def id
+    @data.fetch(:id)
+  end
+
+  def to_param
+    id
+  end
+
+  def name
+    @data.fetch(:name)
+  end
+
+  def const
+    PeakFlowUtils.const_get(@data.fetch(:const_name))
+  end
+
+  def instance
+    const.new
+  end
+
+  def groups
+    const.new.groups
+  end
+end

data/lib/peak_flow_utils/rspec_helper.rb

@@ -1,54 +1,191 @@
 class PeakFlowUtils::RspecHelper
-  def initialize(args)
-    @groups = args.fetch(:groups)
-    @group_number = args.fetch(:group_number)
+  attr_reader :only_types, :tags
+
+  def initialize(groups:, group_number:, only_types: nil, tags: nil)
+    @groups = groups
+    @group_number = group_number
+    @example_data_exists = File.exist?("spec/examples.txt")
+    @only_types = only_types
+    @tags = tags
+  end
+
+  def example_data_exists?
+    @example_data_exists
+  end
+
+  def example_data
+    @example_data ||= begin
+      raw_data = File.read("spec/examples.txt")
+
+      result = []
+      raw_data.scan(/^\.\/(.+)\[(.+?)\]\s+\|\s+(.+?)\s+\|\s+((.+?) seconds|)\s+\|$/) do |match|
+        file_path = match[0]
+        spec_result = match[1]
+        seconds = match[4]&.to_f
+
+        spec_data = {
+          file_path: file_path,
+          spec_result: spec_result,
+          seconds: seconds
+        }
+
+        result << spec_data
+      end
+
+      result
+    end
+  end
+
+  def example_files
+    @example_files ||= begin
+      files = {}
+      example_data.each do |spec_data|
+        file_path = spec_data.fetch(:file_path)
+        seconds = spec_data.fetch(:seconds)
+
+        files[file_path] ||= {examples: 0, seconds: 0.0}
+        files[file_path][:examples] += 1
+        files[file_path][:seconds] += seconds if seconds
+      end
+
+      files
+    end
+  end
+
+  def example_file(path)
+    example_files[path]
   end
 
   def group_files
     return @group_files if @group_files
 
     # Sort them so that they are sorted by file path in three groups so each group have an equal amount of controller specs, features specs and so on
-    group_orders = []
-    @groups.times do
-      group_orders << []
+
+    sorted_files.each do |file|
+      file_path = file.fetch(:path)
+      file_data = example_file(file_path) if example_data_exists?
+
+      if file_data
+        examples = file_data.fetch(:examples)
+        seconds = file_data.fetch(:seconds)
+      else
+        examples = file.fetch(:examples)
+      end
+
+      group = group_with_least
+      group[:examples] += examples
+      group[:files] << file
+      group[:seconds] += seconds if seconds
     end
 
-    group_index = 0
-    files.sort.each do |file|
-      group_orders[group_index] << file
-      group_index += 1
-      group_index = 0 if group_index >= group_orders.length
+    @group_files = group_orders[@group_number - 1].fetch(:files)
+  end
+
+  def group_orders
+    @group_orders ||= begin
+      group_orders = []
+      @groups.times do
+        group_orders << {
+          examples: 0,
+          files: [],
+          seconds: 0.0
+        }
+      end
+      group_orders
     end
+  end
 
-    @group_files = group_orders[@group_number - 1]
+  def group_with_least
+    group_orders.min do |group1, group2|
+      if example_data_exists? && group1.fetch(:seconds) != 0.0 && group2.fetch(:seconds) != 0.0
+        group1.fetch(:seconds) <=> group2.fetch(:seconds)
+      else
+        group1.fetch(:examples) <=> group2.fetch(:examples)
+      end
+    end
   end
 
-  def total_tests
-    files unless @total_tests
-    @total_tests
+  def sorted_files
+    files.values.sort do |file1, file2|
+      file1_path = file1.fetch(:path)
+      file2_path = file2.fetch(:path)
+
+      file1_data = example_file(file1_path) if example_data_exists?
+      file2_data = example_file(file2_path) if example_data_exists?
+
+      if file1_data && file2_data && file1_data.fetch(:seconds) != 0.0 && file2_data.fetch(:seconds) != 0.0
+        value1 = file1_data[:seconds]
+      else
+        value1 = file1.fetch(:points)
+      end
+
+      if file2_data && file2_data && file2_data.fetch(:seconds) != 0.0 && file2_data.fetch(:seconds) != 0.0
+        value2 = file2_data[:seconds]
+      else
+        value2 = file2.fetch(:points)
+      end
+
+      value2 <=> value1
+    end
   end
 
 private
 
+  def dry_result_command
+    command = "bundle exec rspec --dry-run --format json"
+
+    tags&.each do |tag|
+      command << " --tag #{tag}"
+    end
+
+    command
+  end
+
   def dry_result
     require "json"
-    @dry_result ||= ::JSON.parse(`bundle exec rspec --dry-run --format json`)
+    @dry_result ||= ::JSON.parse(`#{dry_result_command}`)
+  end
+
+  def dry_file(path)
+    files.fetch(path)
   end
 
   def files
-    return @files if @files
+    @files ||= begin
+      result = {}
+      dry_result.fetch("examples").each do |example|
+        file_path = example.fetch("file_path")
+        file_path = file_path[2, file_path.length]
+        type = type_from_path(file_path)
+        points = points_from_type(type)
 
-    @total_tests = 0
+        next if ignore_type?(type)
 
-    @files = []
-    dry_result.fetch("examples").each do |example|
-      file_path = example.fetch("file_path")
-      file_path = file_path[2, file_path.length]
+        result[file_path] = {examples: 0, path: file_path, points: 0, type: type} unless result.key?(file_path)
+        result[file_path][:examples] += 1
+        result[file_path][:points] += points
+      end
 
-      @files << file_path unless @files.include?(file_path)
-      @total_tests += 1
+      result
     end
+  end
 
-    @files
+  def ignore_type?(type)
+    only_types && !only_types.include?(type)
+  end
+
+  def type_from_path(file_path)
+    match = file_path.match(/^spec\/(.+?)\//)
+    match[1] if match
+  end
+
+  def points_from_type(type)
+    if type == "feature" || type == "system"
+      10
+    elsif type == "controllers"
+      3
+    else
+      1
+    end
   end
 end