rspectre 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ba92a8e8133dfaf7b4b3482717139be699fb8f25
+  data.tar.gz: 760cdddf1a3aeb9db71b54fa637f8009218eccc1
+SHA512:
+  metadata.gz: f60346768b3217d357455cc3f8c8e8d3048e0f1ee859ff7bf796e3f8b85f5a57457dcc3b2170e146baf211438ef4679c144de46c2fcf4d6c1c164d90d660e411
+  data.tar.gz: '06917b75a86f56f949b6edbd681af187b392af58ef4d8ccf567145ed7775914090b5ae0060516ef049cdea8b7358e336fbc30c6bf73b9501fdeff6100fbcdd38'

data/bin/rspectre

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+
+require 'shellwords'
+require 'optparse'
+
+require 'rspectre'
+
+options = { rspec: %w[--fail-fast spec], :'auto-correct' => false }
+
+OptionParser.new do |opts|
+  opts.banner = 'Usage: rspectre [options]'
+
+  opts.on('--rspec RSPEC_ARGS', 'Arguments to feed to RSpec.') do |value|
+    options[:rspec] = value.shellsplit
+  end
+
+  opts.on(
+    '--auto-correct',
+    'Enables auto-correct.',
+    'When auto-correct is enabled, rspectre will modify your source files in place and delete any'\
+    ' unused test setup.'
+  ) do |value|
+    options[:'auto-correct'] = value
+  end
+end.parse(ARGV)
+
+rspec, auto_correct = options.fetch_values(:rspec, :'auto-correct')
+
+RSpectre::Runner.new(rspec, auto_correct).lint

data/lib/rspectre.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+
+require 'pathname'
+require 'set'
+
+require 'anima'
+require 'concord'
+require 'parser/current'
+require 'rspec'
+require 'unparser'
+
+require 'rspectre/auto_corrector'
+require 'rspectre/color'
+require 'rspectre/node'
+require 'rspectre/offense'
+require 'rspectre/runner'
+require 'rspectre/source_map'
+require 'rspectre/source_map/parser'
+require 'rspectre/tracker'
+
+require 'rspectre/linter'
+require 'rspectre/linter/unused_let'
+require 'rspectre/linter/unused_subject'
+require 'rspectre/linter/unused_shared_setup'
+
+module RSpectre
+  TRACKER = Tracker.new
+end

data/lib/rspectre/auto_corrector.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RSpectre
+  class AutoCorrector < Parser::Rewriter
+    include Concord.new(:filename, :nodes)
+
+    def correct
+      buffer = Parser::Source::Buffer.new("(#{filename})")
+      buffer.source = File.read(filename)
+
+      File.open(filename, 'w') do |file|
+        file.write(rewrite(buffer, Parser::CurrentRuby.new.parse(buffer)))
+      end
+    end
+
+    def on_block(node)
+      remove(node.location.expression) if nodes.any? do |offense_node|
+        node == offense_node && node.location.line == offense_node.location.line
+      end
+
+      super
+    end
+  end
+end

data/lib/rspectre/color.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RSpectre
+  module Color
+    def self.red(str)
+      colorize(str, 31)
+    end
+
+    def self.yellow(str)
+      colorize(str, 33)
+    end
+
+    def self.light_blue(str)
+      colorize(str, 36)
+    end
+
+    def self.colorize(str, color_code)
+      "\e[#{color_code}m#{str}\e[0m"
+    end
+    private_class_method :colorize
+  end
+end

