rspeed 0.2.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27a64c0a7ba3f1c113bbdf8f060be44dad913a684d234663b342a537937ac7f2
-  data.tar.gz: 47d3a190302b361c6bb76279094a7c04982492e59d099d6acdbe92fcbd26d648
+  metadata.gz: 4a58e610b2982e8a8f81783f5704f0a136c971aa6df1a446cf32ce7a53485120
+  data.tar.gz: 41c88139eff91637c52cda59b1239ca1833aa0db886677d0a33c51564d500a19
 SHA512:
-  metadata.gz: ac35df999459a32e06989e84d0e703f52a61b896e3a68ef7993c6eaf70952dd05826dffdf36f01fe5843b3916e57b24112708cbcadd19b83eb018c990f2bda4c
-  data.tar.gz: '09feaa28dc6a306f8ba039bcfbf02b500450b6f117160a726f326daae76c9584524825ffd693a4f3a84a61cb181fef7c00216557ce04ccaea736f42d3e9370d8'
+  metadata.gz: 67b9c9d9334b315b9392bf7a52965bc1884ab67c96345abf3f037b185010b4de24f9b895cc306567f9cf07737786d7f58edc4ab14f0e45a26acef8acd525ed2f
+  data.tar.gz: e2771f90d265bbfc5ea3273c82aa467dee40b3f5cbfc40ac0c7501da4577664c28bd11b491a1568907775584490a36e3c4d5c1935cc375aca27ff8713e9b0b00

data/CHANGELOG.md

@@ -1,3 +1,34 @@
+## master
+
+- CSV dependency dropped;
+- Drops tmp key in favor of profile keys fetch;
+
+## v0.5.1
+
+#### Fix
+
+- Only pipe number 1 will warm up avoiding duplicated spec entries;
+
+## v0.5.0
+
+#### Fix
+
+- Add env `RSPEED_NAME` to specify the application name and avoid result conflicts between multiple runs;
+- No more depends on pipe sequence to generate ou aggregate the resul;
+- rake `rspeed:install`;
+
+#### Update
+
+- The result of the pipes are no more saved on Redis. It's now calculated based on result key `rspeed`;
+
+## v0.4.0
+
+- Now we make diff to discover removed and added examples;
+
+## v0.3.0
+
+- Removed and added files now is considered on run;
+
 ## v0.2.0
 
 - Splits specs by examples over files;

data/README.md

@@ -1,9 +1,10 @@
 # RSpeed
 
