rspeed 0.5.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a58e610b2982e8a8f81783f5704f0a136c971aa6df1a446cf32ce7a53485120
-  data.tar.gz: 41c88139eff91637c52cda59b1239ca1833aa0db886677d0a33c51564d500a19
+  metadata.gz: 5b8a143543e9f44b4c5641d60642968b7cc4a7ec85953b17f6ef62743e66196e
+  data.tar.gz: f8fc781825804fe67084c08b05164ca8a31fc87e458952ba0ca86e567576e669
 SHA512:
-  metadata.gz: 67b9c9d9334b315b9392bf7a52965bc1884ab67c96345abf3f037b185010b4de24f9b895cc306567f9cf07737786d7f58edc4ab14f0e45a26acef8acd525ed2f
-  data.tar.gz: e2771f90d265bbfc5ea3273c82aa467dee40b3f5cbfc40ac0c7501da4577664c28bd11b491a1568907775584490a36e3c4d5c1935cc375aca27ff8713e9b0b00
+  metadata.gz: 7b50821b549363010ab566dd5f654a5b2b042e76fd696054b795126b1343ec3a8d73ed1c3a7a08cb63f1eeba38dbbae8922877bb8ec8649bb4601577b75737b0
+  data.tar.gz: 0f74bea31bf0c550ce6f89b8f22e8c0fedb59acfebe6cddf1dc4fc4499b74e7e73505b4a24327948f1330d9ff46b16f70de0855b4178a452149b33d2b5396051

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 ## 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;
 

data/README.md

@@ -26,14 +26,14 @@ rake rspeed:install
 
 ## Usage
 
-- `RSPEED_NAME`: You app name to avoid data override
+- `RSPEED_APP`: 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_SPEC_PATH`: The specs folders path
 - `RSPEED`: Enables RSpeed
 
 ```sh
