rspeed 0.1.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fa530fc36a8a38f31b2f241cb0c322bd268f0928cb5929f89d4b939e54b740a3
-  data.tar.gz: 4228e7997bd6d4b51da7aa66ef10ddc25474a184cd3c42d42afd6077db777f8d
+  metadata.gz: de6e5d6c3ca630b15b835939ec2b01adbeec526480efde16052c294f297457af
+  data.tar.gz: 4c4d1efdf65c9f4c01106f1fe109d8ffb2160e40b6f90813b4bdc813061613dc
 SHA512:
-  metadata.gz: ce7fa5fe6f56cdf9b3f9a02cc040a8180d21e3c5ad1c08bcc792df3ee336c300c6fd5d8438cef908815a896dc961a5743910a63686653c6fdc91707ec24b4a6b
-  data.tar.gz: ae309883ef9f2f63792644583c1b9277e8c290e84172b59e7eecb0a961015d48b9411a798a6514d6dd3855a3553ce4d31e420634514f37025f4023a4c181e133
+  metadata.gz: 5ab45f421853bee217c88cfad0efd5d2bd16b9968b17b7676593b4ae0a2e708ac6b646f40845b8f186adfc000c505cef4e95f77c7c8273e6964203b0de22420a
+  data.tar.gz: 7e32c34c76fcdaff18e2aa2726c232d42c32fb4e3fc55b452f0d9b62f2dff0e5f458acd4c3dbacae75b5ca0c330e4b2792618179675c11adcf8aa566d13106c9

data/CHANGELOG.md

