rspeed 0.3.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19e3b06a0f6189661598a3db76e740b99b5ab658b3e08119fa6f8a74efb74552
-  data.tar.gz: 813bd8934d23e84bcb0facf56da0bf53c4017d5af03337989a42ffff2dac679d
+  metadata.gz: 5b8a143543e9f44b4c5641d60642968b7cc4a7ec85953b17f6ef62743e66196e
+  data.tar.gz: f8fc781825804fe67084c08b05164ca8a31fc87e458952ba0ca86e567576e669
 SHA512:
-  metadata.gz: '004081032114288e16f23c176ca49c03e85274ed6b91272144643452ec5f2a648c829dae5539c94215897f67482a6f0cf1e5253acabeafc6cdf5a6e2fe2681e9'
-  data.tar.gz: 2ec7f4991a5702f4bd24000e71eb5426969f0abd3a77cabd521887ad72dac3e3ec5f28f0165193ca806f8e9a9e8fce712ac9923f899c9e8767c8808320400ab4
+  metadata.gz: 7b50821b549363010ab566dd5f654a5b2b042e76fd696054b795126b1343ec3a8d73ed1c3a7a08cb63f1eeba38dbbae8922877bb8ec8649bb4601577b75737b0
+  data.tar.gz: 0f74bea31bf0c550ce6f89b8f22e8c0fedb59acfebe6cddf1dc4fc4499b74e7e73505b4a24327948f1330d9ff46b16f70de0855b4178a452149b33d2b5396051

data/CHANGELOG.md

@@ -1,3 +1,53 @@
+## master
+
+- None;
+
+## v0.6.0
+
+#### Break Change
+
+- Drops `RSPEED_RESULT_KEY` key in favor of `RSPEED_NAME`;
+- Renames env `RSPEED_NAME` to `RSPEED_APP`;
+
+#### News
+
+- Adds env `RSPEED_SPEC_PATH` to indicate the spec folders path;
+- Saves pipes and profiles with a zero at the beginning;
+- Makes sure examples is unique;
+
+## v0.5.2
+
+#### Fix
+
+- Avoid duplicate entries in the consolidated result;
+
+#### Update
+
+- 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;

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_APP`: You app name to avoid data override
 - `RSPEED_PIPE`: Current pipe
+- `RSPEED_PIPES`: Quantity of pipes
+- `RSPEED_SPEC_PATH`: The specs folders path
+- `RSPEED`: Enables RSpeed
 
 ```sh
-RSPEED=true RSPEED_PIPES=3 RSPEED_PIPE=1 bundle exec rake rspeed:run
+RSPEED=true RSPEED_APP=blog 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,13 @@
 # frozen_string_literal: true
 
 module RSpeed
-  require 'csv'
-  require 'redis'
+  require 'rspeed/database'
+  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/database.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RSpeed
+  module Database
+    module_function
+
+    def result
+      RSpeed::Redis.list(RSpeed::Variable.result).map { |item| JSON.parse(item, symbolize_names: true) }
+    end
+  end
+end

data/lib/rspeed/differ.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RSpeed
+  module Differ
+    module_function
+
+    def actual_files(spec_path: RSpeed::Env.spec_path)
+      [].tap do |data|
+        Dir[spec_path].sort.each do |file|
+          lines = File.open(file).read.split("\n")
+
+          lines&.each&.with_index do |item, index|
+            data << "#{file}:#{index + 1}" if /^it/.match?(item.gsub(/\s+/, ''))
+          end
+        end
+
+        RSpeed::Logger.log(self, __method__, data)
+      end
+    end
+
+    def actual_data(files:, result:)
+      result
+        .select { |item| files.include?(item[:file]) }
+        .tap { |data| RSpeed::Logger.log(self, __method__, data) }
+    end
+
+    def added_data(files:, result:)
+      (files - result.map { |item| item[:file] })
+        .map { |file| { file: file, time: 0 } }
+        .tap { |data| RSpeed::Logger.log(self, __method__, data) }
+    end
+
+    def diff
+      files  = actual_files
+      result = RSpeed::Database.result.uniq { |item| item[:file] }
+
+      removed_data(files: files, result: result) # called just for log purpose
+
+      (actual_data(files: files, result: result) + added_data(files: files, result: result))
+        .tap { |data| RSpeed::Logger.log(self, __method__, data) }
+    end
+
+    def removed_data(files:, result:)
+      result
+        .reject { |item| files.include?(item[:file]) }
+        .tap { |data| RSpeed::Logger.log(self, __method__, data) }
+    end
+
+    def removed_time(data:)
+      data
+        .sum { |item| item[:time].to_f }
+        .tap { |result| RSpeed::Logger.log(self, __method__, result) }
+    end
+  end
+end