-RSPEED=true RSPEED_NAME=authorizy RSPEED_PIPE=1 RSPEED_PIPES=3 bundle exec rake rspeed:run
+RSPEED=true RSPEED_APP=blog RSPEED_PIPE=1 RSPEED_PIPES=3 bundle exec rake rspeed:run
 ```
 
 ## How it Works

data/lib/rspeed.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module RSpeed
+  require 'rspeed/database'
   require 'rspeed/env'
   require 'rspeed/extension'
   require 'rspeed/logger'

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

@@ -4,6 +4,10 @@ module RSpeed
   module Env
     module_function
 
+    def app
+      ENV['RSPEED_APP']
+    end
+
     def db
       ENV['RSPEED_DB']&.to_i
     end
@@ -12,10 +16,6 @@ module RSpeed
       ENV['RSPEED_HOST']
     end
 
-    def name
-      ENV['RSPEED_NAME']
-    end
-
     def pipe
       ENV.fetch('RSPEED_PIPE', 1).to_i
     end
@@ -28,12 +28,12 @@ module RSpeed
       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 spec_path
+      ENV.fetch('RSPEED_SPEC_PATH', './spec/**/*spec.rb')
+    end
   end
 end

data/lib/rspeed/logger.rb

@@ -4,8 +4,10 @@ module RSpeed
   module Logger
     module_function
 
-    def log(message)
-      puts(message)
+    def log(context, method, message)
+      clazz = context.ancestors.join('::')
+
+      puts("[#{clazz}##{method}.#{RSpeed::Env.pipe}] #{message}")
     end
   end
 end

data/lib/rspeed/observer.rb

@@ -11,19 +11,19 @@ module RSpeed
 
       json = { file: "#{file_path}:#{line_number}", time: spent_time }.to_json
 
-      RSpeed::Redis.client.lpush(RSpeed::Variable.profile, json)
+      RSpeed::Redis.client.rpush(RSpeed::Variable.profile, json)
     end
 
-    def after_suite(splitter = ::RSpeed::Splitter.new)
-      RSpeed::Redis.set(RSpeed::Variable.pipe_name, true)
+    def after_suite
+      RSpeed::Redis.set(RSpeed::Variable.pipe, true)
 
       return unless RSpeed::Redis.specs_finished?
 
-      splitter.rename
+      RSpeed::Splitter.consolidate
 
       RSpeed::Redis.clean
 
-      RSpeed::Logger.log('RSpeed finished.')
+      RSpeed::Logger.log(self, __method__, 'RSpeed finished.')
     end
 
     def before(example)
@@ -35,10 +35,10 @@ module RSpeed
     end
 
     def clean_profile
-      RSpeed::Logger.log('[RSpeed::Observer#clean_profile] Cleanning current flag and profile.')
+      RSpeed::Logger.log(self, __method__, 'Cleanning current flag and profile.')
 
-      RSpeed::Redis.destroy(RSpeed::Variable.pipe_name)
-      RSpeed::Redis.destroy(RSpeed::Variable.profile)
+      RSpeed::Redis.destroy(pattern: RSpeed::Variable.pipe)
+      RSpeed::Redis.destroy(pattern: RSpeed::Variable.profile)
     end
   end
 end

data/lib/rspeed/redis.rb

@@ -7,27 +7,27 @@ module RSpeed
     module_function
 
     def clean
-      RSpeed::Logger.log('[RSpeed::Redis#clean] Cleaning pipes and profiles.')
+      RSpeed::Logger.log(self, __method__, 'Cleaning pipes and profiles.')
 
-      destroy(RSpeed::Variable::PIPES_PATTERN)
-      destroy(RSpeed::Variable::PROFILE_PATTERN)
+      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::Variable::DEFAULT_PATTERN)
-      RSpeed::Logger.log(%([RSpeed::Redis#destroy] Destroying pattern "#{pattern}".))
+    def destroy(pattern:)
+      RSpeed::Logger.log(self, __method__, %(Destroying pattern "#{pattern}".))
 
-      keys(pattern).each { |key| client.del(key) }
+      keys(pattern: pattern).each { |key| client.del(key) }
     end
 
     def get(key)
       client.get(key)
     end
 
-    def keys(pattern = RSpeed::Variable::DEFAULT_PATTERN)
+    def keys(pattern:)
       cursor = 0
       result = []
 
@@ -41,8 +41,16 @@ module RSpeed
       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(RSpeed::Env.result_key).any?
+      keys(pattern: RSpeed::Variable.result).any?
     end
 
     def set(key, value)
@@ -50,14 +58,14 @@ module RSpeed
     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.'}")
+      (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(RSpeed::Variable::PIPES_PATTERN).any?.tap do |boo|
-        RSpeed::Logger.log("[RSpeed::Redis#specs_initiated?] Specs #{boo ? 'initialized.' : 'not initialized yet.'}")
+      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

data/lib/rspeed/runner.rb

@@ -4,12 +4,12 @@ module RSpeed
   module Runner
     module_function
 
-    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(' '))
+    def run(shell)
+      if RSpeed::Redis.result? || RSpeed::Splitter.first_pipe?
+        return shell.call(['bundle exec rspec', RSpeed::Splitter.pipe_files].compact.join(' '))
       end
 
-      RSpeed::Logger.log("Pipe #{RSpeed::Env.pipe} skipped. Only Pipe 1 can warm.")
+      RSpeed::Logger.log(self, __method__, "Skipped! Only Pipe 1 can warm.")
 
       RSpeed::Observer.after_suite
     end

data/lib/rspeed/splitter.rb

@@ -1,59 +1,29 @@
 # frozen_string_literal: true
 
 module RSpeed
-  class Splitter
-    require '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
+  module Splitter
+    module_function
 
-          stream(:actual_examples, examples)
-        end
-      end
-    end
+    require 'json'
 
-    def append?
-      RSpeed::Redis.result? || first_pipe?
-    end
+    require 'rspeed/differ'
 
     def append(items:, key:)
-      items.each { |item| redis.rpush(key, item) }
+      items.each { |item| RSpeed::Redis.client.rpush(key, item) }
     end
 
-    def diff
-      actual_data = rspeed_data.select { |item| actual_examples.include?(item[:file]) }
-      added_data  = added_examples.map { |item| { file: item, time: 0 } }
+    def consolidate
+      RSpeed::Logger.log(self, __method__, 'Consolidating profiles.')
 
-      removed_examples # called just for stream for now
+      RSpeed::Redis.destroy(pattern: RSpeed::Variable.result)
 
-      actual_data + added_data
+      append(items: RSpeed::Redis.profiles_content, key: RSpeed::Variable.result)
     end
 
     def first_pipe?
       RSpeed::Env.pipe == 1
     end
 
-    def get(pattern)
-      @get ||= begin
-        return redis.lrange(pattern, 0, -1) if [RSpeed::Variable.result].include?(pattern)
-
-        RSpeed::Redis.keys(pattern).map { |key| ::JSON.parse(redis.get(key)) }
-      end
-    end
-
     def need_warm?
       first_pipe? && !RSpeed::Redis.result?
     end
@@ -61,21 +31,12 @@ module RSpeed
     def pipe_files
       return unless RSpeed::Redis.result?
 
-      split[RSpeed::Variable.key(RSpeed::Env.pipe)][:files].map { |item| item[:file] }.join(' ')
-    end
-
-    def rename
-      RSpeed::Logger.log('[RSpeed::Splitter#consolidate] Consolidating profiles.')
+      splitted = split(data: RSpeed::Differ.diff)
 
-      RSpeed::Redis.destroy(RSpeed::Env.result_key)
-
-      append(
-        items: RSpeed::Redis.client.keys('rspeed_profile_*').map { |key| redis.lrange(key, 0, -1) },
-        key: RSpeed::Env.result_key
-      )
+      splitted[RSpeed::Variable.key(RSpeed::Env.pipe)][:files].map { |item| item[:file] }.join(' ')
     end
 
-    def split(data = diff)
+    def split(data:)
       json = {}
 
       RSpeed::Env.pipes.times do |index|
@@ -96,39 +57,5 @@ module RSpeed
 
       json
     end
-
-    private
-
-    def added_examples
-      @added_examples ||= begin
-        (actual_examples - rspeed_examples).tap { |examples| stream(:added_examples, examples) }
-      end
-    end
-
-    def redis
-      @redis ||= ::RSpeed::Redis.client
-    end
-
-    def removed_examples
-      @removed_examples ||= begin
-        (rspeed_examples - actual_examples).tap { |examples| stream(:removed_examples, examples) }
-      end
-    end
-
-    def removed_time
-      removed_examples.sum { |item| item[0].to_f }
-    end
-
-    def rspeed_data
-      @rspeed_data ||= get(RSpeed::Env.result_key).map { |item| JSON.parse(item, symbolize_names: true) }
-    end
-
-    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