@@ -1,3 +1,37 @@
+## master
+
+- None;
+
+## 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;
+
 ## v0.1.0
 
 - First release;

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,22 @@ 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_TMP_KEY`: The temporary key that keeps the partial result of the 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

@@ -2,9 +2,13 @@
 
 module RSpeed
   require 'csv'
-  require 'redis'
-end
 
-require 'rspeed/extension'
-require 'rspeed/runner'
-require 'rspeed/splitter'
+  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

data/lib/rspeed/env.rb

@@ -0,0 +1,43 @@
+# 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
+
+    def tmp_key
+      ENV.fetch('RESPEED_TMP_KEY', RSpeed::Variable.tmp)
+    end
+  end
+end

data/lib/rspeed/extension.rb

@@ -1,43 +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 do
-      File.open('rspeed.csv', 'w') { |file| file.truncate 0 }
-    end
-
-    config.before do |example|
-      example.update_inherited_metadata start_at: example.clock.now
-    end
-
-    config.after do |example|
-      file_path       = example.metadata[:file_path]
-      time_difference = example.clock.now - example.metadata[:start_at]
-
-      File.open('rspeed.csv', 'a') do |file|
-        file.write "#{time_difference},#{file_path}\n"
-      end
-    end
-
-    config.after :suite do |_example|
-      result = {}
-
-      CSV.read('rspeed.csv').each do |line|
-        result[line[1]] ||= 0
-        result[line[1]] += line[0].to_d
-      end
-
-      result = result.sort_by { |line| line[1] }.reverse
-
-      File.open('rspeed.csv', 'w') { |file| file.truncate 0 }
-
-      File.open('rspeed.csv', 'a') do |file|
-        result.each do |file_spec, time|
-          file.write "#{time},#{file_spec}\n"
-        end
-      end
-    end
+    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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RSpeed
+  module Observer
+    module_function
+
+    def after(example)
+      file_path   = example.metadata[:file_path]
+      line_number = example.metadata[:line_number]
+      spent_time  = example.clock.now - example.metadata[:start_at]
+
+      File.open(RSpeed::Variable::CSV, 'a') do |file|
+        file.write("#{spent_time},#{file_path}:#{line_number}\n")
+      end
+    end
+
+    def after_suite(splitter = ::RSpeed::Splitter.new)
+      RSpeed::Redis.set(RSpeed::Variable.pipe_name, true)
+
+      splitter.append if splitter.append?
+
+      return unless RSpeed::Redis.specs_finished?
+
+      splitter.rename
+
+      RSpeed::Redis.clean
+    end
+
+    def before(example)
+      example.update_inherited_metadata(start_at: example.clock.now)
+    end
+
+    def before_suite
+      truncate_csv_file
+
+      RSpeed::Redis.destroy(RSpeed::Variable.tmp) unless RSpeed::Redis.specs_initiated?
+    end
+
+    def truncate_csv_file
+      File.open(RSpeed::Variable::CSV, 'w') { |file| file.truncate(0) }
+    end
+  end
+end

data/lib/rspeed/redis.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RSpeed
+  module Redis
+    require 'redis'
+
+    module_function
+
+    def clean
+      destroy(RSpeed::Variable::PIPES_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)
+      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
+    end
+
+    def specs_initiated?
+      RSpeed::Redis.keys(RSpeed::Variable::PIPES_PATTERN).any?
+    end
+  end
+end

data/lib/rspeed/runner.rb

@@ -4,25 +4,12 @@ module RSpeed
   module Runner
     module_function
 
-    def run(shell)
-      splitter = ::RSpeed::Splitter.new
+    def run(shell, splitter: ::RSpeed::Splitter.new)
+      return shell.call(['bundle exec rspec', splitter.pipe_files].compact.join(' ')) if splitter.need_warm?
 
-      if splitter.first_pipe?
-        # splitter.destroy "rspeed_*"
-        splitter.destroy 'rspeed_tmp'
-      end
+      RSpeed::Logger.log("Pipe #{RSpeed::Env.pipe} skipped. Only Pipe 1 can warm.")
 
-      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
-
-      splitter.rename if splitter.last_pipe?
+      RSpeed::Observer.after_suite
     end
   end
 end

data/lib/rspeed/splitter.rb

@@ -2,87 +2,87 @@
 
 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
-      end
+    def initialize(specs_path: './spec/**/*_spec.rb')
+      @specs_path = specs_path
     end
 
-    def destroy(pattern = DEFAULT_PATTERN)
-      keys(pattern).each { |key| redis.del key }
-    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")
 
-    def diff
-      (actual_files + added_files).sort_by { |item| item[:time].to_f }.map do |item|
-        [item[:time], item[:file]]
+            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 first_pipe?
-      pipe == 1
+    def append?
+      RSpeed::Redis.result? || first_pipe?
     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) }
+    def append(files = CSV.read(RSpeed::Variable::CSV))
+      files.each do |time, file|
+        redis.lpush(RSpeed::Env.tmp_key, { file: file, time: time.to_f }.to_json)
       end
     end
 
-    def keys(pattern = DEFAULT_PATTERN)
-      cursor = 0
-      result = []
+    def diff
+      actual_data = rspeed_data.select { |item| actual_examples.include?(item[:file]) }
+      added_data  = added_examples.map { |item| { file: item, time: 0 } }
 
-      loop do
-        cursor, results = redis.scan(cursor, match: pattern)
-        result += results
+      removed_examples # called just for stream for now
 
-        break if cursor.to_i.zero?
-      end
-
-      result
+      actual_data + added_data
     end
 
-    def last_pipe?
-      pipe == pipes
+    def first_pipe?
+      RSpeed::Env.pipe == 1
     end
 
-    def pipe
-      ENV.fetch('RSPEED_PIPE') { 1 }.to_i
-    end
+    def get(pattern)
+      @get ||= begin
+        return redis.lrange(pattern, 0, -1) if [RSpeed::Variable.result, RSpeed::Variable.tmp].include?(pattern)
 
-    def pipes
-      result? ? ENV.fetch('RSPEED_PIPES') { 1 }.to_i : 1
+        RSpeed::Redis.keys(pattern).map { |key| ::JSON.parse(redis.get(key)) }
+      end
     end
 
-    def rename
-      redis.rename 'rspeed_tmp', 'rspeed'
+    def need_warm?
+      first_pipe? && !RSpeed::Redis.result?
     end
 
-    def result?
-      !keys('rspeed').empty?
+    def pipe_files
+      return unless RSpeed::Redis.result?
+
+      split[RSpeed::Variable.key(RSpeed::Env.pipe)][:files].map { |item| item[:file] }.join(' ')
     end
 
-    def save(data = rspeed_data)
-      split(data).each do |key, value|
-        redis.set key, value.to_json
-      end
+    def rename
+      redis.rename(RSpeed::Env.tmp_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
 
-      data.each do |record|
+      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
@@ -94,44 +94,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