data/lib/rspectre/linter.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RSpectre
+  class Linter
+    SOURCE_FILES = {} # rubocop:disable Style/MutableConstant
+
+    def self.example_group
+      RSpec::Core::ExampleGroup
+    end
+
+    def self.register(selector, locations) # rubocop:disable Metrics/MethodLength
+      location = locations.first
+
+      file = File.realpath(location.path)
+      line = location.lineno
+
+      return unless file.to_s.start_with?(File.realpath(Dir.pwd))
+
+      raw_node = node_map(file).find_method(selector, line)
+
+      if raw_node
+        node = RSpectre::Node.new(file, line, raw_node)
+        TRACKER.register(self::TAG, node)
+        if block_given?
+          yield node
+        else
+          return node
+        end
+      end
+    end
+
+    def self.node_map(file)
+      SOURCE_FILES[file] ||= SourceMap.parse(file)
+    end
+
+    def self.record(node)
+      TRACKER.record(self::TAG, node)
+    end
+
+    def self.prepend_behavior(scope, method_name)
+      original_method = scope.instance_method(method_name)
+
+      scope.__send__(:define_method, method_name) do |*args, &block|
+        yield
+
+        original_method.bind(self).(*args, &block)
+      end
+    end
+
+    private_constant(*constants(false))
+    private_class_method(*singleton_methods(false) - %i[record register prepend_behavior])
+  end
+end

data/lib/rspectre/linter/unused_let.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RSpectre
+  class Linter
+    class UnusedLet < self
+      TAG = 'UnusedLet'
+
+      def example_group.let(name, &block)
+        super(name, &block)
+
+        UnusedLet.register(:let, caller_locations) do |node|
+          UnusedLet.prepend_behavior(self, name) { UnusedLet.record(node) }
+        end
+      end
+    end
+  end
+end

