polishgeeks-dev-tools 1.1.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f4c7e5f2ebd0f096a10ac590409dd86df64cb6b0
-  data.tar.gz: c2a9424bac6e6719c716ce3f1dab75cbe933ebf3
+  metadata.gz: 1b6c0bc8902d3041b3290e9203d08670b816f81d
+  data.tar.gz: 37da8e02f5fbea0ce3f33c8ff892230b4937aa56
 SHA512:
-  metadata.gz: 56b7f225f663f401a4c89f486f3cab8627ba84e6cab5b6d0c2a6a0d7f37b7ecce6e843b2bb7225ea1abc0e0d00cde28594e9baf01d4937d1e9f6c88618758a77
-  data.tar.gz: 753bd5caff7b3183e938f175342d52eee52a2bb3d7a130e252838a522934ed974b3b2d1bcffa10a20951c0209a02a3187dfc3e9db7d9396fd8d36313172bde89
+  metadata.gz: dbf1e6be185a824c260365d8a6b872f579cd566d2dd20dc4de9fbdea41d30eb82e2739668f8c3775ac5a83cbfaef144b1a0d5bb047324696fa30964751e56f43
+  data.tar.gz: 4d0aa7a04328efe66cdc50b8e1e26b28bd1f81e8a29fed363dd40140b64caea9317102d511e291c0ba3e7bfd3463272d817113b047eec830e304bd9d1805646f

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 # PolishGeeks Dev Tools Changelog
 
+## 1.1.3
+- Added EmptyMethod command which checks if some files have empty methods
+
 ## 1.1.2
 
 - Ignore .DS_Store files in FinalBlankLine validator.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polishgeeks-dev-tools (1.1.2)
+    polishgeeks-dev-tools (1.1.3)
       brakeman
       faker
       haml-lint
@@ -38,16 +38,17 @@ GEM
       descendants_tracker (~> 0.0.4)
       ice_nine (~> 0.11.0)
       thread_safe (~> 0.3, >= 0.3.1)
-    brakeman (3.0.5)
+    brakeman (3.1.0)
       erubis (~> 2.6)
       fastercsv (~> 1.5)
       haml (>= 3.0, < 5.0)
-      highline (~> 1.6.20)
+      highline (~> 1.6)
       multi_json (~> 1.2)
-      ruby2ruby (~> 2.1.1)
+      ruby2ruby (>= 2.1.1, < 2.3.0)
       ruby_parser (~> 3.7.0)
       sass (~> 3.0)
-      terminal-table (~> 1.4)
+      slim (>= 1.3.6, < 4.0)
+      terminal-table (~> 1.4.5)
     bson (3.2.1)
     builder (3.2.2)
     coderay (1.1.0)
@@ -78,7 +79,7 @@ GEM
       haml (~> 4.0)
       rubocop (>= 0.25.0)
       sysexits (~> 1.1)
-    highline (1.6.21)
+    highline (1.7.3)
     i18n (0.7.0)
     ice_nine (0.11.1)
     json (1.8.3)
@@ -129,14 +130,14 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.3.0)
     rspec-support (3.3.0)
-    rubocop (0.33.0)
+    rubocop (0.34.0)
       astrolabe (~> 1.3)
       parser (>= 2.2.2.5, < 3.0)
       powerpack (~> 0.1)
       rainbow (>= 1.99.1, < 3.0)
       ruby-progressbar (~> 1.4)
     ruby-progressbar (1.7.5)
-    ruby2ruby (2.1.4)
+    ruby2ruby (2.2.0)
       ruby_parser (~> 3.1)
       sexp_processor (~> 4.0)
     ruby_parser (3.7.1)
@@ -161,9 +162,13 @@ GEM
       json (~> 1.8)
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.0)
+    slim (3.0.6)
+      temple (~> 0.7.3)
+      tilt (>= 1.3.3, < 2.1)
     slop (3.6.0)
     sysexits (1.2.0)
-    terminal-table (1.5.2)
+    temple (0.7.6)
+    terminal-table (1.4.5)
     thread_safe (0.3.5)
     tilt (2.0.1)
     timecop (0.8.0)

data/README.md

@@ -51,6 +51,7 @@ determine, which you can use in your project:
 | brakeman              | Rails     | A static analysis security vulnerability scanner for Ruby on Rails                    |
 | rubocop               | -         | Used to check Ruby syntax according to our styling                                    |
 | final_blank_line      | -         | Check if all files have final blank line                                              |
