test-prof 0.1.0.pre2 → 0.1.0.pre5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 528abbfd18c27537ab52c1bf580c73b4327fdbbc
-  data.tar.gz: dfaaa8adc9c93ec2ba4e562cf57ec3f4807ae489
+  metadata.gz: c9b58b9e9898a5b72c42700bfc0751c31639aefc
+  data.tar.gz: 4bf4799f92e06e8e9b3c000fe08659171cd2293d
 SHA512:
-  metadata.gz: db4e05c01a501eb9e9a50d8c4d1f857437ca7c14323c7a25e739736e1139c8201c87fbefcff91c84cf0932c475e9fc2f12006f3f7feb9d6d5068d23b492bdf61
-  data.tar.gz: 2ba7680b870ef1acf274cabb3fd0f4bdfc73558af1d3211e2808f2e99f7864c212212fce9c7ef6f68f78d55f7d5cba1ff44674273fdb6bedfce3c135c77af2d4
+  metadata.gz: 50f89b1bce0e4c45bb00aacaff4cfb6f1e1f8f2875cc0fc38f2317244c662b24f8b56788bb1980221b5ca6987753b3b190a3b9e671de958f5a581a1616ca0fe7
+  data.tar.gz: ed479e4104b92b159a7872fc7dbb85e6b69308c954dade0ca2cb7d044bc60ef11f483e905cb569ceaa0b686a7b07bbc49de841f3424f3b4535f01acc9f985167

data/README.md

