sandi_meter 0.0.1 → 0.0.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    YTQyYTQ2NWQ4ODBhYjNmMzVmNGU5NzJkOTI1ZjhkZTBkODZkNDEyNA==
+    NzI2Nzc1NDI0OWYyNTExZTJjMGViMWQ2YmNkNzU3YmNhNWU5YmM0MQ==
   data.tar.gz: !binary |-
-    Yzk5MjM2ZTdiODY5ZjcyN2YyNTNjYWRjODBiMWI3MzQyYzkxMzdkNg==
+    Njg4MzcxYmMyMDhiOTBhNTJjYTE1MzFhYWM5Yjc0ZWU2YjgyZGE0NA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NmNlNWU0MGQzODYwY2RmMDQ4ZTY4NjZmNWJhN2I5MDU2MzhlMzhjNmI0ZTM1
-    NmIwNzhmNWViNTFiMjExZjQ2ZWZhY2Y1N2JhMGE4ZmEzYWY4OWRmMTdlMTE5
-    NjZmMjcxNzJkNTAwYjcwNWFjY2IwMzk5YTAxZjI3YTU2ZWFiMjI=
+    YTI5YzRhNDExYTg5MTg2ZGUyM2E4NGI0ODE5MjI5YjY1MTg5MTQ1MDNmYTM1
+    NzM2NWU2Y2ZlZGQxNmZlMzIyMmE4ZDI3MjgzY2E1MDYzMWIzZTRjMTI4MDQ4
+    M2Y5MWZhYTA5MzZlM2NjMDk3ZTM2OTI4Y2UyMWM4ZWUwMmNjYWU=
   data.tar.gz: !binary |-
-    ZDBlYmZiZjI0OGI0Y2Y0MTAzY2YxNTE4YjNhZTgxYzdhOTdhMzc2MzI1M2M2
-    OTdmMWU0NzZjNWE1NTZmNGViMjA2Y2IwOTkyMGY3ZmUyN2ZlY2RkZTQ4ZDA0
-    MmEyYzUxZGU3ZjE3NWU5NmVkZGU1MDUzY2M0NTFmOWZmYjczZTQ=
+    ZDExZWRiZTA3ODQ1YWY5YTA0NGY4NzZkYzc5YWE5NTNhODBhYzI5M2RlYTkz
+    NzMwMzE1NDJhZjE5OTI3MWVkNzhmMTVmOGY0NmM0Y2MwYmI5MmZjYTJlYmRl
+    MWE4NTVlNmRkNDI2NzJiYzU0NWE0MWEwMTFjMDVmZGZiNDA4YTc=

data/README.md