data/lib/rspeed/env.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RSpeed
+  module Env
+    module_function
+
+    def app
+      ENV['RSPEED_APP']
+    end
+
+    def db
+      ENV['RSPEED_DB']&.to_i
+    end
+
+    def host
+      ENV['RSPEED_HOST']
+    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 rspeed
+      ENV['RSPEED'] == 'true'
+    end
+
+    def spec_path
+      ENV.fetch('RSPEED_SPEC_PATH', './spec/**/*spec.rb')
+    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,13 @@
+# frozen_string_literal: true
+
+module RSpeed
+  module Logger
+    module_function
+
+    def log(context, method, message)
+      clazz = context.ancestors.join('::')
+
+      puts("[#{clazz}##{method}.#{RSpeed::Env.pipe}] #{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.rpush(RSpeed::Variable.profile, json)
+    end
+
+    def after_suite
+      RSpeed::Redis.set(RSpeed::Variable.pipe, true)
+
+      return unless RSpeed::Redis.specs_finished?
+
+      RSpeed::Splitter.consolidate
+
+      RSpeed::Redis.clean
+
+      RSpeed::Logger.log(self, __method__, '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(self, __method__, 'Cleanning current flag and profile.')
+
+      RSpeed::Redis.destroy(pattern: RSpeed::Variable.pipe)
+      RSpeed::Redis.destroy(pattern: RSpeed::Variable.profile)
     end
   end
 end

data/lib/rspeed/redis.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RSpeed
+  module Redis
+    require 'redis'
+
+    module_function
+
+    def clean
+      RSpeed::Logger.log(self, __method__, 'Cleaning pipes and profiles.')
+
+      destroy(pattern: RSpeed::Variable::PIPES_PATTERN)
+      destroy(pattern: 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::Logger.log(self, __method__, %(Destroying pattern "#{pattern}".))
+
+      keys(pattern: pattern).each { |key| client.del(key) }
+    end
+
+    def get(key)
+      client.get(key)
+    end
+
+    def keys(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 list(key)
+      client.lrange(key, 0, -1)
+    end
+
+    def profiles_content(pattern: 'rspeed:profile_*')
+      client.keys(pattern).map { |key| list(key) }.flatten
+    end
+
+    def result?
+      keys(pattern: RSpeed::Variable.result).any?
+    end
+
+    def set(key, value)
+      client.set(key, value)
+    end
+
+    def specs_finished?
+      (RSpeed::Redis.keys(pattern: RSpeed::Variable::PIPES_PATTERN).size == RSpeed::Env.pipes).tap do |boo|
+        RSpeed::Logger.log(self, __method__, "Specs #{boo ? 'finished.' : 'not fineshed yet.'}")
+      end
+    end
+
+    def specs_initiated?
+      RSpeed::Redis.keys(pattern: RSpeed::Variable::PIPES_PATTERN).any?.tap do |boo|
+        RSpeed::Logger.log(self, __method__, "Specs #{boo ? 'initialized.' : 'not initialized yet.'}")
+      end
+    end
+  end
+end

data/lib/rspeed/runner.rb

@@ -5,24 +5,13 @@ module RSpeed
     module_function
 
     def run(shell)
-      splitter = ::RSpeed::Splitter.new
-
-      if splitter.first_pipe?
-        # splitter.destroy "rspeed_*"
-        splitter.destroy 'rspeed_tmp'
+      if RSpeed::Redis.result? || RSpeed::Splitter.first_pipe?
+        return shell.call(['bundle exec rspec', RSpeed::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(self, __method__, "Skipped! Only Pipe 1 can warm.")
 
-      splitter.rename if splitter.last_pipe?
+      RSpeed::Observer.after_suite
     end
   end
 end

data/lib/rspeed/splitter.rb

@@ -1,85 +1,54 @@
+# frozen_string_literal: true
 
 module RSpeed
-  class Splitter
-    DEFAULT_PATTERN = 'rspeed_*'
+  module Splitter
+    module_function
 
-    def append(files = file_data)
-      files.each do |time, file|
-        redis.lpush('rspeed_tmp', { file: file, time: time.to_f }.to_json)
-      end
-    end
+    require 'json'
 
-    def destroy(pattern = DEFAULT_PATTERN)
-      keys(pattern).each { |key| redis.del key }
-    end
+    require 'rspeed/differ'
 
-    def diff
-      actual_data + added_data
+    def append(items:, key:)
+      items.each { |item| RSpeed::Redis.client.rpush(key, item) }
     end
 
-    def first_pipe?
-      pipe == 1
-    end
+    def consolidate
+      RSpeed::Logger.log(self, __method__, 'Consolidating profiles.')
 
-    def get(pattern)
-      @get ||= begin
-        return redis.lrange(pattern, 0, -1) if %w[rspeed rspeed_tmp].include?(pattern)
+      RSpeed::Redis.destroy(pattern: RSpeed::Variable.result)
 
-        keys(pattern).map { |key| JSON.parse(redis.get(key)) }
-      end
+      append(items: RSpeed::Redis.profiles_content, key: RSpeed::Variable.result)
     end
 
-    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?
-      end
-
-      result
+    def first_pipe?
+      RSpeed::Env.pipe == 1
     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
-    end
-
-    def rename
-      redis.rename('rspeed_tmp', 'rspeed')
-    end
+      splitted = split(data: RSpeed::Differ.diff)
 
-    def result?
-      !keys('rspeed').empty?
+      splitted[RSpeed::Variable.key(RSpeed::Env.pipe)][:files].map { |item| item[:file] }.join(' ')
     end
 
-    def save(data = diff)
-      split(data).each { |key, value| redis.set(key, value.to_json) }
-    end
-
-    def split(data)
+    def split(data:)
       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
@@ -88,47 +57,5 @@ module RSpeed
 
       json
     end
-
-    private
-
-    def actual_data
-      rspeed_data.select { |item| actual_files.include?(item[:file]) }
-    end
-
-    def actual_files
-      @actual_files ||= Dir['./spec/**/*_spec.rb']
-    end
-
-    def added_data
-      added_specs.map { |item| { file: item, time: 0 } }
-    end
-
-    def added_specs
-      actual_files - old_files
-    end
-
-    def file_data
-      CSV.read('rspeed.csv')
-    end
-
-    def old_files
-      rspeed_data.map { |item| item[:file] }
-    end
-
-    def redis
-      @redis ||= ::Redis.new(db: ENV['RSPEED_DB'], host: ENV['RSPEED_HOST'], port: ENV.fetch('RSPEED_PORT') { 6379 })
-    end
-
-    def removed_specs
-      old_files - actual_files
-    end
-
-    def removed_time
-      removed_specs.map { |item| item[0].to_f }.sum
-    end
-
-    def rspeed_data
-      @rspeed_data ||= get('rspeed').map { |item| JSON.parse(item, symbolize_names: true) }
-    end
   end
 end