@@ -65,6 +65,8 @@ We also want to share some small code tricks which can help you to improve your
 
 - [AnyFixture](https://github.com/palkan/test-prof/tree/master/guides/any_fixture.md)
 
+- [RSpec Stamp](https://github.com/palkan/test-prof/tree/master/guides/rspec_stamp.md)
+
 ## Configuration
 
 TestProf global configuration is used by most of the profilers:

data/guides/rspec_stamp.md

@@ -0,0 +1,53 @@
+# RSpec Stamp
+
+RSpec Stamp is a tool to automatically _tag_ failed examples with custom tags.
+
+It _literally_ adds tags to your examples (i.e. rewrites them).
+
+The main purpose of RSpec Stamp is to make refactoring testing codebase easy. Changing global configuration may cause a lot of failures. You can patch failing spec by adding a shared context. And here comes RSpec Stamp.
+
+## Example Use Case: Sidekiq Inline
+
+Using `Sidekiq::Testing.inline!` may be considered a _bad practice_ (see [here](https://github.com/mperham/sidekiq/issues/3495)) due to its negative performance impact. But it's still widely used.
+
+How to migrate from `inline!` to `fake!`?
+
+Step 0. Make sure that all your tests pass.
+
+Step 1. Create a shared context to conditionally turn on `inline!` mode:
+
+```ruby
+shared_context "sidekiq:inline", sidekiq: :inline do
+  around(:each) { |ex| Sidekiq::Testing.inline!(&ex) }
+end
+```
+
+Step 2. Turn on `fake!` mode globally.
+
+Step 3. Run `RSTAMP=sidekiq:inline rspec`.
+
+The output of the command above contains information about the _stamping_ process:
+
+- How many files have been affected?
+
+- How many patches were made?
+
+- How many patches failed?
+
+- How many files have been ignored?
+
+Now all (or almost all) failing specs are tagged with `sidekiq: :inline`. Run the whole suite again and check it there are any failures left.
+
+There is also a _dry-run_ mode (activated by `RSTAMP_DRY_RUN=1` env variable) which prints out patches instead of re-writing files.
+
+## Configuration
+
+By default, RSpecStamp ignores examples located in `spec/support` directory (typical place to put shared examples in).
+You can add more _ignore_ patterns:
+
+```ruby
+TestProf::RSpecStamp.configure do |config|
+  config.ignore_files << %r{spec/my_directory}
+end
+```
+

data/lib/test_prof.rb

@@ -47,8 +47,8 @@ module TestProf
     def activate(env_var)
       if defined?(::Spring) && !ENV['DISABLE_SPRING']
         Spring.after_fork { yield if ENV[env_var] }
-      else
-        yield if ENV[env_var] 
+      elsif ENV[env_var]
+        yield
       end
     end
 
@@ -87,3 +87,4 @@ require "test_prof/ruby_prof"
 require "test_prof/stack_prof"
 require "test_prof/event_prof"
 require "test_prof/factory_doctor"
+require "test_prof/rspec_stamp"

data/lib/test_prof/event_prof.rb

@@ -65,9 +65,7 @@ module TestProf
       def build
         Profiler.new(
           event: config.event,
-          instrumenter: config.resolve_instrumenter,
-          rank_by: config.rank_by,
-          top_count: config.top_count
+          instrumenter: config.resolve_instrumenter
         )
       end
     end
@@ -77,7 +75,7 @@ module TestProf
 
       attr_reader :event, :top_count, :rank_by, :total_count, :total_time
 
-      def initialize(event:, instrumenter:, rank_by:, top_count:)
+      def initialize(event:, instrumenter:)
         @event = event
 
         log :info, "EventProf enabled (#{@event})"

data/lib/test_prof/event_prof/custom_events/factory_create.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module TestProf::EventProf::CustomEvents
-  module FactoryCreate
+  module FactoryCreate # :nodoc: all
     module RunnerPatch
       def run(strategy = @strategy)
         return super unless strategy == :create

data/lib/test_prof/event_prof/custom_events/sidekiq_inline.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module TestProf::EventProf::CustomEvents
-  module SidekiqInline
+  module SidekiqInline # :nodoc: all
     module ClientPatch
       def raw_push(*)
         return super unless Sidekiq::Testing.inline?

data/lib/test_prof/event_prof/custom_events/sidekiq_jobs.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module TestProf::EventProf::CustomEvents
-  module SidekiqJobs
+  module SidekiqJobs # :nodoc: all
     module ClientPatch
       def raw_push(*)
         return super unless Sidekiq::Testing.inline?

data/lib/test_prof/rspec_stamp.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require "test_prof/logging"
+require "test_prof/rspec_stamp/parser"
+
+module TestProf
+  # Mark RSpec examples with provided tags
+  module RSpecStamp
+    EXAMPLE_RXP = /(\s*)(\w+\s*(?:.*)\s*)(do|{)/
+
+    # RSpecStamp configuration
+    class Configuration
+      attr_accessor :ignore_files, :dry_run, :tags
+
+      def initialize
+        @ignore_files = [%r{spec/support}]
+        @dry_run = ENV['RSTAMP_DRY_RUN'] == '1'
+        self.tags = ENV['RSTAMP']
+      end
+
+      def dry_run?
+        @dry_run == true
+      end
+
+      def tags=(val)
+        @tags = if val.is_a?(String)
+                  parse_tags(val)
+                else
+                  val
+                end
+      end
+
+      private
+
+      def parse_tags(str)
+        str.split(/\s*,\s*/).each_with_object([]) do |tag, acc|
+          k, v = tag.split(":")
+          acc << if v.nil?
+                   k.to_sym
+                 else
+                   Hash[k.to_sym, v.to_sym]
+                 end
+        end
+      end
+    end
+
+    class << self
+      include TestProf::Logging
+
+      def config
+        @config ||= Configuration.new
+      end
+
+      def configure
+        yield config
+      end
+
+      # Accepts source code (as array of lines),
+      # line numbers (of example to apply tags)
+      # and an array of tags.
+      def apply_tags(code, lines, tags)
+        failed = 0
+
+        lines.each do |line|
+          unless stamp_example(code[line - 1], tags)
+            failed += 1
+            log :warn, "Failed to stamp: #{code[line - 1]}"
+          end
+        end
+        failed
+      end
+
+      private
+
+      # rubocop: disable Metrics/CyclomaticComplexity
+      # rubocop: disable Metrics/PerceivedComplexity
+      def stamp_example(example, tags)
+        matches = example.match(EXAMPLE_RXP)
+        return false unless matches
+
+        code = matches[2]
+        block = matches[3]
+
+        parsed = Parser.parse(code)
+        return false unless parsed
+
+        parsed.desc ||= 'works'
+
+        tags.each do |t|
+          if t.is_a?(Hash)
+            t.keys.each { |k| parsed.add_htag(k, t[k]) }
+          else
+            parsed.add_tag(t)
+          end
+        end
+
+        need_parens = block == "{"
+
+        tags_str = parsed.tags.map { |t| t.is_a?(Symbol) ? ":#{t}" : t }.join(", ") unless
+          parsed.tags.nil?
+
+        unless parsed.htags.nil?
+          htags_str = parsed.htags.map do |(k, v)|
+            vstr = v.is_a?(Symbol) ? ":#{v}" : quote(v)
+
+            "#{k}: #{vstr}"
+          end
+        end
+
+        replacement = "\\1#{parsed.fname}#{need_parens ? '(' : ' '}"\
+                      "#{[quote(parsed.desc), tags_str, htags_str].compact.join(', ')}"\
+                      "#{need_parens ? ') ' : ' '}\\3"
+
+        if config.dry_run?
+          log :info, "Patched: #{example.sub(EXAMPLE_RXP, replacement)}"
+        else
+          example.sub!(EXAMPLE_RXP, replacement)
+        end
+        true
+      end
+      # rubocop: enable Metrics/CyclomaticComplexity
+      # rubocop: enable Metrics/PerceivedComplexity
+
+      def quote(str)
+        if str.include?("'")
+          "\"#{str}\""
+        else
+          "'#{str}'"
+        end
+      end
+    end
+  end
+end
+
+require "test_prof/rspec_stamp/rspec" if defined?(RSpec)

data/lib/test_prof/rspec_stamp/parser.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+# rubocop: disable Metrics/CyclomaticComplexity
+
+module TestProf
+  module RSpecStamp
+    # Parse examples headers
+    module Parser
+      # Contains the result of parsing
+      class Result
+        attr_accessor :fname, :desc
+        attr_reader :tags, :htags
+
+        def add_tag(v)
+          @tags ||= []
+          @tags << v
+        end
+
+        def add_htag(k, v)
+          @htags ||= []
+          @htags << [k, v]
+        end
+      end
+
+      class << self
+        def parse(code)
+          sexp = Ripper.sexp(code)
+          return unless sexp
+
+          # sexp has the following format:
+          # [:program,
+          #   [
+          #     [
+          #       :command,
+          #       [:@ident, "it", [1, 0]],
+          #       [:args_add_block, [ ... ]]
+          #     ]
+          #   ]
+          # ]
+          #
+          # or
+          #
+          # [:program,
+          #   [
+          #     [
+          #       :vcall,
+          #       [:@ident, "it", [1, 0]]
+          #     ]
+          #   ]
+          # ]
+          res = Result.new
+
+          fcall = sexp[1][0][1]
+          fcall = fcall[1] if fcall.first == :fcall
+          res.fname = fcall[1]
+
+          args_block = sexp[1][0][2]
+
+          return res if args_block.nil?
+
+          args_block = args_block[1] if args_block.first == :arg_paren
+
+          args = args_block[1]
+
+          if args.first.first == :string_literal
+            res.desc = parse_literal(args.shift)
+          end
+
+          parse_arg(res, args.shift) until args.empty?
+
+          res
+        end
+
+        private
+
+        def parse_arg(res, arg)
+          if arg.first == :symbol_literal
+            res.add_tag parse_literal(arg)
+          elsif arg.first == :bare_assoc_hash
+            parse_hash(res, arg[1])
+          end
+        end
+
+        def parse_hash(res, hash_arg)
+          hash_arg.each do |(_, label, val)|
+            res.add_htag label[1][0..-2].to_sym, parse_literal(val)
+          end
+        end
+
+        # Expr of the form:
+        #  [:string_literal, [:string_content, [:@tstring_content, "is", [1, 4]]]]
+        def parse_literal(expr)
+          val = expr[1][1][1]
+          val = val.to_sym if expr[0] == :symbol_literal ||
+                              expr[0] == :assoc_new
+          val
+        end
+      end
+    end
+  end
+end

data/lib/test_prof/rspec_stamp/rspec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module TestProf
+  module RSpecStamp
+    class RSpecListener # :nodoc:
+      include Logging
+
+      NOTIFICATIONS = %i[
+        example_failed
+      ].freeze
+
+      def initialize
+        @failed = 0
+        @ignored = 0
+        @total = 0
+        @examples = Hash.new { |h, k| h[k] = [] }
+      end
+
+      def example_failed(notification)
+        return if notification.example.pending?
+
+        location = notification.example.metadata[:location]
+
+        file, line = location.split(":")
+
+        @examples[file] << line.to_i
+      end
+
+      def stamp!
+        @examples.each do |file, lines|
+          stamp_file(file, lines.uniq)
+        end
+
+        msgs = []
+
+        msgs <<
+          <<~MSG
+            RSpec Stamp results
+
+            Total patches: #{@total}
+            Total files: #{@examples.keys.size}
+
+            Failed patches: #{@failed}
+            Ignored files: #{@ignored}
+          MSG
+
+        log :info, msgs.join
+      end
+
+      private
+
+      def stamp_file(file, lines)
+        @total += lines.size
+        return if ignored?(file)
+
+        log :info, "(dry-run) Patching #{file}" if dry_run?
+
+        code = File.readlines(file)
+
+        @failed += RSpecStamp.apply_tags(code, lines, RSpecStamp.config.tags)
+
+        File.write(file, code.join) unless dry_run?
+      end
+
+      def ignored?(file)
+        ignored = RSpecStamp.config.ignore_files.find do |pattern|
+          file =~ pattern
+        end
+
+        return unless ignored
+        log :warn, "Ignore stamping file: #{file}"
+        @ignored += 1
+      end
+
+      def dry_run?
+        RSpecStamp.config.dry_run?
+      end
+    end
+  end
+end
+
+# Register EventProf listener
+TestProf.activate('RSTAMP') do
+  RSpec.configure do |config|
+    listener = TestProf::RSpecStamp::RSpecListener.new
+
+    config.reporter.register_listener(listener, *TestProf::RSpecStamp::RSpecListener::NOTIFICATIONS)
+
+    config.after(:suite) { listener.stamp! }
+  end
+end

data/lib/test_prof/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TestProf
-  VERSION = "0.1.0.pre2"
+  VERSION = "0.1.0.pre5"
 end

data/spec/integrations/event_prof_spec.rb

@@ -77,8 +77,8 @@ describe "EventProf" do
       expect(output).to match(/Total time: \d{2}:\d{2}\.\d{3}/)
       expect(output).to include("Total events: 3")
 
-      expect(output).to match(%r{SingleJob \(./event_prof_sidekiq_fixture.rb:28\) – \d{2}:\d{2}.\d{3} \(2 / 2\)})
-      expect(output).to match(%r{BatchJob \(./event_prof_sidekiq_fixture.rb:40\) – \d{2}:\d{2}.\d{3} \(1 / 2\)})
+      expect(output).to match(%r{SingleJob \(./event_prof_sidekiq_fixture.rb:27\) – \d{2}:\d{2}.\d{3} \(2 / 2\)})
+      expect(output).to match(%r{BatchJob \(./event_prof_sidekiq_fixture.rb:39\) – \d{2}:\d{2}.\d{3} \(1 / 2\)})
     end
 
     it "works with sidekiq.jobs" do
@@ -93,8 +93,8 @@ describe "EventProf" do
 
       expect(output).to include("Top 5 slowest suites (by count):")
 
-      expect(output).to match(%r{SingleJob \(./event_prof_sidekiq_fixture.rb:28\) – \d{2}:\d{2}.\d{3} \(2 / 2\)})
-      expect(output).to match(%r{BatchJob \(./event_prof_sidekiq_fixture.rb:40\) – \d{2}:\d{2}.\d{3} \(4 / 2\)})
+      expect(output).to match(%r{SingleJob \(./event_prof_sidekiq_fixture.rb:27\) – \d{2}:\d{2}.\d{3} \(2 / 2\)})
+      expect(output).to match(%r{BatchJob \(./event_prof_sidekiq_fixture.rb:39\) – \d{2}:\d{2}.\d{3} \(4 / 2\)})
     end
   end
 end

data/spec/integrations/fixtures/rspec/event_prof_sidekiq_fixture.rb

@@ -9,12 +9,11 @@ Sidekiq::Testing.inline!
 class SingleJob
   include Sidekiq::Worker
 
-  def perform(*args)
-    1 == 1
+  def perform(*_args)
+    true
   end
 end
 
-
 class BatchJob
   include Sidekiq::Worker
 

data/spec/integrations/fixtures/rspec/rspec_stamp_fixture_tmpl.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../../../../lib", __FILE__)
+require "active_support"
+require "test-prof"
+
+shared_context "fixxer", fix: :me do
+  before { @value = true }
+end
+
+describe "Something" do
+  it "fail me" do
+    expect(@value).to eq true
+  end
+
+  it "always passes" do
+    expect(true).to eq true
+  end
+
+  specify '
+    you
+    can
+    not
+    patch me
+  ' do
+    expect(@value).to eq true
+  end
+
+  context "nested context" do
+    subject { @value }
+    specify { is_expected.to eq true }
+  end
+end

data/spec/integrations/rspec_stamp_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+describe "RSpecStamp" do
+  before do
+    FileUtils.cp(
+      File.expand_path("../../integrations/fixtures/rspec/rspec_stamp_fixture_tmpl.rb", __FILE__),
+      File.expand_path("../../integrations/fixtures/rspec/rspec_stamp_fixture.rb", __FILE__)
+    )
+  end
+
+  after do
+    FileUtils.rm(
+      File.expand_path("../../integrations/fixtures/rspec/rspec_stamp_fixture.rb", __FILE__)
+    )
+  end
+
+  specify "it works", :aggregate_failures do
+    output = run_rspec('rspec_stamp', success: false, env: { 'RSTAMP' => 'fix:me' })
+
+    expect(output).to include("4 examples, 3 failures")
+
+    expect(output).to include("RSpec Stamp results")
+    expect(output).to include("Total patches: 3")
+    expect(output).to include("Total files: 1")
+    expect(output).to include("Failed patches: 1")
+    expect(output).to include("Ignored files: 0")
+
+    output2 = run_rspec('rspec_stamp', success: false)
+
+    expect(output2).to include("4 examples, 1 failure")
+  end
+
+  specify "it works with dry-run", :aggregate_failures do
+    output = run_rspec('rspec_stamp', success: false, env: { 'RSTAMP' => 'fix:me', 'RSTAMP_DRY_RUN' => '1' })
+
+    expect(output).to include("4 examples, 3 failures")
+
+    expect(output).to include("RSpec Stamp results")
+    expect(output).to include("Total patches: 3")
+    expect(output).to include("Total files: 1")
+    expect(output).to include("Failed patches: 1")
+    expect(output).to include("Ignored files: 0")
+
+    expect(output).to include("(dry-run) Patching ./rspec_stamp_fixture.rb")
+    expect(output).to include("Patched:   it 'fail me', fix: :me do")
+
+    output2 = run_rspec('rspec_stamp', success: false)
+
+    expect(output2).to include("4 examples, 3 failures")
+  end
+end

data/spec/support/integration_helpers.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 module IntegrationHelpers
-  def run_rspec(path, env: {})
+  def run_rspec(path, success: true, env: {})
     output, status = Open3.capture2(
       env,
       "rspec #{path}_fixture.rb",
       chdir: File.expand_path("../../integrations/fixtures/rspec", __FILE__)
     )
-    expect(status).to be_success
+    expect(status).to be_success if success
     output
   end
 end

data/spec/test_prof/rspec_stamp/parser_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "test_prof/rspec_stamp/parser"
+
+describe TestProf::RSpecStamp::Parser do
+  subject { described_class }
+
+  describe ".parse" do
+    it "handles simple expr" do
+      res = subject.parse('it "works"')
+      expect(res.fname).to eq 'it'
+      expect(res.desc).to eq 'works'
+      expect(res.tags).to be_nil
+      expect(res.htags).to be_nil
+    end
+
+    it "handles missing desc" do
+      res = subject.parse('it ')
+      expect(res.fname).to eq 'it'
+      expect(res.desc).to be_nil
+      expect(res.tags).to be_nil
+      expect(res.htags).to be_nil
+    end
+
+    it "handles parentheses" do
+      res = subject.parse('    it("is") ')
+      expect(res.fname).to eq 'it'
+      expect(res.desc).to eq 'is'
+      expect(res.tags).to be_nil
+      expect(res.htags).to be_nil
+    end
+
+    it "handles several args" do
+      res = subject.parse('  it "is o\'h", :cool, :bad ')
+      expect(res.fname).to eq 'it'
+      expect(res.desc).to eq "is o'h"
+      expect(res.tags).to eq(%i[cool bad])
+      expect(res.htags).to be_nil
+    end
+
+    it "handles hargs" do
+      res = subject.parse('  it "is", cool: :bad, type: "feature" ')
+      expect(res.fname).to eq 'it'
+      expect(res.desc).to eq "is"
+      expect(res.tags).to be_nil
+      expect(res.htags).to eq([%i[cool bad], [:type, "feature"]])
+    end
+
+    it "handles args and hargs" do
+      res = subject.parse('  it "is", :cool, :bad, type: :feature ')
+      expect(res.fname).to eq 'it'
+      expect(res.desc).to eq "is"
+      expect(res.tags).to eq(%i[cool bad])
+      expect(res.htags).to eq([%i[type feature]])
+    end
+  end
+end

data/spec/test_prof/rspec_stamp_spec.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "test_prof/rspec_stamp"
+
+describe TestProf::RSpecStamp do
+  subject { described_class }
+
+  describe "#config" do
+    after { described_class.remove_instance_variable(:@config) }
+
+    subject { described_class.config }
+
+    it "handles array tags" do
+      subject.tags = [:todo]
+      expect(subject.tags).to eq([:todo])
+    end
+
+    it "handles string tags" do
+      subject.tags = "todo"
+      expect(subject.tags).to eq([:todo])
+    end
+
+    it "handle string hash tags" do
+      subject.tags = "fix:me"
+      expect(subject.tags).to eq([{ fix: :me }])
+    end
+
+    it "handle several tags" do
+      subject.tags = "todo,fix:me"
+      expect(subject.tags).to eq([:todo, { fix: :me }])
+    end
+  end
+
+  describe ".apply_tags" do
+    let(:code) { source.split("\n") }
+
+    let(:lines) { [1] }
+
+    let(:tags) { [:todo] }
+
+    subject { described_class.apply_tags(code, lines, tags) }
+
+    let(:source) do
+      <<~CODE
+        it "doesn't do what it should do" do
+          expect(subject.body).to eq("OK")
+        end
+      CODE
+    end
+
+    let(:expected) do
+      <<~CODE
+        it "doesn't do what it should do", :todo do
+          expect(subject.body).to eq("OK")
+        end
+      CODE
+    end
+
+    specify do
+      is_expected.to eq 0
+      expect(code.join("\n")).to eq expected.strip
+    end
+
+    context "with several examples" do
+      let(:source) do
+        <<~CODE
+          it 'succeeds' do
+            expect(subject.body).to eq("OK")
+          end
+
+          context "not found" do
+            let(:post) { draft_post }
+
+            it 'fails' do
+              expect(subject.body).to eq("Not Found")
+            end
+          end
+        CODE
+      end
+
+      let(:expected) do
+        <<~CODE
+          it 'succeeds' do
+            expect(subject.body).to eq("OK")
+          end
+
+          context "not found" do
+            let(:post) { draft_post }
+
+            it 'fails', :todo do
+              expect(subject.body).to eq("Not Found")
+            end
+          end
+        CODE
+      end
+
+      let(:lines) { [8] }
+
+      specify do
+        is_expected.to eq 0
+        expect(code.join("\n")).to eq expected.strip
+      end
+
+      context "patch all" do
+        let(:expected) do
+          <<~CODE
+            it 'succeeds', :todo do
+              expect(subject.body).to eq("OK")
+            end
+
+            context "not found" do
+              let(:post) { draft_post }
+
+              it 'fails', :todo do
+                expect(subject.body).to eq("Not Found")
+              end
+            end
+          CODE
+        end
+
+        let(:lines) { [1, 8] }
+
+        specify do
+          is_expected.to eq 0
+          expect(code.join("\n")).to eq expected.strip
+        end
+      end
+    end
+
+    context "without description" do
+      let(:source) do
+        <<~CODE
+          specify do
+            expect(subject.body).to eq("Not Found")
+          end
+        CODE
+      end
+
+      let(:expected) do
+        <<~CODE
+          specify 'works', :todo do
+            expect(subject.body).to eq("Not Found")
+          end
+        CODE
+      end
+
+      specify do
+        is_expected.to eq 0
+        expect(code.join("\n")).to eq expected.strip
+      end
+    end
+
+    context "one-liner" do
+      let(:source) do
+        <<~CODE
+          it("is") { expect(subject.body).to eq("Not Found") }
+        CODE
+      end
+
+      let(:expected) do
+        <<~CODE
+          it('is', :todo) { expect(subject.body).to eq("Not Found") }
+        CODE
+      end
+
+      specify do
+        is_expected.to eq 0
+        expect(code.join("\n")).to eq expected.strip
+      end
+    end
+
+    context "one-liner without description" do
+      let(:source) do
+        <<~CODE
+          it { expect(subject.body).to eq("Not Found") }
+        CODE
+      end
+
+      let(:expected) do
+        <<~CODE
+          it('works', :todo) { expect(subject.body).to eq("Not Found") }
+        CODE
+      end
+
+      specify do
+        is_expected.to eq 0
+        expect(code.join("\n")).to eq expected.strip
+      end
+    end
+
+    context "with existing tags" do
+      let(:source) do
+        <<~CODE
+          it 'is "KOI"', :log do
+            expect(subject.body).to eq("Not Found")
+          end
+        CODE
+      end
+
+      let(:expected) do
+        <<~CODE
+          it 'is "KOI"', :log, :todo do
+            expect(subject.body).to eq("Not Found")
+          end
+        CODE
+      end
+
+      specify do
+        is_expected.to eq 0
+        expect(code.join("\n")).to eq expected.strip
+      end
+    end
+
+    context "with several tags" do
+      let(:source) do
+        <<~CODE
+          specify do
+            expect(subject.body).to eq("Not Found")
+          end
+        CODE
+      end
+
+      let(:expected) do
+        <<~CODE
+          specify 'works', :todo, a: :b, c: 'd' do
+            expect(subject.body).to eq("Not Found")
+          end
+        CODE
+      end
+
+      let(:tags) { [{ a: :b }, :todo, { c: 'd' }] }
+
+      specify do
+        is_expected.to eq 0
+        expect(code.join("\n")).to eq expected.strip
+      end
+
+      context "with existing tags" do
+        let(:source) do
+          <<~CODE
+            it 'is', :log, level: :debug do
+              expect(subject.body).to eq("Not Found")
+            end
+          CODE
+        end
+
+        let(:expected) do
+          <<~CODE
+            it 'is', :log, :todo, level: :debug, a: :b, c: 'd' do
+              expect(subject.body).to eq("Not Found")
+            end
+          CODE
+        end
+
+        specify do
+          is_expected.to eq 0
+          expect(code.join("\n")).to eq expected.strip
+        end
+      end
+    end
+
+    context "with multiline description" do
+      let(:source) do
+        <<~CODE
+          it %q{
+            succeeds
+            this time
+          } do
+            expect(subject.body).to eq("OK")
+          end
+        CODE
+      end
+
+      specify do
+        is_expected.to eq 1
+        expect(code.join("\n")).to eq source.strip
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test-prof
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre2
+  version: 0.1.0.pre5
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-25 00:00:00.000000000 Z
+date: 2017-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -160,6 +160,7 @@ files:
 - guides/before_all.md
 - guides/event_prof.md
 - guides/factory_doctor.md
+- guides/rspec_stamp.md
 - guides/ruby_prof.md
 - guides/stack_prof.md
 - lib/test-prof.rb
@@ -181,6 +182,9 @@ files:
 - lib/test_prof/logging.rb
 - lib/test_prof/recipes/rspec/any_fixture.rb
 - lib/test_prof/recipes/rspec/before_all.rb
+- lib/test_prof/rspec_stamp.rb
+- lib/test_prof/rspec_stamp/parser.rb
+- lib/test_prof/rspec_stamp/rspec.rb
 - lib/test_prof/ruby_prof.rb
 - lib/test_prof/ruby_prof/rspec.rb
 - lib/test_prof/stack_prof.rb
@@ -196,6 +200,8 @@ files:
 - spec/integrations/fixtures/rspec/event_prof_fixture.rb
 - spec/integrations/fixtures/rspec/event_prof_sidekiq_fixture.rb
 - spec/integrations/fixtures/rspec/factory_doctor_fixture.rb
+- spec/integrations/fixtures/rspec/rspec_stamp_fixture_tmpl.rb
+- spec/integrations/rspec_stamp_spec.rb
 - spec/spec_helper.rb
 - spec/support/ar_models.rb
 - spec/support/instrumenter_stub.rb
@@ -205,6 +211,8 @@ files:
 - spec/test_prof/event_prof_spec.rb
 - spec/test_prof/ext/float_duration_spec.rb
 - spec/test_prof/factory_doctor_spec.rb
+- spec/test_prof/rspec_stamp/parser_spec.rb
+- spec/test_prof/rspec_stamp_spec.rb
 - spec/test_prof/ruby_prof_spec.rb
 - spec/test_prof/stack_prof_spec.rb
 - spec/test_prof_spec.rb