@@ -5,11 +5,37 @@ Static analysis tool for checking your Ruby code for [Sandi Metz' for rules](htt
 * 100 lines per class
 * 5 lines per method
 * 4 params per method call (and don't even try cheating with hash params)
-* 2 instance variables per controller' action
+* 1 instance variables per controller' action
 
-## As simple as
+## CLI mode
 
 ~~~
 gem install sandi_meter
 sandi_meter ~/your/ruby/or/rails/project
+
+1. 94% of classes are under 100 lines.
+2. 53% of methods are under 5 lines.
+3. 98% of methods calls accepts are less than 4 parameters.
+4. 21% of controllers have one instance variable per action.
+~~~
+
+## Ruby script mode
+
+~~~ruby
+require 'sandi_meter/file_scanner'
+require 'pp'
+
+scanner = SandiMeter::FileScanner.new
+data = scanner.scan(PATH_TO_PROJECT)
+pp data
+# {:first_rule=>
+#   {:small_classes_amount=>916,
+#    :total_classes_amount=>937,
+#    :missindented_classes_amount=>1},
+#  :second_rule=>
+#   {:small_methods_amount=>1144,
+#    :total_methods_amount=>1833,
+#    :missindented_methods_amount=>0},
+#  :third_rule=>{:proper_method_calls=>5857, :total_method_calls=>5894},
+#  :fourth_rule=>{:proper_controllers_amount=>17, :total_controllers_amount=>94}}
 ~~~

data/bin/sandi_meter

@@ -1,6 +1,10 @@
 #!/usr/bin/env ruby
 
-require_relative '../lib/file_scanner'
+require_relative '../lib/sandi_meter/file_scanner'
+require_relative '../lib/sandi_meter/formatter'
 
-scanner = FileScanner.new(ARGV[1] == "--log")
-scanner.scan(ARGV[0])
+scanner = SandiMeter::FileScanner.new(ARGV[1] == "--log")
+data = scanner.scan(ARGV[0])
+formatter = SandiMeter::Formatter.new
+
+formatter.print_data(data)

data/lib/sandi_meter/analyzer.rb

@@ -0,0 +1,188 @@
+require 'ripper'
+require_relative 'warning_scanner'
+require_relative 'loc_checker'
+require_relative 'method_arguments_counter'
+
+module SandiMeter
+  class Analyzer
+    attr_reader :classes, :missindented_classes, :methods, :missindented_methods, :method_calls, :instance_variables
+
+    def initialize
+      @classes = []
+      @missindented_classes = []
+      @missindented_methods = {}
+      @methods = {}
+      @method_calls = []
+      @instance_variables = {}
+    end
+
+    def analyze(file_path)
+      @file_path = file_path
+      @file_body = File.read(file_path)
+      @file_lines = @file_body.split(/$/).map { |l| l.gsub("\n", '') }
+      @indentation_warnings = indentation_warnings
+      # TODO
+      # add better determination wheter file is controller
+      @scan_instance_variables = !!(file_path =~ /\w+_controller.rb$/)
+
+      sexp = Ripper.sexp(@file_body)
+      scan_sexp(sexp)
+
+      output
+    end
+
+    private
+    def output
+      loc_checker = SandiMeter::LOCChecker.new(@file_lines)
+
+      @classes.map! do |klass_params|
+        klass_params << loc_checker.check(klass_params, 'class')
+      end
+
+      @methods.each_pair do |klass, methods|
+        methods.each do |method_params|
+          method_params << loc_checker.check(method_params, 'def')
+        end
+      end
+
+      {
+        classes: @classes,
+        missindented_classes: @missindented_classes,
+        methods: @methods,
+        missindented_methods: @missindented_methods,
+        method_calls: @method_calls,
+        instance_variables: @instance_variables
+      }
+    end
+
+    def find_class_params(sexp, current_namespace)
+      flat_sexp = sexp[1].flatten
+      const_indexes = flat_sexp.each_index.select{ |i| flat_sexp[i] == :@const }
+
+      line_number = flat_sexp[const_indexes.first + 2]
+      class_tokens = const_indexes.map { |i| flat_sexp[i + 1] }
+      class_tokens.insert(0, current_namespace) unless current_namespace.empty?
+      class_name = class_tokens.join('::')
+
+      [class_name, line_number]
+    end
+
+    # MOVE
+    # to method scanner class
+    def number_of_arguments(method_sexp)
+      arguments = method_sexp[2]
+      arguments = arguments[1] if arguments.first == :paren
+
+      arguments[1] == nil ? 0 : arguments[1].size
+    end
+
+    def find_method_params(sexp)
+      sexp[1].flatten[1,2]
+    end
+
+    def find_last_line(params, token = 'class')
+      token_name, line = params
+
+      token_indentation = @file_lines[line - 1].index(token)
+      # TODO
+      # add check for trailing spaces
+      last_line = @file_lines[line..-1].index { |l| l =~ %r(\A\s{#{token_indentation}}end\s*\z) }
+
+      last_line ? last_line + line + 1 : nil
+    end
+
+    def scan_class_sexp(element, current_namespace = '')
+      case element.first
+      when :module
+        module_params = find_class_params(element, current_namespace)
+        module_params += [find_last_line(module_params, 'module')]
+        current_namespace = module_params.first
+
+        scan_sexp(element, current_namespace)
+      when :class
+        class_params = find_class_params(element, current_namespace)
+
+        if @indentation_warnings['class'] && @indentation_warnings['class'].any? { |first_line, last_line| first_line == class_params.last }
+          class_params << nil
+          @missindented_classes << class_params
+        else
+          class_params += [find_last_line(class_params)]
+
+          # in case of one liner class last line will be nil
+          (class_params.last == nil ? @missindented_classes : @classes) << class_params
+        end
+
+        current_namespace = class_params.first
+        scan_sexp(element, current_namespace)
+      end
+    end
+
+    def find_args_add_block(method_call_sexp)
+      return unless method_call_sexp.kind_of?(Array)
+
+      method_call_sexp.each do |sexp|
+        next unless sexp.kind_of?(Array)
+
+        if sexp.first == :args_add_block
+          counter = SandiMeter::MethodArgumentsCounter.new
+          arguments_count, line = counter.count(sexp)
+
+          @method_calls << [arguments_count, line]
+
+          find_args_add_block(sexp)
+        else
+          find_args_add_block(sexp)
+        end
+      end
+    end
+
+    def scan_def_for_ivars(current_namespace, method_name, method_sexp)
+      return unless method_sexp.kind_of?(Array)
+
+      method_sexp.each do |sexp|
+        next unless sexp.kind_of?(Array)
+
+        if sexp.first == :assign
+          @instance_variables[current_namespace] ||= {}
+          @instance_variables[current_namespace][method_name] ||= []
+          @instance_variables[current_namespace][method_name] << sexp[1][1][1]
+        else
+          scan_def_for_ivars(current_namespace, method_name, sexp)
+        end
+      end
+    end
+
+    def scan_sexp(sexp, current_namespace = '')
+      sexp.each do |element|
+        next unless element.kind_of?(Array)
+
+        case element.first
+        when :def
+          method_params = find_method_params(element)
+          if @indentation_warnings['def'] && @indentation_warnings['def'].any? { |first_line, last_line| first_line == method_params.last }
+            method_params << nil
+            method_params << number_of_arguments(element)
+            @missindented_methods[current_namespace] ||= []
+            @missindented_methods[current_namespace] << method_params
+          else
+            method_params += [find_last_line(method_params, 'def')]
+            method_params << number_of_arguments(element)
+            @methods[current_namespace] ||= []
+            @methods[current_namespace] << method_params
+          end
+          scan_def_for_ivars(current_namespace, method_params.first, element) if @scan_instance_variables
+          find_args_add_block(element)
+        when :module, :class
+          scan_class_sexp(element, current_namespace)
+        else
+          scan_sexp(element, current_namespace)
+        end
+      end
+    end
+
+    def indentation_warnings
+      warning_scanner = SandiMeter::WarningScanner.new
+      warning_scanner.scan(@file_body)
+    end
+  end
+end

data/lib/sandi_meter/calculator.rb

@@ -0,0 +1,93 @@
+module SandiMeter
+  class Calculator
+    def initialize
+      @data = {}
+      @output = {}
+    end
+
+    def push(data)
+      data.each_pair do |key, value|
+        if value.kind_of?(Array)
+          @data[key] ||= []
+          @data[key] += value
+        elsif value.kind_of?(Hash)
+          @data[key] ||= {}
+          @data[key].merge!(value)
+        end
+      end
+    end
+
+    def calculate!
+      check_first_rule
+      check_second_rule
+      check_third_rule
+      check_fourth_rule
+
+      @output
+    end
+
+    private
+    def check_first_rule
+      total_classes_amount = @data[:classes].size
+      small_classes_amount = @data[:classes].inject(0) do |sum, class_params|
+        sum += 1 if class_params.last == true
+        sum
+      end
+      missindented_classes_amount = @data[:missindented_classes].size
+
+      @output[:first_rule] ||= {}
+      @output[:first_rule][:small_classes_amount] = small_classes_amount
+      @output[:first_rule][:total_classes_amount] = total_classes_amount
+      @output[:first_rule][:missindented_classes_amount] = missindented_classes_amount
+    end
+
+    def check_second_rule
+      total_methods_amount = 0
+      small_methods_amount = 0
+
+      @data[:methods].each_pair do |klass, methods|
+        small_methods_amount += methods.select { |m| m.last == true }.size
+        total_methods_amount += methods.size
+      end
+
+      missindented_methods_amount = 0
+      @data[:missindented_methods].each_pair do |klass, methods|
+        missindented_methods_amount += methods.size
+      end
+
+      @output[:second_rule] ||= {}
+      @output[:second_rule][:small_methods_amount] = small_methods_amount
+      @output[:second_rule][:total_methods_amount] = total_methods_amount
+      @output[:second_rule][:missindented_methods_amount] = missindented_methods_amount
+    end
+
+    # TODO
+    # count method definitions argumets too
+    def check_third_rule
+      total_method_calls = @data[:method_calls].size
+
+      proper_method_calls = @data[:method_calls].inject(0) do |sum, params|
+        sum += 1 unless params.first > 4
+        sum
+      end
+
+      @output[:third_rule] ||= {}
+      @output[:third_rule][:proper_method_calls] = proper_method_calls
+      @output[:third_rule][:total_method_calls] = total_method_calls
+    end
+
+    def check_fourth_rule
+      proper_controllers_amount = 0
+      total_controllers_amount = 0
+
+      @data[:instance_variables].each_pair do |controller, methods|
+        total_controllers_amount += 1
+        proper_controllers_amount += 1 unless methods.values.map(&:size).any? { |v| v > 1 }
+      end
+
+      @output[:fourth_rule] ||= {}
+      @output[:fourth_rule][:proper_controllers_amount] = proper_controllers_amount
+      @output[:fourth_rule][:total_controllers_amount] = total_controllers_amount
+    end
+  end
+end

data/lib/sandi_meter/file_scanner.rb

@@ -0,0 +1,41 @@
+require_relative 'analyzer'
+require_relative 'calculator'
+
+module SandiMeter
+  class FileScanner
+    def initialize(log_errors = false)
+      @log_errors = log_errors
+      @calculator = SandiMeter::Calculator.new
+    end
+
+    def scan(path)
+      if File.directory?(path)
+        scan_dir(path)
+      else
+        scan_file(path)
+      end
+
+      @calculator.calculate!
+    end
+
+    private
+    def scan_dir(path)
+      Dir["#{path}/**/*.rb"].each do |file|
+        scan_file(file)
+      end
+    end
+
+    def scan_file(path)
+      begin
+        analyzer = SandiMeter::Analyzer.new
+        data = analyzer.analyze(path)
+        @calculator.push(data)
+      rescue Exception => e
+        if @log_errors
+          puts "Checkout #{path} for:"
+          puts "\t#{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/sandi_meter/formatter.rb

@@ -0,0 +1,29 @@
+module SandiMeter
+  class Formatter
+    def print_data(data)
+      if data[:first_rule][:total_classes_amount] > 0
+        puts "1. #{data[:first_rule][:small_classes_amount] * 100 / data[:first_rule][:total_classes_amount]}% of classes are under 100 lines."
+      else
+        puts "1. No classes to analize."
+      end
+
+      if data[:second_rule][:total_methods_amount] > 0
+        puts "2. #{data[:second_rule][:small_methods_amount] * 100 / data[:second_rule][:total_methods_amount]}% of methods are under 5 lines."
+      else
+        puts "2. No methods to analize."
+      end
+
+      if data[:third_rule][:total_method_calls] > 0
+        puts "3. #{data[:third_rule][:proper_method_calls] * 100 / data[:third_rule][:total_method_calls]}% of methods calls accepts are less than 4 parameters."
+      else
+        puts "3. No method calls to analize."
+      end
+
+      if data[:fourth_rule][:total_controllers_amount] > 0
+        puts "4. #{data[:fourth_rule][:proper_controllers_amount] * 100 / data[:fourth_rule][:total_controllers_amount]}% of controllers have one instance variable per action."
+      else
+        puts "4. No controllers to analize."
+      end
+    end
+  end
+end

data/lib/sandi_meter/loc_checker.rb

@@ -0,0 +1,19 @@
+module SandiMeter
+  class LOCChecker < Struct.new(:file_lines)
+
+    MAX_LOC = {
+      'def'   => 5,
+      'class' => 100
+    }
+
+    def check(params, token)
+      _, first_line, last_line = params
+      locs_size(first_line, last_line) <= MAX_LOC[token]
+    end
+
+    private
+    def locs_size(first_line, last_line)
+      file_lines[first_line - 1..last_line - 1].map(&:strip).reject(&:empty?).size
+    end
+  end
+end

data/lib/sandi_meter/method_arguments_counter.rb

@@ -0,0 +1,38 @@
+module SandiMeter
+  class MethodArgumentsCounter
+    def initialize
+      reset!
+    end
+
+    def count(args_add_block_sexp)
+      reset!
+
+      @count += args_add_block_sexp[1].size
+      @count += 1 if args_add_block_sexp.last == true
+      bypass_sexp(args_add_block_sexp)
+
+      return [@count, @lines.uniq.sort.first]
+    end
+
+    def reset!
+      @count = 0
+      @lines = []
+    end
+
+    private
+    def bypass_sexp(args_add_block_sexp)
+      args_add_block_sexp.each do |sexp|
+        next unless sexp.kind_of?(Array)
+
+        case sexp.first
+        when :bare_assoc_hash
+          @count += sexp[1].size - 1
+        when :@int, :@ident
+          @lines << sexp.last.first
+        end
+
+        bypass_sexp(sexp)
+      end
+    end
+  end
+end

data/lib/sandi_meter/version.rb

@@ -1,3 +1,3 @@
 module SandiMeter
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/sandi_meter/warning_scanner.rb

@@ -0,0 +1,57 @@
+require 'open3'
+
+module SandiMeter
+  class WarningScanner
+    attr_reader :indentation_warnings
+
+    INDENTATION_WARNING_REGEXP = /at 'end' with '(def|class|module)' at (\d+)\z/
+
+    def scan(source)
+      status, @warnings, process = if defined? Bundler
+                                  Bundler.with_clean_env do
+                                       validate(source)
+                                    end
+                                  else
+                                    validate(source)
+                                  end
+
+      check_syntax(status)
+      @indentation_warnings = parse_warnings
+    end
+
+    private
+    def validate(source)
+      Open3.capture3('ruby -wc', stdin_data: source)
+    end
+
+    def check_syntax(status)
+      raise SyntaxError, @warnings unless !!(status =~ /Syntax\sOK/)
+    end
+
+    def check_token_lines(token, line_num, end_line_num)
+      raise 'No valid end line number' unless end_line_num =~ /^\d+$/
+      raise 'No valid line number' unless line_num =~ /^\d+$/
+      raise 'No valid token ("def" or "class")' unless token =~ /^def|class|module$/
+    end
+
+    def extract_indentation_mismatch(warning_line)
+      _, end_line_num, warning_type, warning_body = warning_line.split(':').map(&:strip)
+      return nil unless warning_type == 'warning'
+      return nil unless warning_body =~ /at 'end' with '(def|class|module)' at (\d+)\z/
+
+      res = warning_body.match(INDENTATION_WARNING_REGEXP)[1..2] << end_line_num
+      check_token_lines(*res)
+
+      res
+    end
+
+    def parse_warnings
+      @warnings.split("\n").inject({}) do |warnings, warning|
+        token, line, end_line = extract_indentation_mismatch(warning)
+        warnings[token] ||= []
+        warnings[token] << [line.to_i, end_line.to_i]
+        warnings
+      end
+    end
+  end
+end

data/spec/analyzer_spec.rb

@@ -1,8 +1,8 @@
 require 'test_helper'
-require_relative '../lib/analyzer'
+require_relative '../lib/sandi_meter/analyzer'
 
-describe Analyzer do
-  let(:analyzer) { Analyzer.new }
+describe SandiMeter::Analyzer do
+  let(:analyzer) { SandiMeter::Analyzer.new }
 
   describe 'finds properly indended classes with lines' do
     let(:test_class) { test_file_path(3) }

data/spec/loc_checker_spec.rb

@@ -1,13 +1,13 @@
 require 'test_helper'
-require_relative '../lib/loc_checker'
+require_relative '../lib/sandi_meter/loc_checker'
 
-describe LOCChecker do
-  let(:checker) { LOCChecker.new([]) }
+describe SandiMeter::LOCChecker do
+  let(:checker) { SandiMeter::LOCChecker.new([]) }
 
   describe '#check' do
     context 'for short code' do
       before do
-        stub_const('LOCChecker::MAX_LOC', { 'blah' => 10 })
+        stub_const('SandiMeter::LOCChecker::MAX_LOC', { 'blah' => 10 })
         checker.stub(:locs_size).and_return(rand(0..10))
       end
 
@@ -20,7 +20,7 @@ describe LOCChecker do
 
     context 'for large code' do
       before do
-        stub_const('LOCChecker::MAX_LOC', { 'blah' => 10 })
+        stub_const('SandiMeter::LOCChecker::MAX_LOC', { 'blah' => 10 })
         checker.stub(:locs_size).and_return(rand(11..100))
       end
 

data/spec/method_arguments_counter_spec.rb

@@ -1,9 +1,9 @@
 require 'test_helper'
-require_relative '../lib/method_arguments_counter'
+require_relative '../lib/sandi_meter/method_arguments_counter'
 
-describe MethodArgumentsCounter do
-  let(:test_loader) { ArgsLoader.new }
-  let(:analyzer) { MethodArgumentsCounter.new }
+describe SandiMeter::MethodArgumentsCounter do
+  let(:test_loader) { SandiMeter::ArgsLoader.new }
+  let(:analyzer) { SandiMeter::MethodArgumentsCounter.new }
 
   context 'when variable/method arguments' do
     let(:args_add_block_1) { load_args_block('blah arg1, arg2')}

data/spec/warning_scanner_spec.rb

@@ -1,8 +1,8 @@
 require 'test_helper'
-require_relative '../lib/warning_scanner'
+require_relative '../lib/sandi_meter/warning_scanner'
 
-describe WarningScanner do
-  let(:scanner) { WarningScanner.new }
+describe SandiMeter::WarningScanner do
+  let(:scanner) { SandiMeter::WarningScanner.new }
 
   describe 'scanning class with indentation warnings' do
     let(:test_class) { read_test_file(1) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sandi_meter
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Anatoli Makarevich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-15 00:00:00.000000000 Z
+date: 2013-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -50,13 +50,14 @@ files:
 - README.md
 - Rakefile
 - sandi_meter.gemspec
-- lib/analyzer.rb
-- lib/calculator.rb
-- lib/file_scanner.rb
-- lib/loc_checker.rb
-- lib/method_arguments_counter.rb
+- lib/sandi_meter/analyzer.rb
+- lib/sandi_meter/calculator.rb
+- lib/sandi_meter/file_scanner.rb
+- lib/sandi_meter/formatter.rb
+- lib/sandi_meter/loc_checker.rb
+- lib/sandi_meter/method_arguments_counter.rb
 - lib/sandi_meter/version.rb
-- lib/warning_scanner.rb
+- lib/sandi_meter/warning_scanner.rb
 - bin/sandi_meter
 - spec/analyzer_spec.rb
 - spec/loc_checker_spec.rb

data/lib/analyzer.rb

@@ -1,186 +0,0 @@
-require 'ripper'
-require_relative 'warning_scanner'
-require_relative 'loc_checker'
-require_relative 'method_arguments_counter'
-
-class Analyzer
-  attr_reader :classes, :missindented_classes, :methods, :missindented_methods, :method_calls, :instance_variables
-
-  def initialize
-    @classes = []
-    @missindented_classes = []
-    @missindented_methods = {}
-    @methods = {}
-    @method_calls = []
-    @instance_variables = {}
-  end
-
-  def analyze(file_path)
-    @file_path = file_path
-    @file_body = File.read(file_path)
-    @file_lines = @file_body.split(/$/).map { |l| l.gsub("\n", '') }
-    @indentation_warnings = indentation_warnings
-    # TODO
-    # add better determination wheter file is controller
-    @scan_instance_variables = !!(file_path =~ /\w+_controller.rb$/)
-
-    sexp = Ripper.sexp(@file_body)
-    scan_sexp(sexp)
-
-    output
-  end
-
-  private
-  def output
-    loc_checker = LOCChecker.new(@file_lines)
-
-    @classes.map! do |klass_params|
-      klass_params << loc_checker.check(klass_params, 'class')
-    end
-
-    @methods.each_pair do |klass, methods|
-      methods.each do |method_params|
-        method_params << loc_checker.check(method_params, 'def')
-      end
-    end
-
-    {
-      classes: @classes,
-      missindented_classes: @missindented_classes,
-      methods: @methods,
-      missindented_methods: @missindented_methods,
-      method_calls: @method_calls,
-      instance_variables: @instance_variables
-    }
-  end
-
-  def find_class_params(sexp, current_namespace)
-    flat_sexp = sexp[1].flatten
-    const_indexes = flat_sexp.each_index.select{ |i| flat_sexp[i] == :@const }
-
-    line_number = flat_sexp[const_indexes.first + 2]
-    class_tokens = const_indexes.map { |i| flat_sexp[i + 1] }
-    class_tokens.insert(0, current_namespace) unless current_namespace.empty?
-    class_name = class_tokens.join('::')
-
-    [class_name, line_number]
-  end
-
-  # MOVE
-  # to method scanner class
-  def number_of_arguments(method_sexp)
-    arguments = method_sexp[2]
-    arguments = arguments[1] if arguments.first == :paren
-
-    arguments[1] == nil ? 0 : arguments[1].size
-  end
-
-  def find_method_params(sexp)
-    sexp[1].flatten[1,2]
-  end
-
-  def find_last_line(params, token = 'class')
-    token_name, line = params
-
-    token_indentation = @file_lines[line - 1].index(token)
-    # TODO
-    # add check for trailing spaces
-    last_line = @file_lines[line..-1].index { |l| l =~ %r(\A\s{#{token_indentation}}end\s*\z) }
-
-    last_line ? last_line + line + 1 : nil
-  end
-
-  def scan_class_sexp(element, current_namespace = '')
-    case element.first
-    when :module
-      module_params = find_class_params(element, current_namespace)
-      module_params += [find_last_line(module_params, 'module')]
-      current_namespace = module_params.first
-
-      scan_sexp(element, current_namespace)
-    when :class
-      class_params = find_class_params(element, current_namespace)
-
-      if @indentation_warnings['class'] && @indentation_warnings['class'].any? { |first_line, last_line| first_line == class_params.last }
-        class_params << nil
-        @missindented_classes << class_params
-      else
-        class_params += [find_last_line(class_params)]
-
-        # in case of one liner class last line will be nil
-        (class_params.last == nil ? @missindented_classes : @classes) << class_params
-      end
-
-      current_namespace = class_params.first
-      scan_sexp(element, current_namespace)
-    end
-  end
-
-  def find_args_add_block(method_call_sexp)
-    return unless method_call_sexp.kind_of?(Array)
-
-    method_call_sexp.each do |sexp|
-      next unless sexp.kind_of?(Array)
-
-      if sexp.first == :args_add_block
-        counter = MethodArgumentsCounter.new
-        arguments_count, line = counter.count(sexp)
-
-        @method_calls << [arguments_count, line]
-
-        find_args_add_block(sexp)
-      else
-        find_args_add_block(sexp)
-      end
-    end
-  end
-
-  def scan_def_for_ivars(current_namespace, method_name, method_sexp)
-    return unless method_sexp.kind_of?(Array)
-
-    method_sexp.each do |sexp|
-      next unless sexp.kind_of?(Array)
-
-      if sexp.first == :assign
-        @instance_variables[current_namespace] ||= {}
-        @instance_variables[current_namespace][method_name] ||= []
-        @instance_variables[current_namespace][method_name] << sexp[1][1][1]
-      else
-        scan_def_for_ivars(current_namespace, method_name, sexp)
-      end
-    end
-  end
-
-  def scan_sexp(sexp, current_namespace = '')
-    sexp.each do |element|
-      next unless element.kind_of?(Array)
-
-      case element.first
-      when :def
-        method_params = find_method_params(element)
-        if @indentation_warnings['def'] && @indentation_warnings['def'].any? { |first_line, last_line| first_line == method_params.last }
-          method_params << nil
-          method_params << number_of_arguments(element)
-          @missindented_methods[current_namespace] ||= []
-          @missindented_methods[current_namespace] << method_params
-        else
-          method_params += [find_last_line(method_params, 'def')]
-          method_params << number_of_arguments(element)
-          @methods[current_namespace] ||= []
-          @methods[current_namespace] << method_params
-        end
-        scan_def_for_ivars(current_namespace, method_params.first, element) if @scan_instance_variables
-        find_args_add_block(element)
-      when :module, :class
-        scan_class_sexp(element, current_namespace)
-      else
-        scan_sexp(element, current_namespace)
-      end
-    end
-  end
-
-  def indentation_warnings
-    warning_scanner = WarningScanner.new
-    warning_scanner.scan(@file_body)
-  end
-end

data/lib/calculator.rb

@@ -1,103 +0,0 @@
-class Calculator
-  def initialize
-    @data = {}
-  end
-
-  def push(data)
-    data.each_pair do |key, value|
-      if value.kind_of?(Array)
-        @data[key] ||= []
-        @data[key] += value
-      elsif value.kind_of?(Hash)
-        @data[key] ||= {}
-        @data[key].merge!(value)
-      end
-    end
-  end
-
-  def calculate!
-    check_first_rule
-    check_second_rule
-    check_third_rule
-    check_fourth_rule
-  end
-
-  private
-  def check_first_rule
-    total_classes_amount = @data[:classes].size
-    small_classes_amount = @data[:classes].inject(0) do |sum, class_params|
-      sum += 1 if class_params.last == true
-      sum
-    end
-    missindented_classes_amount = @data[:missindented_classes].size
-
-    puts "#{small_classes_amount * 100/ total_classes_amount}% of classes are under 100 lines."
-
-    # TODO uncomment when missindented location will be implemented
-    #
-    # if missindented_classes_amount > 0
-    #   puts "Pay attention to #{missindented_classes_amount} missindented classes."
-    # end
-  end
-
-  def check_second_rule
-    total_methods_amount = 0
-    small_methods_amount = 0
-
-    @data[:methods].each_pair do |klass, methods|
-      small_methods_amount += methods.select { |m| m.last == true }.size
-      total_methods_amount += methods.size
-    end
-
-    missindented_methods_amount = 0
-    @data[:missindented_methods].each_pair do |klass, methods|
-      missindented_methods_amount += methods.size
-    end
-
-    puts "#{small_methods_amount * 100 / total_methods_amount}% of methods are under 5 lines."
-
-    # TODO uncomment when missindented location will be implemented
-    #
-    # if missindented_methods_amount > 0
-    #   puts "Pay attention to #{missindented_methods_amount} missindented methods."
-    # end
-  end
-
-  # TODO
-  # count method definitions argumets too
-  def check_third_rule
-    total_method_calls = @data[:method_calls].size
-
-    proper_method_calls = @data[:method_calls].inject(0) do |sum, params|
-      sum += 1 unless params.first > 4
-      sum
-    end
-
-    missindented_methods_amount = 0
-    @data[:missindented_methods].each_pair do |klass, methods|
-      missindented_methods_amount += methods.size
-    end
-
-    if total_method_calls > 0
-      puts "#{proper_method_calls * 100 / total_method_calls}% of methods calls accepts are less than 4 parameters."
-    else
-      puts "Seems like there no method calls. WAT?!"
-    end
-  end
-
-  def check_fourth_rule
-    proper_controllers_amount = 0
-    total_controllers_amount = 0
-
-    @data[:instance_variables].each_pair do |controller, methods|
-      total_controllers_amount += 1
-      proper_controllers_amount += 1 unless methods.values.map(&:size).any? { |v| v > 1 }
-    end
-
-    if total_controllers_amount > 0
-      puts "#{proper_controllers_amount * 100 / total_controllers_amount}% of controllers have one instance varible per action."
-    else
-      puts "Seems like there are no controllers :)"
-    end
-  end
-end

data/lib/file_scanner.rb

@@ -1,39 +0,0 @@
-require_relative 'analyzer'
-require_relative 'calculator'
-
-class FileScanner
-  def initialize(log_errors = false)
-    @log_errors = log_errors
-    @calculator = Calculator.new
-  end
-
-  def scan(path)
-    if File.directory?(path)
-      scan_dir(path)
-    else
-      scan_file(path)
-    end
-
-    @calculator.calculate!
-  end
-
-  private
-  def scan_dir(path)
-    Dir["#{path}/**/*.rb"].each do |file|
-      scan_file(file)
-    end
-  end
-
-  def scan_file(path)
-    begin
-      analyzer = Analyzer.new
-      data = analyzer.analyze(path)
-      @calculator.push(data)
-    rescue Exception => e
-      if @log_errors
-        puts "Checkout #{path} for:"
-        puts "\t#{e.message}"
-      end
-    end
-  end
-end

data/lib/loc_checker.rb

@@ -1,17 +0,0 @@
-class LOCChecker < Struct.new(:file_lines)
-
-  MAX_LOC = {
-    'def'   => 5,
-    'class' => 100
-  }
-
-  def check(params, token)
-    _, first_line, last_line = params
-    locs_size(first_line, last_line) <= MAX_LOC[token]
-  end
-
-  private
-  def locs_size(first_line, last_line)
-    file_lines[first_line - 1..last_line - 1].map(&:strip).reject(&:empty?).size
-  end
-end

data/lib/method_arguments_counter.rb

@@ -1,36 +0,0 @@
-class MethodArgumentsCounter
-  def initialize
-    reset!
-  end
-
-  def count(args_add_block_sexp)
-    reset!
-
-    @count += args_add_block_sexp[1].size
-    @count += 1 if args_add_block_sexp.last == true
-    bypass_sexp(args_add_block_sexp)
-
-    return [@count, @lines.uniq.sort.first]
-  end
-
-  def reset!
-    @count = 0
-    @lines = []
-  end
-
-  private
-  def bypass_sexp(args_add_block_sexp)
-    args_add_block_sexp.each do |sexp|
-      next unless sexp.kind_of?(Array)
-
-      case sexp.first
-      when :bare_assoc_hash
-        @count += sexp[1].size - 1
-      when :@int, :@ident
-        @lines << sexp.last.first
-      end
-
-      bypass_sexp(sexp)
-    end
-  end
-end

data/lib/warning_scanner.rb

@@ -1,55 +0,0 @@
-require 'open3'
-
-class WarningScanner
-  attr_reader :indentation_warnings
-
-  INDENTATION_WARNING_REGEXP = /at 'end' with '(def|class|module)' at (\d+)\z/
-
-  def scan(source)
-    status, @warnings, process = if defined? Bundler
-                                Bundler.with_clean_env do
-                                     validate(source)
-                                  end
-                                else
-                                  validate(source)
-                                end
-
-    check_syntax(status)
-    @indentation_warnings = parse_warnings
-  end
-
-  private
-  def validate(source)
-    Open3.capture3('ruby -wc', stdin_data: source)
-  end
-
-  def check_syntax(status)
-    raise SyntaxError, @warnings unless !!(status =~ /Syntax\sOK/)
-  end
-
-  def check_token_lines(token, line_num, end_line_num)
-    raise 'No valid end line number' unless end_line_num =~ /^\d+$/
-    raise 'No valid line number' unless line_num =~ /^\d+$/
-    raise 'No valid token ("def" or "class")' unless token =~ /^def|class|module$/
-  end
-
-  def extract_indentation_mismatch(warning_line)
-    _, end_line_num, warning_type, warning_body = warning_line.split(':').map(&:strip)
-    return nil unless warning_type == 'warning'
-    return nil unless warning_body =~ /at 'end' with '(def|class|module)' at (\d+)\z/
-
-    res = warning_body.match(INDENTATION_WARNING_REGEXP)[1..2] << end_line_num
-    check_token_lines(*res)
-
-    res
-  end
-
-  def parse_warnings
-    @warnings.split("\n").inject({}) do |warnings, warning|
-      token, line, end_line = extract_indentation_mismatch(warning)
-      warnings[token] ||= []
-      warnings[token] << [line.to_i, end_line.to_i]
-      warnings
-    end
-  end
-end