data/lib/rspectre/linter/unused_shared_setup.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RSpectre
+  class Linter
+    class UnusedSharedSetup < self
+      TAG = 'UnusedSharedSetup'
+
+      def self.redefine_shared(receiver, method) # rubocop:disable Metrics/MethodLength
+        # Capture the original class method
+        original_method = receiver.method(method)
+
+        # Overwrite the class method using define_singleton_method
+        receiver.__send__(:define_singleton_method, method) do |name, *args, &block|
+          # When we can locate the source of the node, tag it
+          if (node = UnusedSharedSetup.register(method, caller_locations))
+            # And call the orignal
+            original_method.(name, *args) do |*shared_args|
+              # But record that it was used in a `before`
+              before { UnusedSharedSetup.record(node) }
+
+              # And then perform the original block in a `class_exec` like the original block was
+              # supposed to be
+              class_exec(*shared_args, &block)
+            end
+          else
+            # If we couldn't locate the source, just delegate to the original method.
+            original_method.(name, *args, &block)
+          end
+        end
+      end
+
+      if respond_to?(:shared_examples)
+        main = TOPLEVEL_BINDING.eval('self')
+        redefine_shared(main, :shared_examples)
+        redefine_shared(main, :shared_examples_for)
+        redefine_shared(main, :shared_context)
+      end
+
+      redefine_shared(RSpec, :shared_examples)
+      redefine_shared(RSpec, :shared_examples_for)
+      redefine_shared(RSpec, :shared_context)
+
+      # We cannot dynamically capture the original method for the example group like we can for the
+      # binding on main and for the RSpec constant because RSpec checks to see if the receiver of
+      # the method is the top level example group which would be the case if we redefined it in
+      # terms of the old method. I think we can probably do some kind of module inclusion to reduce
+      # this duplication (which is effectively what happens here anyway, i think), but this works
+      # for now.
+      def example_group.shared_examples(name, *args, &block)
+        if (node = UnusedSharedSetup.register(:shared_examples, caller_locations))
+          super(name, *args) do |*shared_args|
+            before { UnusedSharedSetup.record(node) }
+
+            class_exec(*shared_args, &block)
+          end
+        else
+          super(name, *args, &block)
+        end
+      end
+
+      def example_group.shared_examples_for(name, *args, &block)
+        if (node = UnusedSharedSetup.register(:shared_examples_for, caller_locations))
+          super(name, *args) do |*shared_args|
+            before { UnusedSharedSetup.record(node) }
+
+            class_exec(*shared_args, &block)
+          end
+        else
+          super(name, *args, &block)
+        end
+      end
+
+      def example_group.shared_context(name, *args, &block)
+        if (node = UnusedSharedSetup.register(:shared_context, caller_locations))
+          super(name, *args) do |*shared_args|
+            before { UnusedSharedSetup.record(node) }
+
+            class_exec(*shared_args, &block)
+          end
+        else
+          super(name, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/rspectre/linter/unused_subject.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RSpectre
+  class Linter
+    class UnusedSubject < self
+      TAG = 'UnusedSubject'
+
+      def example_group.subject(name = nil, &block)
+        super(*name, &block)
+
+        UnusedSubject.register(:subject, caller_locations) do |node|
+          UnusedSubject.prepend_behavior(self, :subject) { UnusedSubject.record(node) }
+          alias_method name, :subject if name
+        end
+      end
+    end
+  end
+end

data/lib/rspectre/node.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RSpectre
+  class Node
+    include Concord::Public.new(:file, :line, :node)
+
+    def start_column
+      location.column + 1
+    end
+
+    def end_column
+      if single_line?
+        location.last_column + 1
+      else
+        source_line.length + 1
+      end
+    end
+
+    def source_line
+      location.expression.source_line.rstrip
+    end
+
+    private
+
+    def single_line?
+      line.equal?(location.last_line)
+    end
+
+    def location
+      node.children.first.location
+    end
+  end
+end

data/lib/rspectre/offense.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RSpectre
+  class Offense
+    include Anima.new(:file, :line, :source_line, :start_column, :end_column, :type)
+
+    DESCRIPTIONS = {
+      'UnusedLet'         => 'Unused `let` definition.',
+      'UnusedSubject'     => 'Unused `subject` definition.',
+      'UnusedSharedSetup' => 'Unused `shared_examples`, `shared_examples_for`, or'\
+                             ' `shared_context` definition.'
+    }.freeze
+
+    def self.parse(type, node)
+      new(
+        file:         node.file,
+        line:         node.line,
+        source_line:  node.source_line,
+        start_column: node.start_column,
+        end_column:   node.end_column,
+        type:         type
+      )
+    end
+
+    def warn
+      puts to_s
+    end
+
+    def to_s
+      <<~DOC
+
+          #{source_id}: #{offense_type}: #{description}
+              #{source_line}
+              #{highlight}
+      DOC
+    end
+
+    def description
+      DESCRIPTIONS.fetch(type)
+    end
+
+    private
+
+    def source_id
+      Color.light_blue("#{file}:#{line}:#{start_column}")
+    end
+
+    def offense_type
+      Color.yellow(type)
+    end
+
+    def highlight
+      ' ' * (start_column - 1) + carets(end_column - start_column)
+    end
+
+    def carets(n)
+      Color.yellow('^' * n)
+    end
+  end
+end

data/lib/rspectre/runner.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RSpectre
+  class Runner
+    include Concord.new(:rspec_arguments, :auto_correct)
+
+    EXIT_SUCCESS = 0
+
+    def lint
+      if runner.run_specs(RSpec.world.ordered_example_groups).equal?(EXIT_SUCCESS)
+        handle_offenses
+      else
+        exit_with_error
+      end
+    end
+
+    private
+
+    def handle_offenses
+      if TRACKER.offenses?
+        auto_correct ? TRACKER.correct_offenses : TRACKER.report_offenses
+      end
+    end
+
+    def exit_with_error
+      abort(
+        Color.red(
+          'Running the specs failed. Either your tests do not pass '\
+          'normally or this is a bug in RSpectre.'
+        )
+      )
+    end
+
+    def runner
+      rspec_config = RSpec::Core::ConfigurationOptions.new(rspec_arguments)
+
+      RSpec::Core::Runner.new(rspec_config).tap { |runner| runner.setup($stderr, StringIO.new) }
+    end
+  end # Rspec
+end

data/lib/rspectre/source_map.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RSpectre
+  class SourceMap
+    include Concord.new(:map)
+
+    def initialize
+      super(Hash.new { [] })
+    end
+    private_class_method :new
+
+    def self.parse(file)
+      self::Parser.new(file).populate(new)
+    end
+
+    def add(node)
+      return unless node.loc.expression
+
+      map[node.loc.first_line] <<= node
+    end
+
+    def find_method(target_selector, line)
+      candidates = find_methods(target_selector, line)
+
+      if candidates.one?
+        candidates.first
+      else
+        warn Color.yellow("Unable to resolve `#{target_selector}` on line #{line}.")
+      end
+    end
+
+    private
+
+    def find_methods(target_selector, line)
+      block_nodes(line).select do |node|
+        send, = *node
+        _receiver, selector = *send
+
+        selector.equal?(target_selector)
+      end
+    end
+
+    def block_nodes(line)
+      map.fetch(line, []).select { |node| node.type.equal?(:block) }
+    end
+
+    class Null < self
+      public_class_method :new
+
+      def find_let(_)
+      end
+    end
+  end
+end

data/lib/rspectre/source_map/parser.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RSpectre
+  class SourceMap
+    class Parser
+      include Concord.new(:file)
+
+      def populate(map)
+        walk(parsed_source) { |node| map.add(node) }
+
+        map.freeze
+      rescue ::Parser::SyntaxError => error
+        warn Color.yellow("Warning! Skipping #{file} due to parsing error!")
+        warn error.diagnostic.render
+        Null.new
+      end
+
+      private
+
+      def walk(node, &block)
+        yield node
+
+        node.children.each do |child|
+          next unless child.is_a?(::Parser::AST::Node)
+
+          walk(child, &block)
+        end
+      end
+
+      def parsed_source
+        ::Parser::CurrentRuby.parse(raw_source, file)
+      end
+
+      def raw_source
+        Pathname.new(file).read
+      end
+    end
+  end
+end

data/lib/rspectre/tracker.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RSpectre
+  class Tracker
+    include Concord.new(:registry, :tracker)
+
+    def initialize
+      super(Hash.new { Set.new }, Hash.new { Set.new })
+    end
+
+    def register(type, node)
+      registry[type] <<= node
+    end
+
+    def record(type, node)
+      tracker[type] <<= node
+    end
+
+    def report_offenses
+      offenses.each(&:warn)
+      abort
+    end
+
+    def offenses?
+      offenses.any?
+    end
+
+    def correct_offenses
+      registry.flat_map { |type, locations| (locations - tracker[type]).to_a }
+        .group_by(&:file)
+        .transform_values { |nodes| nodes.map(&:node) }
+        .each do |file, nodes|
+          AutoCorrector.new(file, nodes).correct
+        end
+    end
+
+    private
+
+    def offenses
+      registry.flat_map do |type, locations|
+        missing = locations - tracker[type]
+
+        missing.map { |node| Offense.parse(type, node) }
+      end
+    end
+  end
+end

data/lib/rspectre/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RSpectre
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: rspectre
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Daniel Gollahon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: anima
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: concord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: unparser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.47'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.47'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+description: 
+email: 
+executables:
+- rspectre
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/rspectre
+- lib/rspectre.rb
+- lib/rspectre/auto_corrector.rb
+- lib/rspectre/color.rb
+- lib/rspectre/linter.rb
+- lib/rspectre/linter/unused_let.rb
+- lib/rspectre/linter/unused_shared_setup.rb
+- lib/rspectre/linter/unused_subject.rb
+- lib/rspectre/node.rb
+- lib/rspectre/offense.rb
+- lib/rspectre/runner.rb
+- lib/rspectre/source_map.rb
+- lib/rspectre/source_map/parser.rb
+- lib/rspectre/tracker.rb
+- lib/rspectre/version.rb
+homepage: http://github.com/dgollahon/rspectre
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: A tool for linting RSpec test suites.
+test_files: []