sandi_meter 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YTQyYTQ2NWQ4ODBhYjNmMzVmNGU5NzJkOTI1ZjhkZTBkODZkNDEyNA==
+  data.tar.gz: !binary |-
+    Yzk5MjM2ZTdiODY5ZjcyN2YyNTNjYWRjODBiMWI3MzQyYzkxMzdkNg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NmNlNWU0MGQzODYwY2RmMDQ4ZTY4NjZmNWJhN2I5MDU2MzhlMzhjNmI0ZTM1
+    NmIwNzhmNWViNTFiMjExZjQ2ZWZhY2Y1N2JhMGE4ZmEzYWY4OWRmMTdlMTE5
+    NjZmMjcxNzJkNTAwYjcwNWFjY2IwMzk5YTAxZjI3YTU2ZWFiMjI=
+  data.tar.gz: !binary |-
+    ZDBlYmZiZjI0OGI0Y2Y0MTAzY2YxNTE4YjNhZTgxYzdhOTdhMzc2MzI1M2M2
+    OTdmMWU0NzZjNWE1NTZmNGViMjA2Y2IwOTkyMGY3ZmUyN2ZlY2RkZTQ4ZDA0
+    MmEyYzUxZGU3ZjE3NWU5NmVkZGU1MDUzY2M0NTFmOWZmYjczZTQ=

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Anatoli Makarevich
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,15 @@
+# SandiMeter
+
+Static analysis tool for checking your Ruby code for [Sandi Metz' for rules](http://robots.thoughtbot.com/post/50655960596/sandi-metz-rules-for-developers).
+
+* 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
+
+## As simple as
+
+~~~
+gem install sandi_meter
+sandi_meter ~/your/ruby/or/rails/project
+~~~

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake/testtask'
+require 'bundler'
+
+Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new do |test|
+  test.verbose = true
+  test.libs << "spec"
+  test.test_files = FileList['spec/**/*_spec.rb']
+end
+
+task default: :test

data/bin/sandi_meter

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/file_scanner'
+
+scanner = FileScanner.new(ARGV[1] == "--log")
+scanner.scan(ARGV[0])

data/lib/analyzer.rb

@@ -0,0 +1,186 @@
+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

@@ -0,0 +1,103 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,36 @@
+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/sandi_meter/version.rb

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

data/lib/warning_scanner.rb

@@ -0,0 +1,55 @@
+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

data/sandi_meter.gemspec

@@ -0,0 +1,24 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sandi_meter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sandi_meter"
+  spec.version       = SandiMeter::VERSION
+  spec.authors       = ["Anatoli Makarevich"]
+  spec.email         = ["makaroni4@gmail.com"]
+  spec.description   = %q{Sandi Metz rules checker}
+  spec.summary       = %q{Sandi Metz rules checker}
+  spec.homepage      = "https://github.com/makaroni4/sandi_meter"
+  spec.license       = "MIT"
+
+  spec.files = %w(LICENSE README.md Rakefile sandi_meter.gemspec)
+  spec.files += Dir.glob("lib/**/*.rb")
+  spec.files += Dir.glob("bin/**/*")
+  spec.files += Dir.glob("spec/**/*")
+  spec.executables   = ["sandi_meter"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/spec/analyzer_spec.rb

@@ -0,0 +1,163 @@
+require 'test_helper'
+require_relative '../lib/analyzer'
+
+describe Analyzer do
+  let(:analyzer) { Analyzer.new }
+
+  describe 'finds properly indended classes with lines' do
+    let(:test_class) { test_file_path(3) }
+
+    before do
+      analyzer.analyze(test_class)
+    end
+
+    it 'finds indentation warnings for method' do
+      analyzer.classes.should eq([["TestClass", 1, 5, true]])
+      analyzer.missindented_classes.should be_empty
+    end
+
+    it 'finds methods' do
+      analyzer.methods.should eq({"TestClass"=>[["blah", 2, 4, 0, true]]})
+      analyzer.missindented_methods.should be_empty
+    end
+
+    it 'finds method calls that brakes third rule' do
+      analyzer.method_calls.should eq([[5,3]])
+    end
+  end
+
+  describe 'finds missindented classes without last line' do
+    let(:test_class) { test_file_path(1) }
+
+    before do
+      analyzer.analyze(test_class)
+    end
+
+    it 'finds indentation warnings for method' do
+      analyzer.classes.should be_empty
+      analyzer.missindented_classes.should eq([["MyApp::TestClass", 2, nil]])
+    end
+
+    it 'finds methods' do
+      analyzer.methods.should be_empty
+      analyzer.missindented_methods.should eq({"MyApp::TestClass"=>[["blah", 3, nil, 0]]})
+    end
+  end
+
+  describe 'finds properly indended classes in one file' do
+    let(:test_class) { test_file_path(4) }
+
+    before do
+      analyzer.analyze(test_class)
+    end
+
+    it 'finds classes' do
+      analyzer.classes.should include(["FirstTestClass", 1, 4, true])
+      analyzer.classes.should include(["SecondTestClass", 6, 9, true])
+      analyzer.missindented_classes.should be_empty
+    end
+
+    it 'finds methods' do
+      analyzer.methods["FirstTestClass"].should eq([["first_meth", 2, 3, 1, true]])
+      analyzer.methods["SecondTestClass"].should eq([["second_meth", 7, 8, 1, true]])
+      analyzer.missindented_methods.should be_empty
+    end
+  end
+
+  describe 'finds one liner class' do
+    let(:test_class) { test_file_path(5) }
+
+    before do
+      analyzer.analyze(test_class)
+    end
+
+    it 'finds classes' do
+      analyzer.missindented_classes.should eq([["OneLinerClass", 1, nil]])
+      analyzer.classes.should be_empty
+    end
+
+    it 'finds methods' do
+      analyzer.methods.should be_empty
+      analyzer.missindented_methods.should be_empty
+    end
+  end
+
+  describe 'finds subclass of a class' do
+    let(:test_class) { test_file_path(7) }
+
+    before do
+      analyzer.analyze(test_class)
+    end
+
+    it 'finds class and subclass' do
+      analyzer.classes.should include(["MyApp::Blah::User", 5, 13, true])
+      analyzer.classes.should include(["MyApp::Blah::User::SubUser", 9, 12, true])
+      analyzer.missindented_classes.should be_empty
+    end
+
+    it 'finds methods' do
+      analyzer.methods["MyApp::Blah"].should eq([["module_meth", 2, 3, 0, true]])
+      analyzer.methods["MyApp::Blah::User"].should eq([["class_meth", 6, 7, 0, true]])
+      analyzer.methods["MyApp::Blah::User::SubUser"].should eq([["sub_meth", 10, 11, 0, true]])
+      analyzer.missindented_methods.should be_empty
+    end
+  end
+
+  describe 'finds class and methods with private methods' do
+    let(:test_class) { test_file_path(8) }
+
+    before do
+      analyzer.analyze(test_class)
+    end
+
+    it 'finds class and subclass' do
+      analyzer.classes.should include(["RailsController", 1, 12, true])
+      analyzer.missindented_classes.should be_empty
+    end
+
+    it 'finds methods' do
+      analyzer.methods["RailsController"].should include(["index", 2, 3, 0, true])
+      analyzer.methods["RailsController"].should include(["destroy", 5, 6, 0, true])
+      analyzer.methods["RailsController"].should include(["private_meth", 9, 10, 0, true])
+      analyzer.missindented_methods.should be_empty
+    end
+  end
+
+  describe 'instance variables in methods' do
+    context 'in controller class' do
+      let(:test_class) { test_file_path('9_controller') }
+
+      before do
+        analyzer.analyze(test_class)
+      end
+
+      it 'finds instance variable' do
+        analyzer.instance_variables.should eq({"UsersController"=>{"index"=>["@users"]}})
+      end
+    end
+
+    context 'not in controller class' do
+      let(:test_class) { test_file_path(10) }
+
+      before do
+        analyzer.analyze(test_class)
+      end
+
+      it 'does not find instance variable' do
+        analyzer.instance_variables.should be_empty
+      end
+    end
+  end
+
+  describe 'hash method arguments' do
+    let(:test_class) { test_file_path(11) }
+
+    before do
+      analyzer.analyze(test_class)
+    end
+
+    it 'counts arguments' do
+      analyzer.method_calls.should eq([[5, 3]])
+    end
+  end
+end

data/spec/loc_checker_spec.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+require_relative '../lib/loc_checker'
+
+describe LOCChecker do
+  let(:checker) { LOCChecker.new([]) }
+
+  describe '#check' do
+    context 'for short code' do
+      before do
+        stub_const('LOCChecker::MAX_LOC', { 'blah' => 10 })
+        checker.stub(:locs_size).and_return(rand(0..10))
+      end
+
+      # REFACTOR
+      # avoid passing dumb arguments to tested methods
+      it 'passes the check' do
+        checker.check([1,2,3], 'blah').should be_true
+      end
+    end
+
+    context 'for large code' do
+      before do
+        stub_const('LOCChecker::MAX_LOC', { 'blah' => 10 })
+        checker.stub(:locs_size).and_return(rand(11..100))
+      end
+
+      it 'does not pass the check' do
+        checker.check([1,2,3], 'blah').should be_false
+      end
+    end
+  end
+end

data/spec/method_arguments_counter_spec.rb

@@ -0,0 +1,59 @@
+require 'test_helper'
+require_relative '../lib/method_arguments_counter'
+
+describe MethodArgumentsCounter do
+  let(:test_loader) { ArgsLoader.new }
+  let(:analyzer) { MethodArgumentsCounter.new }
+
+  context 'when variable/method arguments' do
+    let(:args_add_block_1) { load_args_block('blah arg1, arg2')}
+    let(:args_add_block_2) { load_args_block('blah(arg1, arg2)')}
+
+    it 'counts arguments' do
+      analyzer.count(args_add_block_1).should eq([2, 1])
+      analyzer.count(args_add_block_2).should eq([2, 1])
+    end
+  end
+
+  context 'when hash arguments' do
+    let(:args_add_block_1) { load_args_block('blah k: :v') }
+    let(:args_add_block_2) { load_args_block('blah(k: :v)') }
+
+    let(:args_add_block_3) { load_args_block('blah k1: :v1, k2: :v2') }
+    let(:args_add_block_4) { load_args_block('blah(k1: :v1, k2: :v2)') }
+
+    it 'counts arguments' do
+      analyzer.count(args_add_block_1).should eq([1, 1])
+      analyzer.count(args_add_block_2).should eq([1, 1])
+      analyzer.count(args_add_block_3).should eq([2, 1])
+      analyzer.count(args_add_block_4).should eq([2, 1])
+    end
+  end
+
+  context 'when variable/method with hash' do
+    let(:code_1) { load_args_block('blah arg_1, arg_2, k: :v') }
+    let(:code_2) { load_args_block('blah(arg_1, arg_2, k: :v)') }
+    let(:code_3) { load_args_block('blah arg_1, arg_2, k1: :v1, k2: :v2') }
+    let(:code_4) { load_args_block('blah(arg_1, arg_2, k1: :v1, k2: :v2)') }
+
+    it 'counts arguments' do
+      analyzer.count(code_1).should eq([3, 1])
+      analyzer.count(code_2).should eq([3, 1])
+    end
+
+    it 'counts hash keys as argumets' do
+      analyzer.count(code_3).should eq([4, 1])
+      analyzer.count(code_4).should eq([4, 1])
+    end
+  end
+
+  context 'when argument with default value' do
+    let(:code_1) { load_args_block('blah arg_1 = "blah"') }
+    let(:code_2) { load_args_block('blah(arg_1 = "blah")') }
+
+    it 'counts arguments' do
+      analyzer.count(code_1).should eq([1, 1])
+      analyzer.count(code_2).should eq([1, 1])
+    end
+  end
+end

data/spec/test_classes/1.rb

@@ -0,0 +1,6 @@
+module MyApp
+    class TestClass
+      def blah
+        end
+  end
+  end

data/spec/test_classes/10.rb

@@ -0,0 +1,9 @@
+class User
+  def initialize
+    @name = Faker::Lorem.word
+  end
+
+  def hi
+    puts @name
+  end
+end

data/spec/test_classes/11.rb

@@ -0,0 +1,5 @@
+class TestClass
+  def blah
+    call :a, :b, :c, :d, key: :value
+  end
+end

data/spec/test_classes/2.rb

@@ -0,0 +1,3 @@
+  class TestClass
+    def blah
+      end

data/spec/test_classes/3.rb

@@ -0,0 +1,5 @@
+class TestClass
+  def blah
+    User.blah(1,2,3,4,5)
+  end
+end

data/spec/test_classes/4.rb

@@ -0,0 +1,9 @@
+class FirstTestClass
+  def first_meth(blah)
+  end
+end
+
+class SecondTestClass
+  def second_meth blah
+  end
+end

data/spec/test_classes/5.rb

@@ -0,0 +1 @@
+class OneLinerClass; end

data/spec/test_classes/6.rb

@@ -0,0 +1,9 @@
+module MyApp::Blah
+  def module_meth
+  end
+
+  class User
+    def class_meth
+    end
+  end
+end

data/spec/test_classes/7.rb

@@ -0,0 +1,14 @@
+module MyApp::Blah
+  def module_meth
+  end
+
+  class User
+    def class_meth
+    end
+
+    class SubUser
+      def sub_meth
+      end
+    end
+  end
+end

data/spec/test_classes/8.rb

@@ -0,0 +1,12 @@
+class RailsController
+  def index
+  end
+
+  def destroy
+  end
+
+  private
+  def private_meth
+  end
+
+end

data/spec/test_classes/9_controller.rb

@@ -0,0 +1,5 @@
+class UsersController
+  def index
+    @users = User.page(params[:page])
+  end
+end

data/spec/test_helper.rb

@@ -0,0 +1,49 @@
+require 'rspec/autorun'
+require 'ripper'
+
+def test_file_path(file_name)
+  File.join(
+    File.dirname(__FILE__),
+    "test_classes/#{file_name}.rb"
+  )
+end
+
+def read_test_file(file_name)
+  File.read(
+    test_file_path(file_name)
+  )
+end
+
+def load_args_block(method_call)
+  loader = ArgsLoader.new
+  loader.load(method_call)
+end
+
+class ArgsLoader
+  def reset!
+    @sexp = nil
+  end
+
+  def load(method_call)
+    reset!
+    load_method_add_arg(Ripper.sexp(method_call))
+    return @sexp
+  end
+
+  private
+  def load_method_add_arg(method_sexp)
+    method_sexp.each do |s|
+      next unless s.kind_of?(Array)
+
+      s.each do |a|
+        next unless a.kind_of?(Array)
+
+        if a.first == :args_add_block
+          @sexp ||= a
+        else
+          load_method_add_arg(s)
+        end
+      end
+    end
+  end
+end

data/spec/warning_scanner_spec.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+require_relative '../lib/warning_scanner'
+
+describe WarningScanner do
+  let(:scanner) { WarningScanner.new }
+
+  describe 'scanning class with indentation warnings' do
+    let(:test_class) { read_test_file(1) }
+
+    before do
+      scanner.scan(test_class)
+    end
+
+    it 'finds indentation warnings for method' do
+      scanner.indentation_warnings['def'].should eq([[3, 4]])
+    end
+
+    it 'finds indentation warnings for class' do
+      scanner.indentation_warnings['class'].should eq([[2, 5]])
+    end
+
+    it 'finds indentation warnings for module' do
+      scanner.indentation_warnings['module'].should eq([[1, 6]])
+    end
+  end
+
+  describe 'scanning class with syntax error' do
+    let(:test_class) { read_test_file(2) }
+
+    it 'raise syntax error' do
+      expect {
+        scanner.scan(test_class)
+      }.to raise_error(SyntaxError)
+    end
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: sandi_meter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Anatoli Makarevich
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Sandi Metz rules checker
+email:
+- makaroni4@gmail.com
+executables:
+- sandi_meter
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- 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/version.rb
+- lib/warning_scanner.rb
+- bin/sandi_meter
+- spec/analyzer_spec.rb
+- spec/loc_checker_spec.rb
+- spec/method_arguments_counter_spec.rb
+- spec/test_classes/1.rb
+- spec/test_classes/10.rb
+- spec/test_classes/11.rb
+- spec/test_classes/2.rb
+- spec/test_classes/3.rb
+- spec/test_classes/4.rb
+- spec/test_classes/5.rb
+- spec/test_classes/6.rb
+- spec/test_classes/7.rb
+- spec/test_classes/8.rb
+- spec/test_classes/9_controller.rb
+- spec/test_helper.rb
+- spec/warning_scanner_spec.rb
+homepage: https://github.com/makaroni4/sandi_meter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.5
+signing_key: 
+specification_version: 4
+summary: Sandi Metz rules checker
+test_files: []