+| empty_method          | -         | Check if some files have empty methods                                                 |
 | expires_in            | -         | Checks if there are typos like expire_in, etc that might brake app caching            |
 | haml_lint             | -         | User to check HAML syntax in the app views                                            |
 | yard                  | -         | YARD documentation standards checking                                                 |
@@ -74,6 +75,7 @@ Some validators might accept additional config settings - please refer to this t
 |-------------------------------|-----------------------|-------------------------------------------------------------------------------------------------------------|
 | rspec_files_structure_ignored | rspec_files_structure | You can provide an array of files that should be ignored                                                    |
 | final_blank_line_ignored      | final_blank_line      | You can provide an array of files (ex. lib/file.rb) or directories (ex. lib/command) that should be ignored |
+| empty_method_ignored          | empty_method          | You can provide an array of files (ex. lib/file.rb) or directories (ex. lib/command) that should be ignored |
 
 ## Usage in any Rails/Ruby application
 

data/Rakefile

@@ -10,6 +10,10 @@ task :check do
     config.expires_in_files_ignored = %w(
       lib/polishgeeks/dev-tools/command/expires_in.rb
     )
+    config.empty_method_ignored = %w(
+      empty_method_spec.rb
+      file_parser_spec.rb
+    )
   end
 
   PolishGeeks::DevTools::Runner.new.execute(

data/lib/polishgeeks-dev-tools.rb

@@ -36,8 +36,13 @@ module PolishGeeks
 end
 
 require 'polishgeeks/dev-tools/command/base'
+require 'polishgeeks/dev-tools/command/empty_method'
+require 'polishgeeks/dev-tools/command/empty_method/string_refinements'
 
 commands_path = File.dirname(__FILE__) + '/polishgeeks/dev-tools/command/*.rb'
 Dir[commands_path].each { |file| require file }
 
+commands_path = File.dirname(__FILE__) + '/polishgeeks/dev-tools/command/**/*.rb'
+Dir[commands_path].each { |file| require file }
+
 load 'polishgeeks/dev-tools/tasks/dev-tools.rake'

data/lib/polishgeeks/dev-tools/command/empty_method.rb

@@ -0,0 +1,104 @@
+module PolishGeeks
+  module DevTools
+    module Command
+      # Validator used to check if all '.rb' files don't have empty methods
+      class EmptyMethod < Base
+        self.type = :validator
+
+        attr_reader :counter
+
+        # Default paths which we want to exclude from analyse
+        DEFAULT_PATHS_TO_EXCLUDE = %w(
+          coverage
+          tmp
+          doc
+          log
+          vendor
+          public
+          app/assets/images
+          app/assets/fonts
+        )
+
+        # Executes this command and set output and counter variables
+        def execute
+          @output = []
+          @counter = 0
+
+          files_to_analyze.each do |file|
+            @counter += 1
+            empty_methods = FileParser.new(file).find_empty_methods
+            @output << sanitize(file) + " lines #{empty_methods}" unless empty_methods.empty?
+          end
+        end
+
+        # @return [Boolean] true if none of the files include any empty methods
+        def valid?
+          output.empty?
+        end
+
+        # @return [String] default label for this command
+        def label
+          "Empty methods: #{counter} files checked"
+        end
+
+        # @return [String] message that should be printed when some files have
+        # empty methods
+        def error_message
+          "Following files contains blank methods: \n#{output.join("\n")}\n"
+        end
+
+        private
+
+        # @return [Array<String>] array with files to analyze
+        # @note method take all not excluded files
+        def files_to_analyze
+          files = files_from_path('**/*.rb')
+          remove_excludes files
+        end
+
+        # @param [Array<String>] files list which we want analyse
+        # @return [Array<String>] array without excluded files
+        def remove_excludes(files)
+          excluded_paths = excludes
+
+          files.delete_if do |file|
+            excluded_paths.any? { |exclude| file =~ /#{exclude}/ }
+          end
+        end
+
+        # @return [Array<String>] list of files/directories that
+        #   should be excluded from checking
+        # @note excluded files/directories are defined in DEFAULT_PATHS_TO_EXCLUDE
+        #   and in configuration file
+        def excludes
+          config_excludes + DEFAULT_PATHS_TO_EXCLUDE
+        end
+
+        # @return [Array<String>] list of excluded files/directories from config file
+        def config_excludes
+          DevTools.config.empty_method_ignored || []
+        end
+
+        # @param [String] path from which we want take files
+        # @return [Array<String>] list of files in path with app prefix path
+        # @note if path is a file return array with file path with app prefix path
+        def files_from_path(path)
+          full_path = "#{::PolishGeeks::DevTools.app_root}/#{path}"
+          return [full_path] if File.file?(full_path)
+
+          Dir.glob(full_path).select { |f| File.file? f }
+        end
+
+        # @param [String] file name that we want to sanitize
+        # @return [String] sanitized file name
+        # @example
+        #   file = /home/something/app/lib/lib.rb,
+        #   where /home/something/app/ is a app root path, then
+        #   sanitize(file) #=> lib/lib.rb
+        def sanitize(file)
+          file.gsub("#{PolishGeeks::DevTools.app_root}/", '')
+        end
+      end
+    end
+  end
+end

data/lib/polishgeeks/dev-tools/command/empty_method/file_parser.rb

@@ -0,0 +1,74 @@
+module PolishGeeks
+  module DevTools
+    module Command
+      class EmptyMethod
+        # Parse file and search whether it contain empty methods
+        class FileParser
+          attr_reader :empty_methods
+          using StringRefinements
+
+          def initialize(file)
+            @file = IO.readlines(file)
+            @empty_methods = []
+          end
+
+          # @return [Array<Fixnum>] list of lines where empty methods are defined
+          # @example
+          #   file = " class Example
+          #     def empty_method; end
+          #   end
+          #   "
+          #   FileParser.new(file).find_empty_methods => [2]
+          #
+          #   file = ""
+          #   FileParser.new(file).find_empty_methods => []
+          def find_empty_methods
+            @file.each_with_index do |line, index|
+              next add_empty_method(index) if line.one_line_empty_method?
+              check_bodies_existence(line, index)
+            end
+            empty_methods
+          end
+
+          private
+
+          # Adds line of empty method definition to array of empty_methods
+          # Remembers line where method is defined; search end of method definition
+          # and check whether body of method is empty or not.
+          # @param [String] line line to parse for empty methods definition
+          # @param [Fixnum] index index of line in file
+          def check_bodies_existence(line, index)
+            @method_definition_line = index if line.defines_method?
+            return unless @method_definition_line && line.defines_end?
+
+            if method_has_no_lines?(@method_definition_line, index)
+              return add_empty_method(@method_definition_line)
+            end
+
+            body_lines = (@method_definition_line + 1)..(index - 1)
+            method_body = @file[body_lines]
+
+            add_empty_method(@method_definition_line) if method_is_empty?(method_body)
+            @method_definition_line = nil
+          end
+
+          # @param [Array<String>] method_body
+          # @return [Boolean] whether method is empty or not
+          def method_is_empty?(method_body)
+            !method_body.inject(false) { |a, e| a || e.not_commented_or_empty? }
+          end
+
+          # Adds line number of empty method to empty_methods.
+          # @param [Fixnum] index index of line
+          def add_empty_method(index)
+            empty_methods << index + 1
+          end
+
+          def method_has_no_lines?(body_begin, body_end)
+            body_end - body_begin < 2
+          end
+        end
+      end
+    end
+  end
+end

data/lib/polishgeeks/dev-tools/command/empty_method/string_refinements.rb

@@ -0,0 +1,45 @@
+module PolishGeeks
+  module DevTools
+    module Command
+      class EmptyMethod
+        # Adds ability to check strings on specific regex matching
+        module StringRefinements
+          # Regex to determine commented or empty string
+          COMMENTED_OR_EMPTY = /^\s*(|#.*)$/
+          # Regex to determine definition of method with 'def'
+          DEFINITION_OF_METHOD = /^\s*def\s+\w*(\s*|\s*#.*)$/
+          # Regex to determine empty one-line method
+          EMPTY_ONE_LINE_METHOD = /^\s*def\s+.*;\s*end\s*(\s+|#.*|\n|$)$/
+          # Regex to determine end of method
+          END_REGEX = /^\s*end(\.\w+(\s+|$)|\s*#.+|\s+|$)\s*/
+          # Regex to determine begin of method definition through define_method
+          DEFINE_METHOD = '^\s*(define_method|define_singleton_method)'
+          # Regex to determine definition of method with do-end block
+          DEFINE_METHOD_WITH_DO_END =
+            /#{DEFINE_METHOD}(\s+|\().*do(\s*(\s*|.*\|\s*))(\s*|#.*)$/
+          # Regex to determine empty one-line methods
+          EMPTY_ONE_LINE_DEFINE_METHODS =
+            /#{DEFINE_METHOD}.+\s+({\s*)\s*((\|.*\|\s+})|})(\s+|\n|#|$|\.)/
+
+          refine String do
+            def one_line_empty_method?
+              match(EMPTY_ONE_LINE_METHOD) || match(EMPTY_ONE_LINE_DEFINE_METHODS)
+            end
+
+            def defines_method?
+              match(DEFINITION_OF_METHOD) || match(DEFINE_METHOD_WITH_DO_END)
+            end
+
+            def defines_end?
+              match END_REGEX
+            end
+
+            def not_commented_or_empty?
+              match(COMMENTED_OR_EMPTY).nil?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/polishgeeks/dev-tools/command/final_blank_line.rb

@@ -18,6 +18,7 @@ module PolishGeeks
           app/assets/images
           app/assets/fonts
           .DS_Store
+          .gem
         )
 
         # Executes this command and set output and counter variables

data/lib/polishgeeks/dev-tools/config.rb

@@ -26,6 +26,7 @@ module PolishGeeks
         rspec_files_structure
         expires_in_files
         final_blank_line
+        empty_method
       ).each do |attr|
         attr_accessor "#{attr}_ignored"
       end
@@ -38,6 +39,7 @@ module PolishGeeks
         brakeman
         rubocop
         final_blank_line
+        empty_method
         haml_lint
         allowed_extensions
         yml_parser

data/lib/polishgeeks/dev-tools/runner.rb

@@ -14,7 +14,7 @@ module PolishGeeks
         Config::COMMANDS.each do |command|
           next unless DevTools.config.public_send(:"#{command}?")
 
-          klass = command.to_s.gsub(/(?<=_|^)(\w)/) { |el| el.upcase }.gsub(/(?:_)(\w)/, '\1')
+          klass = command.to_s.gsub(/(?<=_|^)(\w)/, &:upcase).gsub(/(?:_)(\w)/, '\1')
           cmd = Object.const_get("PolishGeeks::DevTools::Command::#{klass}").new
           cmd.stored_output = output
           cmd.execute

data/lib/polishgeeks/dev-tools/version.rb

@@ -3,6 +3,6 @@ module PolishGeeks
   # Dev Tools for PolishGeeks developers
   module DevTools
     # Current version of dev tools
-    VERSION = '1.1.2'
+    VERSION = '1.1.3'
   end
 end

data/spec/lib/polishgeeks/dev-tools/command/empty_method/file_parser_spec.rb

@@ -0,0 +1,194 @@
+RSpec.describe PolishGeeks::DevTools::Command::EmptyMethod::FileParser do
+  let(:file) { Tempfile.new('foo') }
+  subject { described_class.new(file) }
+
+  describe '#find_empty_methods' do
+    context 'empty define_singleton_methods' do
+      before do
+        file.write("
+          define_singleton_method(:a) {}
+
+          define_singleton_method('b') { |_a, _b| }
+          define_singleton_method :c do |_a, _b|
+            #
+            #
+          end
+
+          define_singleton_method :d do |_a, _b|
+          end
+          ")
+        file.read
+      end
+
+      it { expect(subject.find_empty_methods).to eq([2, 4, 5, 10]) }
+    end
+
+    context 'empty define_methods with comments' do
+      before do
+        file.write("
+          define_method(:a) {} # comment
+
+          define_method('b') { |_a, _b| } # comment
+          define_method :c do |_a, _b| # comment
+            #
+          end
+          ")
+        file.read
+      end
+
+      it { expect(subject.find_empty_methods).to eq([2, 4, 5]) }
+    end
+
+    context 'empty define_methods' do
+      before do
+        file.write("
+          define_method(:a) {}
+
+          define_method('b') { |_a, _b| }
+          define_method :c do |_a, _b|
+            #
+          end
+          ")
+        file.read
+      end
+
+      it { expect(subject.find_empty_methods).to eq([2, 4, 5]) }
+    end
+
+    context 'singleton_methods and methods are defined' do
+      before do
+        file.write("
+          define_singleton_method(:a) { puts rand(5) }
+
+          define_singleton_method(:ab) { |_a, _b| rand(5) }
+          define_singleton_method :c do |_a, _b|
+            rand(5)
+          end
+          define_method(:d) { puts rand(5) }
+
+          define_method(:e) { |_a, _b| rand(5) }
+          define_method :f do |_a, _b|
+            # comment
+            # comment
+            rand(5)
+          end")
+        file.read
+      end
+
+      it { expect(subject.find_empty_methods).to be_empty }
+    end
+
+    context 'empty one line method' do
+      before do
+        file.write(' def a; end ')
+        file.read
+      end
+
+      it { expect(subject.find_empty_methods).to eq([1]) }
+    end
+
+    context 'empty one line method with comment' do
+      before do
+        file.write(' def a; end #comment ')
+        file.read
+      end
+
+      it { expect(subject.find_empty_methods).to eq([1]) }
+    end
+
+    context 'empty body method' do
+      before do
+        file.write(" def a
+                     end ")
+        file.read
+      end
+
+      it { expect(subject.find_empty_methods).to eq([1]) }
+    end
+
+    context 'empty body method with comment' do
+      before do
+        file.write(" def a # comment
+                     end #comment")
+        file.read
+      end
+
+      it { expect(subject.find_empty_methods).to eq([1]) }
+    end
+
+    context 'empty method' do
+      before do
+        file.write(" def a
+                      #
+
+                      #
+                     end ")
+        file.read
+      end
+
+      it { expect(subject.find_empty_methods).to eq([1]) }
+    end
+
+    context 'method with comments inside' do
+      before do
+        file.write(" def a
+                      # comment
+                      # comment
+                      # comment
+                      rand(10)
+                     end ")
+        file.read
+      end
+
+      it { expect(subject.find_empty_methods).to be_empty }
+    end
+
+    context 'method which defines empty define_method inside' do
+      before do
+        file.write(" def a
+                      define_method(:asd) {}
+                     end ")
+        file.read
+      end
+
+      it { expect(subject.find_empty_methods).to eq([2]) }
+    end
+
+    context 'method which defines empty define_singleton_method inside' do
+      before do
+        file.write(" def a
+                      define_singleton_method(:asd) do
+                        # comment
+                      end
+                     end ")
+        file.read
+      end
+
+      it { expect(subject.find_empty_methods).to eq([2]) }
+    end
+
+    context 'method which defines define_method inside' do
+      before do
+        file.write(" def a
+                      define_method(:asd) { rand(150) } #
+                     end ")
+        file.read
+      end
+
+      it { expect(subject.find_empty_methods).to be_empty }
+    end
+  end
+
+  describe '#method_has_no_lines?' do
+    it { expect(subject.send(:method_has_no_lines?, 2, 4)).to be_falsey }
+    it { expect(subject.send(:method_has_no_lines?, 2, 3)).to be_truthy }
+  end
+
+  describe '#add_empty_method' do
+    it { expect(subject.send(:add_empty_method, 2)).to eq [3] }
+  end
+
+  describe '#add_empty_method' do
+    it { expect(subject.send(:add_empty_method, 2)).to eq [3] }
+  end
+end

data/spec/lib/polishgeeks/dev-tools/command/empty_method/string_refinements_spec.rb

@@ -0,0 +1,167 @@
+RSpec.describe PolishGeeks::DevTools::Command::EmptyMethod::StringRefinements do
+  using described_class
+
+  describe '#defines_method?' do
+    context 'def method' do
+      line = '  def method_for_calculation'
+
+      it { expect(line.defines_method?).to be_truthy }
+    end
+
+    context 'define_method method without whitespace after' do
+      line = '  define_method(:method_for_calculation) do'
+
+      it { expect(line.defines_method?).to be_truthy }
+    end
+
+    context 'define_method method symbol definition' do
+      line = '  define_method :method_for_calculation do'
+
+      it { expect(line.defines_method?).to be_truthy }
+    end
+
+    context 'define_method method with string definition' do
+      line = '  define_method ("method_for_calculation") do'
+
+      it { expect(line.defines_method?).to be_truthy }
+    end
+
+    context 'define_method method with comment' do
+      line = '  define_method (:method_for_calculation) do #comment'
+
+      it { expect(line.defines_method?).to be_truthy }
+    end
+
+    context 'define_method method with params' do
+      line = '  define_method (:method_for_calculation) do |a, b| '
+
+      it { expect(line.defines_method?).to be_truthy }
+    end
+
+    context 'define_method method with params and comment' do
+      line = '  define_method (:method_for_calculation) do |a, b| #comment'
+
+      it { expect(line.defines_method?).to be_truthy }
+    end
+
+    context 'string that is not method definition' do
+      line = '  define_methods(:method_for_calculation) do |a, b| #comment'
+
+      it { expect(line.defines_method?).to be_falsey }
+    end
+
+    context 'string that is not method definition' do
+      line = '  define_methods (:method_for_calculation) do |a, b| '
+
+      it { expect(line.defines_method?).to be_falsey }
+    end
+  end
+
+  describe '#one_line_empty_method?' do
+    context 'def method' do
+      line = '  def method_for_calculation; end'
+
+      it { expect(line.one_line_empty_method?).to be_truthy }
+    end
+
+    context 'def method with comment' do
+      line = '  def method_for_calculation; end # comment'
+
+      it { expect(line.one_line_empty_method?).to be_truthy }
+    end
+
+    context 'define_method method' do
+      line = '  define_method :method_for_calculation {} '
+
+      it { expect(line.one_line_empty_method?).to be_truthy }
+    end
+
+    context 'define_method method with comment' do
+      line = '  define_method(:method_for_calculation) {} # comment'
+
+      it { expect(line.one_line_empty_method?).to be_truthy }
+    end
+
+    context 'define_method method with name as string' do
+      line = '  define_method "method_for_calculation" {} '
+
+      it { expect(line.one_line_empty_method?).to be_truthy }
+    end
+
+    context 'define_method method with block' do
+      line = '  define_method :method_for_calculation { |_a, _b| } # comment'
+
+      it { expect(line.one_line_empty_method?).to be_truthy }
+    end
+
+    context 'define_method method with block' do
+      line = '  define_method :method_for_calculation { |_a, _b| "5" } # comment'
+
+      it { expect(line.one_line_empty_method?).to be_falsey }
+    end
+
+    context 'not empty define_method method' do
+      line = '  define_method :method_for_calculation { 5 } # comment'
+
+      it { expect(line.one_line_empty_method?).to be_falsey }
+    end
+
+    context 'not empty def method' do
+      line = '  def method_for_calculation;  5 end # comment'
+
+      it { expect(line.one_line_empty_method?).to be_falsey }
+    end
+  end
+
+  describe '#defines_end?' do
+    context 'end' do
+      line = 'end'
+
+      it { expect(line.defines_end?).to be_truthy }
+    end
+
+    context 'end with method call' do
+      line = 'end.compact'
+
+      it { expect(line.defines_end?).to be_truthy }
+    end
+
+    context 'end with comment' do
+      line = 'end.compact # compacts result array'
+
+      it { expect(line.defines_end?).to be_truthy }
+    end
+
+    context 'end is commented' do
+      line = '# end'
+
+      it { expect(line.defines_end?).to be_falsey }
+    end
+
+    context 'similar words' do
+      line = 'ends'
+
+      it { expect(line.defines_end?).to be_falsey }
+    end
+  end
+
+  describe '#not_commented_or_empty?' do
+    context 'empty line' do
+      line = '  '
+
+      it { expect(line.not_commented_or_empty?).to be_falsey }
+    end
+
+    context 'commented line' do
+      line = ' # commented line '
+
+      it { expect(line.not_commented_or_empty?).to be_falsey }
+    end
+
+    context 'commented line' do
+      line = ' line '
+
+      it { expect(line.not_commented_or_empty?).to be_truthy }
+    end
+  end
+end

data/spec/lib/polishgeeks/dev-tools/command/empty_method_spec.rb

@@ -0,0 +1,212 @@
+require 'spec_helper'
+require 'tempfile'
+
+RSpec.describe PolishGeeks::DevTools::Command::EmptyMethod do
+  subject { described_class.new }
+  describe '#execute' do
+    let(:file) { [rand.to_s] }
+
+    before do
+      expect(subject)
+        .to receive(:files_to_analyze)
+        .and_return(file)
+      allow(described_class::FileParser)
+        .to receive_message_chain(:new, :find_empty_methods)
+        .and_return(empty_methods)
+    end
+
+    context 'when all files are valid' do
+      let(:empty_methods) { [] }
+      before do
+        subject.execute
+      end
+
+      it 'should set appropriate variables' do
+        expect(subject.output).to eq []
+        expect(subject.counter).to eq(file.count)
+      end
+    end
+
+    context 'when exist not valid file' do
+      let(:empty_methods) { [rand.to_s, rand.to_s] }
+      before do
+        expect(subject)
+          .to receive(:sanitize)
+          .with(file.first)
+          .and_return(file.first)
+        subject.execute
+      end
+
+      it 'should set appropriate variables' do
+        expect(subject.output.first).to eq "#{file.first} lines #{empty_methods}"
+        expect(subject.counter).to eq(file.count)
+      end
+    end
+  end
+
+  describe '#valid?' do
+    before do
+      subject.instance_variable_set('@output', output)
+    end
+
+    context 'when output is empty' do
+      let(:output) { [] }
+
+      it { expect(subject.valid?).to eq true }
+    end
+
+    context 'when output have some files' do
+      let(:output) { ['file_name'] }
+
+      it { expect(subject.valid?).to eq false }
+    end
+  end
+
+  describe '#label' do
+    let(:counter) { rand(10) }
+    let(:expected) { "Empty methods: #{counter} files checked" }
+
+    before do
+      subject.instance_variable_set('@counter', counter)
+    end
+
+    it { expect(subject.label).to eq expected }
+  end
+
+  describe '#error_message' do
+    let(:output) { [rand.to_s, rand.to_s] }
+    let(:expected) { "Following files contains blank methods: \n#{output.join("\n")}\n" }
+
+    before do
+      subject.instance_variable_set('@output', output)
+    end
+
+    it { expect(subject.error_message).to eq expected }
+  end
+
+  describe '#files_to_analyze' do
+    let(:files) { [rand.to_s, rand.to_s] }
+
+    before do
+      expect(subject)
+        .to receive(:files_from_path)
+        .with('**/*.rb')
+        .and_return(files)
+
+      expect(subject)
+        .to receive(:remove_excludes)
+        .with(files)
+        .and_return(files)
+    end
+
+    it { expect(subject.send(:files_to_analyze)).to eq files }
+  end
+
+  describe '#remove_excludes' do
+    let(:files) { %w(lib/file.txt exclude.txt file.rb) }
+    let(:excludes) { %w(lib exclude.txt) }
+
+    before do
+      expect(subject)
+        .to receive(:excludes)
+        .and_return(excludes)
+    end
+
+    it { expect(subject.send(:remove_excludes, files)).to eq ['file.rb'] }
+  end
+
+  describe '#excludes' do
+    let(:configs) { [rand.to_s] }
+    let(:expected) { configs + described_class::DEFAULT_PATHS_TO_EXCLUDE }
+
+    before do
+      expect(subject)
+        .to receive(:config_excludes)
+        .and_return(configs)
+    end
+
+    it { expect(subject.send(:excludes)).to eq expected }
+  end
+
+  describe '#config_excludes' do
+    context 'empty_method_ignored is set' do
+      let(:paths) { ["#{rand}.rb", "#{rand}.rb"] }
+      let(:config) { double(empty_method_ignored: paths) }
+
+      before do
+        expect(PolishGeeks::DevTools)
+          .to receive(:config)
+          .and_return config
+      end
+
+      it { expect(subject.send(:config_excludes)).to eq paths }
+    end
+
+    context 'empty_method_ignored is not set' do
+      let(:config) { double(empty_method_ignored: nil) }
+
+      before do
+        expect(PolishGeeks::DevTools)
+          .to receive(:config)
+          .and_return config
+      end
+
+      it { expect(subject.send(:config_excludes)).to eq [] }
+    end
+  end
+
+  describe '#files_from_path' do
+    let(:app_root) { PolishGeeks::DevTools.app_root }
+
+    context 'path is a directory' do
+      let(:path) { rand.to_s }
+      let(:file_in_path) { "#{app_root}/#{rand}" }
+      let(:dir_in_path) { "#{app_root}/#{rand}" }
+
+      before do
+        expect(File)
+          .to receive(:file?)
+          .with("#{app_root}/#{path}")
+          .and_return(false)
+
+        expect(Dir)
+          .to receive(:glob)
+          .with("#{app_root}/#{path}")
+          .and_return([file_in_path, dir_in_path])
+
+        expect(File)
+          .to receive(:file?)
+          .with(file_in_path)
+          .and_return(true)
+
+        expect(File)
+          .to receive(:file?)
+          .with(dir_in_path)
+          .and_return(false)
+      end
+
+      it { expect(subject.send(:files_from_path, path)).to eq [file_in_path] }
+    end
+
+    context 'path is a file' do
+      let(:path) { rand.to_s }
+
+      before do
+        expect(File)
+          .to receive(:file?)
+          .with("#{app_root}/#{path}")
+          .and_return(true)
+      end
+
+      it { expect(subject.send(:files_from_path, path)).to eq ["#{app_root}/#{path}"] }
+    end
+  end
+
+  describe '#sanitize' do
+    let(:file) { rand.to_s }
+    let(:app_root) { PolishGeeks::DevTools.app_root }
+    let(:path) { "#{app_root}/#{file}" }
+
+    it { expect(subject.send(:sanitize, "#{app_root}/#{path}")).to eq file }
+  end
+end

data/spec/lib/polishgeeks/dev-tools/runner_spec.rb

@@ -21,7 +21,7 @@ RSpec.describe PolishGeeks::DevTools::Runner do
       PolishGeeks::DevTools::Config::COMMANDS.each do |command|
         config.public_send(:"#{command}=", true)
 
-        klass_name = command.to_s.gsub(/(?<=_|^)(\w)/) { |el| el.upcase }.gsub(/(?:_)(\w)/, '\1')
+        klass_name = command.to_s.gsub(/(?<=_|^)(\w)/, &:upcase).gsub(/(?:_)(\w)/, '\1')
         klass = Object.const_get("PolishGeeks::DevTools::Command::#{klass_name}")
 
         instance = double

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polishgeeks-dev-tools
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.3
 platform: ruby
 authors:
 - Maciej Mensfeld
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-31 00:00:00.000000000 Z
+date: 2015-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -230,6 +230,9 @@ files:
 - lib/polishgeeks/dev-tools/command/base.rb
 - lib/polishgeeks/dev-tools/command/brakeman.rb
 - lib/polishgeeks/dev-tools/command/coverage.rb
+- lib/polishgeeks/dev-tools/command/empty_method.rb
+- lib/polishgeeks/dev-tools/command/empty_method/file_parser.rb
+- lib/polishgeeks/dev-tools/command/empty_method/string_refinements.rb
 - lib/polishgeeks/dev-tools/command/examples_comparator.rb
 - lib/polishgeeks/dev-tools/command/expires_in.rb
 - lib/polishgeeks/dev-tools/command/final_blank_line.rb
@@ -258,6 +261,9 @@ files:
 - spec/lib/polishgeeks/dev-tools/command/base_spec.rb
 - spec/lib/polishgeeks/dev-tools/command/brakeman_spec.rb
 - spec/lib/polishgeeks/dev-tools/command/coverage_spec.rb
+- spec/lib/polishgeeks/dev-tools/command/empty_method/file_parser_spec.rb
+- spec/lib/polishgeeks/dev-tools/command/empty_method/string_refinements_spec.rb
+- spec/lib/polishgeeks/dev-tools/command/empty_method_spec.rb
 - spec/lib/polishgeeks/dev-tools/command/examples_comparator_spec.rb
 - spec/lib/polishgeeks/dev-tools/command/expires_in_spec.rb
 - spec/lib/polishgeeks/dev-tools/command/final_blank_line_spec.rb
@@ -309,6 +315,9 @@ test_files:
 - spec/lib/polishgeeks/dev-tools/command/base_spec.rb
 - spec/lib/polishgeeks/dev-tools/command/brakeman_spec.rb
 - spec/lib/polishgeeks/dev-tools/command/coverage_spec.rb
+- spec/lib/polishgeeks/dev-tools/command/empty_method/file_parser_spec.rb
+- spec/lib/polishgeeks/dev-tools/command/empty_method/string_refinements_spec.rb
+- spec/lib/polishgeeks/dev-tools/command/empty_method_spec.rb
 - spec/lib/polishgeeks/dev-tools/command/examples_comparator_spec.rb
 - spec/lib/polishgeeks/dev-tools/command/expires_in_spec.rb
 - spec/lib/polishgeeks/dev-tools/command/final_blank_line_spec.rb
@@ -331,3 +340,4 @@ test_files:
 - spec/lib/polishgeeks/dev-tools/shell_spec.rb
 - spec/lib/polishgeeks/dev-tools/version_spec.rb
 - spec/spec_helper.rb
+has_rdoc: