pippi 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0c609506ea54efa1618cc91626c3a1b0d13619ce
-  data.tar.gz: 815ea5e17c5562c9eee9c8cffe7025c759036995
+  metadata.gz: 5ad992cb9bc5aa2b1e2ea7ee7acbe531cbb2432e
+  data.tar.gz: 564a5feffa9d49e8eb28d878f4635c93ba19921e
 SHA512:
-  metadata.gz: db93b8205fcfd68ebce496b74701165719364b90d5ffe9f06609e7a1bec19a4fdc5a14766d01dbf8a0138cd42d6a9ec9b2cd69377f15ca5e3cb4c6ea0af7f2fc
-  data.tar.gz: 2cb1d62ca2e910bb583b0cffa1bf67531b4b5bf6393133b93776b3e72787293fd3793b28adff09aff965e4464523c94365c61cb513c70ad0021124e6323ce6c6
+  metadata.gz: 9e1046f43ec28739b33a224136a3c852ea9a0c91579f5c22bff9f102e0fff483bb0ce9c97a9b93d2cb34d4a1c6fca390bfff9de1ec2020488d96d7ff6d88faec
+  data.tar.gz: 822431d1b25e296483f2031a8ec581788615e6c1d89b02b9fee1fd4474172c72e8b753cbcaaae81f1e51564cc881a6ae38a7dd92ff3dfa5ec9dad96bb15f5879

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.0.10 (2014-12-09)
+
+* [NEW] Added SelectFollowedByNone
+
 ## 0.0.9 (2014-12-04)
 
 * [FIXED] False positives reduced

data/README.md

@@ -189,6 +189,22 @@ Instead, consider doing this:
 [1,2,3].detect {|x| x > 1 }
 ```
 
+#### SelectFollowedByNone
+
+Don't use select followed by none?; use none? with a block instead
+
+For example, rather than doing this:
+
+```ruby
+[1,2,3].select {|x| x > 1 }.none?
+```
+
+Instead, consider doing this:
+
+```ruby
+[1,2,3].none? {|x| x > 1 }
+```
+
 #### SelectFollowedBySelect
 
 Don't use consecutive select blocks; use a single select instead
@@ -257,8 +273,6 @@ Instead, consider doing this:
 ## Ideas for other problems to detect:
 
 ```ruby
-# Don't use select followed by compact, use select with the nil inside the block
-
 # unnecessary assignment since String#strip! mutates receiver
 # wrong
 x = x.strip!
@@ -320,7 +334,8 @@ end
 
 * Clean up this initial hacked out metaprogramming
 * Do more checks
-* Make writing rules nicer, without some much dorking around with methods.  "select followed by first" could be specified with something like "Array#select => #first" and the rest left up to the framework.
+* Finish refactoring duplicated code into MethodSequenceChecker
+* Use MethodSequenceFinder to do something with String
 
 ## Developing
 

data/doc/docs.md