-[![Build Status](https://github.com/wbotelhos/rspeed/workflows/CI/badge.svg)](https://github.com/wbotelhos/rspeed/actions)
+[![CI](https://github.com/wbotelhos/rspeed/workflows/CI/badge.svg)](https://github.com/wbotelhos/rspeed/actions)
 [![Gem Version](https://badge.fury.io/rb/rspeed.svg)](https://badge.fury.io/rb/rspeed)
-[![Maintainability](https://api.codeclimate.com/v1/badges/cc5efe8b06bc1d5e9e8a/maintainability)](https://codeclimate.com/github/wbotelhos/rspeed/maintainability)
-[![Patreon](https://img.shields.io/badge/donate-%3C3-brightgreen.svg)](https://www.patreon.com/wbotelhos)
+[![Maintainability](https://api.codeclimate.com/v1/badges/f312587b4f126bb13e85/maintainability)](https://codeclimate.com/github/wbotelhos/rspeed/maintainability)
+[![Coverage](https://codecov.io/gh/wbotelhos/rspeed/branch/main/graph/badge.svg)](https://codecov.io/gh/wbotelhos/rspeed)
+[![Sponsor](https://img.shields.io/badge/sponsor-%3C3-green)](https://www.patreon.com/wbotelhos)
 
 RSpeed splits your specs to you run parallels tests.
 
@@ -25,19 +26,21 @@ rake rspeed:install
 
 ## Usage
 
-- `RSPEED`: Enables RSpeed
-- `RSPEED_PIPES`: Quantity of pipes
+- `RSPEED_NAME`: You app name to avoid data override
 - `RSPEED_PIPE`: Current pipe
+- `RSPEED_PIPES`: Quantity of pipes
+- `RSPEED_RESULT_KEY`: The key that keeps the final result of all pipes
+- `RSPEED`: Enables RSpeed
 
 ```sh
-RSPEED=true RSPEED_PIPES=3 RSPEED_PIPE=1 bundle exec rake rspeed:run
+RSPEED=true RSPEED_NAME=authorizy RSPEED_PIPE=1 RSPEED_PIPES=3 bundle exec rake rspeed:run
 ```
 
 ## How it Works
 
 ### First run
 
-1. Since we has no statistics on the first time, we run all specs and collect it;
+1. Since we have no statistics on the first time, we run all specs and collect it;
 
 ```json
 { "file": "./spec/models/1_spec.rb", "time": 0.01 }

data/lib/generators/rspeed/install_generator.rb

@@ -6,7 +6,7 @@ module RSpeed
 
     desc 'Creates RSpeed task'
 
-    def copy_initializer
+    def create_initializer
       copy_file 'lib/tasks/rspeed.rake', 'lib/tasks/rspeed.rake'
     end
   end

data/lib/rspeed.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
 module RSpeed
-  require 'csv'
-  require 'redis'
+  require 'rspeed/env'
+  require 'rspeed/extension'
+  require 'rspeed/logger'
+  require 'rspeed/observer'
+  require 'rspeed/redis'
+  require 'rspeed/runner'
+  require 'rspeed/splitter'
+  require 'rspeed/variable'
 end
-
-require 'rspeed/extension'
-require 'rspeed/observer'
-require 'rspeed/runner'
-require 'rspeed/splitter'

data/lib/rspeed/env.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RSpeed
+  module Env
+    module_function
+
+    def db
+      ENV['RSPEED_DB']&.to_i
+    end
+
+    def host
+      ENV['RSPEED_HOST']
+    end
+
+    def name
+      ENV['RSPEED_NAME']
+    end
+
+    def pipe
+      ENV.fetch('RSPEED_PIPE', 1).to_i
+    end
+
+    def pipes
+      ENV.fetch('RSPEED_PIPES', 1).to_i
+    end
+
+    def port
+      ENV['RSPEED_PORT']&.to_i
+    end
+
+    def result_key
+      ENV.fetch('RESPEED_RESULT_KEY', RSpeed::Variable.result)
+    end
+
+    def rspeed
+      ENV['RSPEED'] == 'true'
+    end
+  end
+end

data/lib/rspeed/extension.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
-if ENV['RSPEED'] == 'true'
-  require 'rspec/rails'
+if RSpeed::Env.rspeed
+  require 'rspec'
 
   RSpec.configure do |config|
     config.before(:suite) { RSpeed::Observer.before_suite }
     config.before { |example| RSpeed::Observer.before(example) }
     config.after { |example| RSpeed::Observer.after(example) }
+    config.after(:suite) { RSpeed::Observer.after_suite }
   end
 end

data/lib/rspeed/logger.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RSpeed
+  module Logger
+    module_function
+
+    def log(message)
+      puts(message)
+    end
+  end
+end

data/lib/rspeed/observer.rb

@@ -9,9 +9,21 @@ module RSpeed
       line_number = example.metadata[:line_number]
       spent_time  = example.clock.now - example.metadata[:start_at]
 
-      File.open('rspeed.csv', 'a') do |file|
-        file.write "#{spent_time},#{file_path}:#{line_number}\n"
-      end
+      json = { file: "#{file_path}:#{line_number}", time: spent_time }.to_json
+
+      RSpeed::Redis.client.lpush(RSpeed::Variable.profile, json)
+    end
+
+    def after_suite(splitter = ::RSpeed::Splitter.new)
+      RSpeed::Redis.set(RSpeed::Variable.pipe_name, true)
+
+      return unless RSpeed::Redis.specs_finished?
+
+      splitter.rename
+
+      RSpeed::Redis.clean
+
+      RSpeed::Logger.log('RSpeed finished.')
     end
 
     def before(example)
@@ -19,11 +31,14 @@ module RSpeed
     end
 
     def before_suite
-      truncate_csv_file
+      clean_profile
     end
 
-    def truncate_csv_file
-      File.open('rspeed.csv', 'w') { |file| file.truncate(0) }
+    def clean_profile
+      RSpeed::Logger.log('[RSpeed::Observer#clean_profile] Cleanning current flag and profile.')
+
+      RSpeed::Redis.destroy(RSpeed::Variable.pipe_name)
+      RSpeed::Redis.destroy(RSpeed::Variable.profile)
     end
   end
 end

data/lib/rspeed/redis.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RSpeed
+  module Redis
+    require 'redis'
+
+    module_function
+
+    def clean
+      RSpeed::Logger.log('[RSpeed::Redis#clean] Cleaning pipes and profiles.')
+
+      destroy(RSpeed::Variable::PIPES_PATTERN)
+      destroy(RSpeed::Variable::PROFILE_PATTERN)
+    end
+
+    def client
+      @client ||= ::Redis.new(db: RSpeed::Env.db, host: RSpeed::Env.host, port: RSpeed::Env.port)
+    end
+
+    def destroy(pattern = RSpeed::Variable::DEFAULT_PATTERN)
+      RSpeed::Logger.log(%([RSpeed::Redis#destroy] Destroying pattern "#{pattern}".))
+
+      keys(pattern).each { |key| client.del(key) }
+    end
+
+    def get(key)
+      client.get(key)
+    end
+
+    def keys(pattern = RSpeed::Variable::DEFAULT_PATTERN)
+      cursor = 0
+      result = []
+
+      loop do
+        cursor, results = client.scan(cursor, match: pattern)
+        result += results
+
+        break if cursor.to_i.zero?
+      end
+
+      result
+    end
+
+    def result?
+      keys(RSpeed::Env.result_key).any?
+    end
+
+    def set(key, value)
+      client.set(key, value)
+    end
+
+    def specs_finished?
+      (RSpeed::Redis.keys(RSpeed::Variable::PIPES_PATTERN).size == RSpeed::Env.pipes).tap do |boo|
+        RSpeed::Logger.log("[RSpeed::Redis#specs_finished?] Specs #{boo ? 'finished.' : 'not fineshed yet.'}")
+      end
+    end
+
+    def specs_initiated?
+      RSpeed::Redis.keys(RSpeed::Variable::PIPES_PATTERN).any?.tap do |boo|
+        RSpeed::Logger.log("[RSpeed::Redis#specs_initiated?] Specs #{boo ? 'initialized.' : 'not initialized yet.'}")
+      end
+    end
+  end
+end

data/lib/rspeed/runner.rb

@@ -4,25 +4,14 @@ module RSpeed
   module Runner
     module_function
 
-    def run(shell)
-      splitter = ::RSpeed::Splitter.new
-
-      if splitter.first_pipe?
-        # splitter.destroy "rspeed_*"
-        splitter.destroy 'rspeed_tmp'
+    def run(shell, splitter: ::RSpeed::Splitter.new)
+      if RSpeed::Redis.result? || splitter.first_pipe?
+        return shell.call(['bundle exec rspec', splitter.pipe_files].compact.join(' '))
       end
 
-      if splitter.result?
-        splitter.save if splitter.first_pipe?
-
-        files = splitter.get("rspeed_#{splitter.pipe}")[0]['files'].map { |item| item['file'] }.join(' ')
-      end
-
-      shell.call ['bundle exec rspec', files].compact.join(' ')
-
-      splitter.append
+      RSpeed::Logger.log("Pipe #{RSpeed::Env.pipe} skipped. Only Pipe 1 can warm.")
 
-      splitter.rename if splitter.last_pipe?
+      RSpeed::Observer.after_suite
     end
   end
 end

data/lib/rspeed/splitter.rb

@@ -2,89 +2,92 @@
 
 module RSpeed
   class Splitter
-    DEFAULT_PATTERN = 'rspeed_*'
+    require 'json'
 
-    def append(files = file_data)
-      files.each do |time, file|
-        redis.lpush 'rspeed_tmp', { file: file, time: time.to_f }.to_json
+    def initialize(specs_path: './spec/**/*_spec.rb')
+      @specs_path = specs_path
+    end
+
+    def actual_examples
+      @actual_examples ||= begin
+        [].tap do |examples|
+          Dir[@specs_path].sort.each do |file|
+            data     = File.open(file).read
+            lines    = data.split("\n")
+
+            lines&.each&.with_index do |item, index|
+              examples << "#{file}:#{index + 1}" if /^it/.match?(item.gsub(/\s+/, ''))
+            end
+          end
+
+          stream(:actual_examples, examples)
+        end
       end
     end
 
-    def destroy(pattern = DEFAULT_PATTERN)
-      keys(pattern).each { |key| redis.del key }
+    def append?
+      RSpeed::Redis.result? || first_pipe?
+    end
+
+    def append(items:, key:)
+      items.each { |item| redis.rpush(key, item) }
     end
 
     def diff
-      (actual_files + added_files).sort_by { |item| item[:time].to_f }.map do |item|
-        [item[:time], item[:file]]
-      end
+      actual_data = rspeed_data.select { |item| actual_examples.include?(item[:file]) }
+      added_data  = added_examples.map { |item| { file: item, time: 0 } }
+
+      removed_examples # called just for stream for now
+
+      actual_data + added_data
     end
 
     def first_pipe?
-      pipe == 1
+      RSpeed::Env.pipe == 1
     end
 
     def get(pattern)
       @get ||= begin
-        return redis.lrange(pattern, 0, -1) if %w[rspeed rspeed_tmp].include?(pattern)
-
-        keys(pattern).map { |key| JSON.parse redis.get(key) }
-      end
-    end
+        return redis.lrange(pattern, 0, -1) if [RSpeed::Variable.result].include?(pattern)
 
-    def keys(pattern = DEFAULT_PATTERN)
-      cursor = 0
-      result = []
-
-      loop do
-        cursor, results = redis.scan(cursor, match: pattern)
-        result += results
-
-        break if cursor.to_i.zero?
+        RSpeed::Redis.keys(pattern).map { |key| ::JSON.parse(redis.get(key)) }
       end
-
-      result
     end
 
-    def last_pipe?
-      pipe == pipes
+    def need_warm?
+      first_pipe? && !RSpeed::Redis.result?
     end
 
-    def pipe
-      ENV.fetch('RSPEED_PIPE') { 1 }.to_i
-    end
+    def pipe_files
+      return unless RSpeed::Redis.result?
 
-    def pipes
-      result? ? ENV.fetch('RSPEED_PIPES') { 1 }.to_i : 1
+      split[RSpeed::Variable.key(RSpeed::Env.pipe)][:files].map { |item| item[:file] }.join(' ')
     end
 
     def rename
-      redis.rename 'rspeed_tmp', 'rspeed'
-    end
+      RSpeed::Logger.log('[RSpeed::Splitter#consolidate] Consolidating profiles.')
 
-    def result?
-      !keys('rspeed').empty?
-    end
+      RSpeed::Redis.destroy(RSpeed::Env.result_key)
 
-    def save(data = rspeed_data)
-      split(data).each do |key, value|
-        redis.set key, value.to_json
-      end
+      append(
+        items: RSpeed::Redis.client.keys('rspeed_profile_*').map { |key| redis.lrange(key, 0, -1) },
+        key: RSpeed::Env.result_key
+      )
     end
 
-    def split(data)
+    def split(data = diff)
       json = {}
 
-      pipes.times do |index|
-        json["rspeed_#{index + 1}".to_sym] ||= []
-        json["rspeed_#{index + 1}".to_sym] = { total: 0, files: [], number: index + 1 }
+      RSpeed::Env.pipes.times do |index|
+        json[RSpeed::Variable.key(index + 1)] ||= []
+        json[RSpeed::Variable.key(index + 1)] = { total: 0, files: [], number: index + 1 }
       end
 
       sorted_data = data.sort_by { |item| item[:time] }.reverse
 
       sorted_data.each do |record|
         selected_pipe_data = json.min_by { |pipe| pipe[1][:total] }
-        selected_pipe      = json["rspeed_#{selected_pipe_data[1][:number]}".to_sym]
+        selected_pipe      = json[RSpeed::Variable.key(selected_pipe_data[1][:number])]
         time               = record[:time].to_f
 
         selected_pipe[:total] += time
@@ -96,44 +99,36 @@ module RSpeed
 
     private
 
-    def actual_files
-      rspeed_data.select { |item| actual_specs.include?(item[:file]) }
-    end
-
-    def actual_specs
-      Dir['./spec/**/*_spec.rb']
-    end
-
-    def added_files
-      added_specs.map { |item| { file: item, time: 0 } }
-    end
-
-    def added_specs
-      actual_specs - saved_specs
-    end
-
-    def file_data
-      CSV.read('rspeed.csv')
+    def added_examples
+      @added_examples ||= begin
+        (actual_examples - rspeed_examples).tap { |examples| stream(:added_examples, examples) }
+      end
     end
 
     def redis
-      @redis ||= ::Redis.new(db: ENV['RSPEED_DB'], host: ENV['RSPEED_HOST'], port: ENV.fetch('RSPEED_PORT') { 6379 })
+      @redis ||= ::RSpeed::Redis.client
     end
 
-    def removed_specs
-      saved_specs - actual_specs
+    def removed_examples
+      @removed_examples ||= begin
+        (rspeed_examples - actual_examples).tap { |examples| stream(:removed_examples, examples) }
+      end
     end
 
     def removed_time
-      removed_specs.map { |item| item[0].to_f }.sum
+      removed_examples.sum { |item| item[0].to_f }
     end
 
     def rspeed_data
-      get('rspeed').map { |item| JSON.parse item, symbolize_names: true }
+      @rspeed_data ||= get(RSpeed::Env.result_key).map { |item| JSON.parse(item, symbolize_names: true) }
     end
 
-    def saved_specs
+    def rspeed_examples
       rspeed_data.map { |item| item[:file] }
     end
+
+    def stream(type, data)
+      RSpeed::Logger.log("PIPE: #{RSpeed::Env.pipe} with #{type}: #{data}")
+    end
   end
 end