@@ -64,6 +64,22 @@ Instead, consider doing this:
 [1,2,3].detect {|x| x > 1 }
 ```
 
+#### SelectFollowedByNone
+
+Don't use select followed by none?; use none? with a block instead
+
+For example, rather than doing this:
+
+```ruby
+[1,2,3].select {|x| x > 1 }.none?
+```
+
+Instead, consider doing this:
+
+```ruby
+[1,2,3].none? {|x| x > 1 }
+```
+
 #### SelectFollowedBySelect
 
 Don't use consecutive select blocks; use a single select instead

data/lib/pippi.rb

@@ -14,6 +14,9 @@ require 'pippi/checks/select_followed_by_first'
 require 'pippi/checks/select_followed_by_size'
 require 'pippi/checks/select_followed_by_empty'
 require 'pippi/checks/select_followed_by_any'
+require 'pippi/checks/select_followed_by_none'
 require 'pippi/checks/select_followed_by_select'
+require 'pippi/checks/method_sequence_finder'
+require 'pippi/checks/method_sequence_checker'
 require 'pippi/checks/assert_with_nil'
 require 'pippi/checks/debug_check'

data/lib/pippi/auto_runner.rb

@@ -5,11 +5,16 @@ module Pippi
     def initialize(opts = {})
       checkset = opts.fetch(:checkset, 'basic')
       @ctx = Pippi::Context.new
-      Pippi::CheckLoader.new(@ctx, checkset).checks.each(&:decorate)
+
+      @ctx.checks = Pippi::CheckLoader.new(@ctx, checkset).checks
+      @ctx.checks.each(&:decorate)
       at_exit { dump }
     end
 
     def dump
+      if @ctx.checks.one? && @ctx.checks.first.kind_of?(Pippi::Checks::MethodSequenceFinder)
+        @ctx.checks.first.dump
+      end
       File.open('log/pippi.log', 'w') do |outfile|
         @ctx.report.problems.each do |problem|
           outfile.syswrite("#{problem.to_text}\n")

data/lib/pippi/check_set_mapper.rb

@@ -23,12 +23,16 @@ module Pippi
           "SelectFollowedByFirst",
           "SelectFollowedBySize",
           "SelectFollowedByAny",
+          "SelectFollowedByNone",
           "SelectFollowedByEmpty",
           "ReverseFollowedByEach",
           "SelectFollowedBySelect"
         ],
         "training" => [
         ],
+        "research" => [
+          "MethodSequenceFinder",
+        ],
         "buggy" => [
           "AssertWithNil",
           "MapFollowedByFlatten",

data/lib/pippi/checks/map_followed_by_flatten.rb

@@ -1,4 +1,6 @@
 module Pippi::Checks
+
+  # TODO make this use MethodSequenceChecker
   class MapFollowedByFlatten < Check
     module MyFlatten
       def flatten(depth = nil)

data/lib/pippi/checks/method_sequence_checker.rb

@@ -0,0 +1,80 @@
+class MethodSequenceChecker
+
+  ARITY_TYPE_BLOCK_ARG = 1
+  ARITY_TYPE_NONE = 2
+
+  attr_reader :check, :clazz_to_decorate, :method1, :method2, :first_method_arity_type, :second_method_arity_type, :should_check_subsequent_calls
+
+  def initialize(check, clazz_to_decorate, method1, method2, first_method_arity_type, second_method_arity_type, should_check_subsequent_calls)
+    @check = check
+    @clazz_to_decorate = clazz_to_decorate
+    @method1 = method1
+    @method2 = method2
+    @first_method_arity_type = first_method_arity_type
+    @second_method_arity_type = second_method_arity_type
+    @should_check_subsequent_calls = should_check_subsequent_calls
+  end
+
+  def decorate
+    clazz_to_decorate.class_exec(check, self) do |my_check, method_sequence_check_instance|
+      name = "@_pippi_check_#{my_check.class.name.split('::').last.downcase}"
+      self.instance_variable_set(name, my_check)
+      self.class.send(:define_method, name[1..-1]) do
+        instance_variable_get(name)
+      end
+
+      # e.g., "size" in "select followed by size"
+      second_method_decorator = Module.new do
+        define_method(method_sequence_check_instance.method2) do |*args, &blk|
+          self.class.instance_variable_get(name).add_problem
+          if method_sequence_check_instance.should_check_subsequent_calls && method_sequence_check_instance.clazz_to_decorate == Array
+            problem_location = caller_locations.find { |c| c.to_s !~ /byebug|lib\/pippi\/checks/ }
+            self.class.instance_variable_get(name).method_names_that_indicate_this_is_being_used_as_a_collection.each do |this_means_its_ok_sym|
+              define_singleton_method(this_means_its_ok_sym, self.class.instance_variable_get(name).clear_fault_proc(self.class.instance_variable_get(name), problem_location))
+            end
+          end
+          if method_sequence_check_instance.second_method_arity_type == ARITY_TYPE_BLOCK_ARG
+            super(&blk)
+          elsif method_sequence_check_instance.second_method_arity_type == ARITY_TYPE_NONE
+            super()
+          end
+        end
+      end
+
+      # e.g., "select" in "select followed ARITY_TYPE_NONEze"
+     first_method_decorator = Module.new do
+        define_method(method_sequence_check_instance.method1) do |*args, &blk|
+          result = if method_sequence_check_instance.first_method_arity_type == ARITY_TYPE_BLOCK_ARG
+            super(&blk)
+          elsif method_sequence_check_instance.first_method_arity_type == ARITY_TYPE_NONE
+            super()
+          end
+          if self.class.instance_variable_get(name)
+            result.extend second_method_decorator
+            self.class.instance_variable_get(name).array_mutator_methods.each do |this_means_its_ok_sym|
+              result.define_singleton_method(this_means_its_ok_sym, self.class.instance_variable_get(name).its_ok_watcher_proc(second_method_decorator, method_sequence_check_instance.method2))
+            end
+          end
+          result
+        end
+      end
+      prepend first_method_decorator
+    end
+  end
+
+  def array_mutator_methods
+    [:collect!, :compact!, :flatten!, :map!, :reject!, :reverse!, :rotate!, :select!, :shuffle!, :slice!, :sort!, :sort_by!, :uniq!]
+  end
+
+  def its_ok_watcher_proc(clazz, method_name)
+    proc do |*args, &blk|
+      begin
+        singleton_class.ancestors.find { |x| x == clazz }.instance_eval { remove_method method_name }
+      rescue NameError
+        return super(*args, &blk)
+      else
+        return super(*args, &blk)
+      end
+    end
+  end
+end

data/lib/pippi/checks/method_sequence_finder.rb

@@ -0,0 +1,84 @@
+module Pippi::Checks
+
+  module MyModule
+    def split(&blk)
+      result = super
+      if self.class._pippi_method_call_sequences
+        array_methods_to_track.each do |track_this|
+          result.define_singleton_method(track_this, track_it_proc(track_this))
+        end
+      end
+      result
+    end
+
+    def track_it_proc(method_name)
+      location = caller_locations.find { |c| c.to_s !~ /byebug|lib\/pippi\/checks/ }
+      proc do |*args, &blk|
+        begin
+          self.class._pippi_method_call_sequences.found_sequence(method_name, location)
+        rescue NameError
+          return super(*args, &blk)
+        else
+          return super(*args, &blk)
+        end
+      end
+    end
+    
+    def string_methods_to_track
+      [:ascii_only?, :b, :between?, :bytes, :bytesize, :byteslice, :capitalize, :capitalize!, :casecmp, :center, :chars, :chomp, :chomp!, :chop, :chop!, :chr, :clear, :codepoints, :concat, :count, :crypt, :delete, :delete!, :downcase, :downcase!, :dump, :each_byte, :each_char, :each_codepoint, :each_line, :empty?, :encode, :encode!, :encoding, :end_with?, :force_encoding, :getbyte, :gsub, :gsub!, :hex, :index, :insert, :intern, :length, :lines, :ljust, :lstrip, :lstrip!, :match, :next, :next!, :oct, :ord, :partition, :replace, :reverse, :reverse!, :rindex, :rjust, :rpartition, :rstrip, :rstrip!, :scan, :scrub, :scrub!, :setbyte, :size, :slice, :slice!, :split, :squeeze, :squeeze!, :start_with?, :strip, :strip!, :sub, :sub!, :succ, :succ!, :sum, :swapcase, :swapcase!, :to_c, :to_f, :to_i, :to_r, :to_str, :to_sym, :tr, :tr!, :tr_s, :tr_s!, :unpack, :upcase, :upcase!, :upto, :valid_encoding?]      
+    end
+
+    def array_methods_to_track
+      [:all?, :any?, :assoc, :at, :bsearch, :chunk, :clear, :collect, :collect!, :collect_concat, :combination, :compact, :compact!, :concat, :count, :cycle, :delete, :delete_at, :delete_if, :detect, :drop, :drop_while, :each, :each_cons, :each_entry, :each_index, :each_slice, :each_with_index, :each_with_object, :empty?, :entries, :fetch, :fill, :find, :find_all, :find_index, :first, :flat_map, :flatten, :flatten!, :grep, :group_by, :histogram, :index, :inject, :insert, :join, :keep_if, :last, :lazy, :length, :map, :map!, :max, :max_by, :member?, :min, :min_by, :minmax, :minmax_by, :none?, :one?, :pack, :partition, :permutation, :pop, :product, :push, :rassoc, :reduce, :reject, :reject!, :repeated_combination, :repeated_permutation, :replace, :reverse, :reverse!, :reverse_each, :rindex, :rotate, :rotate!, :sample, :select, :select!, :shift, :shuffle, :shuffle!, :size, :slice, :slice!, :slice_before, :sort, :sort!, :sort_by, :sort_by!, :take, :take_while, :to_a, :to_ary, :to_h, :transpose, :uniq, :uniq!, :unshift, :values_at, :zip]
+    end
+  end
+
+  class MethodSequenceFinder < Check
+
+    class Record
+      attr_reader :path, :lineno, :meth1, :meth2
+      def initialize(path, lineno, meth1, meth2)
+        @path = path
+        @lineno = lineno
+        @meth1 = meth1
+        @meth2 = meth2
+      end
+      def eql?(other)
+        path == other.path && lineno == other.lineno && meth1 == other.meth1 && meth2 == other.meth2
+      end
+      def hash
+        require 'zlib'
+        Zlib.crc32("#{path}:#{lineno}:#{meth1}:#{meth2}")
+      end
+    end
+
+    attr_reader :sequences, :clazz_to_decorate
+
+    def initialize(ctx)
+      super
+      @clazz_to_decorate = String
+      @sequences = Set.new
+    end
+
+    def dump
+      @sequences.map {|r| "#{r.meth1}:#{r.meth2}" }.inject({}) {|m,i| m[i] ||= 0 ;  m[i] += 1  ; m }.to_a.sort_by {|x| x[1] }.reverse.each do |r|
+        puts "#{r[0].split(':')[0]} followed by #{r[0].split(':')[1]} occurred #{r[1]} times\n"
+      end
+    end
+
+    def found_sequence(method_name, location)
+      @sequences << Record.new(location.path, location.lineno, "map", method_name)
+    end
+
+    def decorate
+      clazz_to_decorate.class_exec(self) do |my_check|
+        @_pippi_method_call_sequences = my_check
+        class << self
+          attr_reader :_pippi_method_call_sequences
+        end
+        prepend MyModule
+      end
+    end
+
+  end
+end

data/lib/pippi/checks/reverse_followed_by_each.rb

@@ -1,4 +1,6 @@
 module Pippi::Checks
+
+  # TODO make this use MethodSequenceChecker
   class ReverseFollowedByEach < Check
     module MyEach
       def each

data/lib/pippi/checks/select_followed_by_any.rb

@@ -2,41 +2,13 @@ module Pippi::Checks
 
   class SelectFollowedByAny < Check
 
-    module MyAny
-      def any?(&blk)
-        self.class._pippi_check_select_followed_by_any.add_problem
-        problem_location = caller_locations.find { |c| c.to_s !~ /byebug|lib\/pippi\/checks/ }
-        self.class._pippi_check_select_followed_by_any.method_names_that_indicate_this_is_being_used_as_a_collection.each do |this_means_its_ok_sym|
-          define_singleton_method(this_means_its_ok_sym, self.class._pippi_check_select_followed_by_any.clear_fault_proc(self.class._pippi_check_select_followed_by_any, problem_location))
-        end
-        super
-      end
-    end
-
-    module MySelect
-      def select(&blk)
-        result = super
-        if self.class._pippi_check_select_followed_by_any.nil?
-          # Ignore Array subclasses since select or any may have difference meanings
-          # elsif defined?(ActiveRecord::Relation) && self.class.kind_of?(ActiveRecord::Relation) # maybe also this
-        else
-          result.extend MyAny
-          self.class._pippi_check_select_followed_by_any.array_mutator_methods.each do |this_means_its_ok_sym|
-            result.define_singleton_method(this_means_its_ok_sym, self.class._pippi_check_select_followed_by_any.its_ok_watcher_proc(MyAny, :any?))
-          end
-        end
-        result
-      end
+    def decorate
+      @mycheck.decorate
     end
 
-    def decorate
-      Array.class_exec(self) do |my_check|
-        @_pippi_check_select_followed_by_any = my_check
-        def self._pippi_check_select_followed_by_any
-          @_pippi_check_select_followed_by_any
-        end
-        prepend MySelect
-      end
+    def initialize(ctx)
+      super
+      @mycheck = MethodSequenceChecker.new(self, Array, "select", "any?", MethodSequenceChecker::ARITY_TYPE_BLOCK_ARG, MethodSequenceChecker::ARITY_TYPE_NONE, true)
     end
 
     class Documentation

data/lib/pippi/checks/select_followed_by_empty.rb

@@ -2,41 +2,13 @@ module Pippi::Checks
 
   class SelectFollowedByEmpty < Check
 
-    module MyEmpty
-      def empty?(&blk)
-        self.class._pippi_check_select_followed_by_empty.add_problem
-        problem_location = caller_locations.find { |c| c.to_s !~ /byebug|lib\/pippi\/checks/ }
-        self.class._pippi_check_select_followed_by_empty.method_names_that_indicate_this_is_being_used_as_a_collection.each do |this_means_its_ok_sym|
-          define_singleton_method(this_means_its_ok_sym, self.class._pippi_check_select_followed_by_empty.clear_fault_proc(self.class._pippi_check_select_followed_by_empty, problem_location))
-        end
-        super
-      end
-    end
-
-    module MySelect
-      def select(&blk)
-        result = super
-        if self.class._pippi_check_select_followed_by_empty.nil?
-          # Ignore Array subclasses since select or empty may have difference meanings
-          # elsif defined?(ActiveRecord::Relation) && self.class.kind_of?(ActiveRecord::Relation) # maybe also this
-        else
-          result.extend MyEmpty
-          self.class._pippi_check_select_followed_by_empty.array_mutator_methods.each do |this_means_its_ok_sym|
-            result.define_singleton_method(this_means_its_ok_sym, self.class._pippi_check_select_followed_by_empty.its_ok_watcher_proc(MyEmpty, :empty?))
-          end
-        end
-        result
-      end
+    def decorate
+      @mycheck.decorate
     end
 
-    def decorate
-      Array.class_exec(self) do |my_check|
-        @_pippi_check_select_followed_by_empty = my_check
-        def self._pippi_check_select_followed_by_empty
-          @_pippi_check_select_followed_by_empty
-        end
-        prepend MySelect
-      end
+    def initialize(ctx)
+      super
+      @mycheck = MethodSequenceChecker.new(self, Array, "select", "empty?", MethodSequenceChecker::ARITY_TYPE_BLOCK_ARG, MethodSequenceChecker::ARITY_TYPE_NONE, true)
     end
 
     class Documentation

data/lib/pippi/checks/select_followed_by_first.rb

@@ -1,5 +1,7 @@
 module Pippi::Checks
   class SelectFollowedByFirst < Check
+
+    # TODO make this use MethodSequenceChecker
     module MyFirst
       def first(elements = nil)
         unless elements

data/lib/pippi/checks/select_followed_by_none.rb

@@ -0,0 +1,28 @@
+module Pippi::Checks
+
+  class SelectFollowedByNone < Check
+
+    def decorate
+      @mycheck.decorate
+    end
+
+    def initialize(ctx)
+      super
+      @mycheck = MethodSequenceChecker.new(self, Array, "select", "none?", MethodSequenceChecker::ARITY_TYPE_BLOCK_ARG, MethodSequenceChecker::ARITY_TYPE_NONE, true)
+    end
+
+    class Documentation
+      def description
+        "Don't use select followed by none?; use none? with a block instead"
+      end
+      def sample
+        "[1,2,3].select {|x| x > 1 }.none?"
+      end
+      def instead_use
+        "[1,2,3].none? {|x| x > 1 }"
+      end
+    end
+
+  end
+
+end

data/lib/pippi/checks/select_followed_by_select.rb

@@ -2,34 +2,13 @@ module Pippi::Checks
 
   class SelectFollowedBySelect < Check
 
-    module MySecondSelect
-      def select(&blk)
-        self.class._pippi_check_select_followed_by_select.add_problem
-        super
-      end
-    end
-
-    module MyFirstSelect
-      def select(&blk)
-        result = super
-        if !self.class._pippi_check_select_followed_by_select.nil?
-          result.extend MySecondSelect
-          self.class._pippi_check_select_followed_by_select.array_mutator_methods.each do |this_means_its_ok_sym|
-            result.define_singleton_method(this_means_its_ok_sym, self.class._pippi_check_select_followed_by_select.its_ok_watcher_proc(MySecondSelect, :select))
-          end
-        end
-        result
-      end
+    def decorate
+      @mycheck.decorate
     end
 
-    def decorate
-      Array.class_exec(self) do |my_check|
-        @_pippi_check_select_followed_by_select = my_check
-        def self._pippi_check_select_followed_by_select
-          @_pippi_check_select_followed_by_select
-        end
-        prepend MyFirstSelect
-      end
+    def initialize(ctx)
+      super
+      @mycheck = MethodSequenceChecker.new(self, Array, "select", "select", MethodSequenceChecker::ARITY_TYPE_BLOCK_ARG, MethodSequenceChecker::ARITY_TYPE_BLOCK_ARG, false)
     end
 
     class Documentation

data/lib/pippi/checks/select_followed_by_size.rb

@@ -1,39 +1,13 @@
 module Pippi::Checks
   class SelectFollowedBySize < Check
-    module MySize
-      def size
-        self.class._pippi_check_select_followed_by_size.add_problem
-        problem_location = caller_locations.find { |c| c.to_s !~ /byebug|lib\/pippi\/checks/ }
-        self.class._pippi_check_select_followed_by_size.method_names_that_indicate_this_is_being_used_as_a_collection.each do |this_means_its_ok_sym|
-          define_singleton_method(this_means_its_ok_sym, self.class._pippi_check_select_followed_by_size.clear_fault_proc(self.class._pippi_check_select_followed_by_size, problem_location))
-        end
-        super()
-      end
-    end
 
-    module MySelect
-      def select(&blk)
-        result = super
-        if self.class._pippi_check_select_followed_by_size.nil?
-          # Ignore Array subclasses since select or size may have difference meanings
-        else
-          result.extend MySize
-          self.class._pippi_check_select_followed_by_size.array_mutator_methods.each do |this_means_its_ok_sym|
-            result.define_singleton_method(this_means_its_ok_sym, self.class._pippi_check_select_followed_by_size.its_ok_watcher_proc(MySize, :size))
-          end
-        end
-        result
-      end
+    def decorate
+      @mycheck.decorate
     end
 
-    def decorate
-      Array.class_exec(self) do |my_check|
-        @_pippi_check_select_followed_by_size = my_check
-        class << self
-          attr_reader :_pippi_check_select_followed_by_size
-        end
-        prepend MySelect
-      end
+    def initialize(ctx)
+      super
+      @mycheck = MethodSequenceChecker.new(self, Array, "select", "size", MethodSequenceChecker::ARITY_TYPE_BLOCK_ARG, MethodSequenceChecker::ARITY_TYPE_NONE, true)
     end
 
     class Documentation

data/lib/pippi/context.rb

@@ -1,5 +1,8 @@
 module Pippi
   class Context
+
+    attr_accessor :checks
+
     class DebugLogger
       def warn(str)
         File.open('pippi_debug.log', 'a') do |f|

data/lib/pippi/tasks.rb

@@ -4,7 +4,7 @@ module Pippi
   class Documentation
     def generate
       str = ''
-      Pippi::CheckSetMapper.new("").predefined_sets.sort.select {|k,v| v.any? }.each do |checkset_name, checks|
+      Pippi::CheckSetMapper.new("").predefined_sets.sort.select {|k,v| k != "research" && v.any? }.each do |checkset_name, checks|
         str << "### #{checkset_name}\n"
         checks.sort.each do |check|
           obj = Object.const_get("Pippi::Checks::#{check}::Documentation").new

data/lib/pippi/version.rb

@@ -1,3 +1,3 @@
 module Pippi
-  VERSION = '0.0.9'
+  VERSION = '0.0.10'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pippi
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - Tom Copeland
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-05 00:00:00.000000000 Z
+date: 2014-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -73,10 +73,13 @@ files:
 - lib/pippi/checks/check.rb
 - lib/pippi/checks/debug_check.rb
 - lib/pippi/checks/map_followed_by_flatten.rb
+- lib/pippi/checks/method_sequence_checker.rb
+- lib/pippi/checks/method_sequence_finder.rb
 - lib/pippi/checks/reverse_followed_by_each.rb
 - lib/pippi/checks/select_followed_by_any.rb
 - lib/pippi/checks/select_followed_by_empty.rb
 - lib/pippi/checks/select_followed_by_first.rb
+- lib/pippi/checks/select_followed_by_none.rb
 - lib/pippi/checks/select_followed_by_select.rb
 - lib/pippi/checks/select_followed_by_size.rb
 - lib/pippi/context.rb