sandi_meter 1.0.3 → 1.0.4

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NjQ3NGNjZTlkNjIxYWQxYWMxZmZkOTg5NTZjYjdjYmEyNDQyNTkyMA==
+    NjM5NTVlNTgyZGU3ZDQ2ZjgyMzU0MmY1YjkwZmFkNjViMjYzNzE1YQ==
   data.tar.gz: !binary |-
-    YzEyNzM3MjRjYWZlNmE5N2M4YmUyOTY5N2M3YzExNTg2ZmVjN2I3Yg==
-!binary "U0hBNTEy":
+    NjJjODA5ZDlkZDQwZmU0OThmYjAzOGM0ZjJhMjEzNjI0ZWI0M2E1OQ==
+SHA512:
   metadata.gz: !binary |-
-    ZmU5NzY1ZmYwNWVkMjUzNWYxN2RkODEzMzUyMzdmODVhNDk0MzRhOGE0MDMz
-    MjBlM2ViYjBiOWZjNzViYTNhMDI5MjkwMGYyYTgzZjE2YTc5NzNjYWVmZjVh
-    ZTk0YjhkYzY2MTViNDgzODVhOTJkNzdmNjM4NmNkNmQ2NmRiNjc=
+    YzE5OTlmMjQ2NzkzMzY4MzU5NDYwMDEwYjNlOGNiMTI5ZDc0MDlkODdlZjFm
+    ODdiM2Q3ZTkwMzc5YjE2M2QzMDc3MjhjZmUxMjNhNzU3ODQ4MzYyYzM0YjRj
+    MjQwYzBkOGIzNjM2ZjlhODg0NjAyZmJiNWYxY2NmODk1YjRiYmU=
   data.tar.gz: !binary |-
-    ZTA4OWE3NWI5Y2E0YWMyODk3MGM3MDExNjdlMTk1YzIxODM4NTk4NjE3NTRk
-    ZDI3NDc5MjZiZGNiYjkwNTM3YzhhNjNjZmEwZWJiMzU5NDcwOTQwNmMyNjAz
-    MTlmZGE4ZmRmZmZkZWU0ODQxNzg4MWYyM2JiZjA0NmQ5OTk1NWQ=
+    NDU3NmQ4MGIwYmU5YmQ1MjdiNjJjMTk1ODRiZWM0MmYzYThjZTk0NmRjODZj
+    OGQxOGZkOTVhMTI2YzU5YWZlODg5MmM1ZDYxOTA1ZjBhYWYxMDQzODNmMzRk
+    YTRiM2VhODZjYjNmYWM5NjIyZjljNmJlZDA2YjMwMDBjZTJhNTQ=

data/bin/sandi_meter

@@ -1,5 +1,7 @@
 #!/usr/bin/env ruby
 
+$LOAD_PATH << File.expand_path("../../lib", __FILE__)
+
 require 'sandi_meter/cli'
 
 SandiMeter::CLI.execute

data/html/script.js

@@ -35,7 +35,7 @@ function plotLine(id, data, ykeys, labels) {
   });
 }
 
-function latestReport(data) {
+function lastReport(data) {
   return data.sort(function(a, b){
     var keyA = new Date(a.timestamp),
     keyB = new Date(b.timestamp);
@@ -47,23 +47,24 @@ function latestReport(data) {
 }
 
 function dateHeader(last_report) {
-  var d = Date(last_report.timestamp).toString().split(' ');
+  var date = new Date(last_report.timestamp);
+  var d = date.toString().split(' ');
   return date_string = [d[3], d[1], d[2], d[4]].join(' ');
 }
 
 function setHeader(last_report) {
-  $('.js-report-date').text("Latest report from " + dateHeader(latest_report));
+  $('.js-report-date').text("Latest report from " + dateHeader(last_report));
 }
 
 $(document).ready(function(){
-  latest_report = latestReport(data);
+  last_report = lastReport(data);
 
-  setHeader();
+  setHeader(last_report);
 
-  plotDonut(latest_report.r10, latest_report.r11, '1. Classes under 100 lines', '1. Classes more than 100 lines', 'pie1');
-  plotDonut(latest_report.r20, latest_report.r21, '2. Methods under 5 lines', '2. Methods more than 5 lines', 'pie2');
-  plotDonut(latest_report.r30, latest_report.r31, '3. Method calls with less than 4 params', '3. Method calls with more than 4 params', 'pie3');
-  plotDonut(latest_report.r40, latest_report.r41, '4. Controllers with one instance variable', '4. Controllers with many instance variables', 'pie4');
+  plotDonut(last_report.r10, last_report.r11, '1. Classes under 100 lines', '1. Classes more than 100 lines', 'pie1');
+  plotDonut(last_report.r20, last_report.r21, '2. Methods under 5 lines', '2. Methods more than 5 lines', 'pie2');
+  plotDonut(last_report.r30, last_report.r31, '3. Method calls with less than 4 params', '3. Method calls with more than 4 params', 'pie3');
+  plotDonut(last_report.r40, last_report.r41, '4. Controllers with one instance variable', '4. Controllers with many instance variables', 'pie4');
 
   plotLine('plot1', data, ['r10', 'r11'], ['under 100 lines', 'more than 100 lines.']);
   plotLine('plot2', data, ['r20', 'r21'], ['under 5 lines', 'more than 5 lines']);

data/lib/sandi_meter/analyzer.rb

@@ -2,21 +2,19 @@ require 'ripper'
 require_relative 'warning_scanner'
 require_relative 'loc_checker'
 require_relative 'method_arguments_counter'
+require_relative 'sandi_meter/class'
+require_relative 'sandi_meter/method_call'
+require_relative 'sandi_meter/method'
 
 module SandiMeter
   class Analyzer
-    attr_reader :classes, :misindented_classes, :methods, :misindented_methods, :method_calls, :instance_variables
+    attr_accessor :parent_token, :private_or_protected
+    attr_reader :classes, :methods, :method_calls
 
     def initialize
       @classes = []
-      @misindented_classes = []
-      @misindented_methods = {}
       @methods = {}
       @method_calls = []
-      @instance_variables = {}
-
-      @parent_token = nil
-      @private_or_protected = false
     end
 
     def analyze(file_path)
@@ -26,7 +24,7 @@ module SandiMeter
       @indentation_warnings = indentation_warnings
       # TODO
       # add better determination wheter file is controller
-      @scan_instance_variables = !!(file_path =~ /\w+_controller.rb$/)
+      @controller = !!(file_path =~ /\w+_controller.rb$/)
 
       sexp = Ripper.sexp(@file_body)
       scan_sexp(sexp)
@@ -38,28 +36,6 @@ module SandiMeter
     def output
       loc_checker = SandiMeter::LOCChecker.new(@file_lines)
 
-      @classes.map! do |klass_params|
-        klass_params << loc_checker.check(klass_params, 'class')
-        klass_params << "#{@file_path}:#{klass_params[1]}"
-      end
-
-      @misindented_classes.map! do |klass_params|
-        klass_params << "#{@file_path}:#{klass_params[1]}"
-      end
-
-      @methods.each_pair do |klass, methods|
-        methods.each do |method_params|
-          method_params << loc_checker.check(method_params, 'def')
-          method_params << "#{@file_path}:#{method_params[1]}"
-        end
-      end
-
-      @misindented_methods.each_pair do |klass, methods|
-        methods.each do |method_params|
-          method_params << "#{@file_path}:#{method_params[1]}"
-        end
-      end
-
       {
         classes: @classes,
         misindented_classes: @misindented_classes,
@@ -79,7 +55,11 @@ module SandiMeter
       class_tokens.insert(0, current_namespace) unless current_namespace.empty?
       class_name = class_tokens.join('::')
 
-      [class_name, line_number]
+      {
+        name: class_name,
+        first_line: line_number,
+        path: @file_path
+      }
     end
 
     # MOVE
@@ -92,12 +72,15 @@ module SandiMeter
     end
 
     def find_method_params(sexp)
-      sexp[1].flatten[1,2]
+      name, first_line = sexp[1].flatten[1, 2]
+      {
+        name: name,
+        first_line: first_line,
+        path: @file_path
+      }
     end
 
-    def find_last_line(params, token = 'class')
-      token_name, line = params
-
+    def find_last_line(line, token = 'class')
       token_indentation = @file_lines[line - 1].index(token)
       # TODO
       # add check for trailing spaces
@@ -110,24 +93,21 @@ module SandiMeter
       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
+
+        module_params[:last_line] = find_last_line(module_params[:first_line], 'module')
+        current_namespace = module_params[:name]
 
         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
-          @misindented_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 ? @misindented_classes : @classes) << class_params
+        unless @indentation_warnings['class'] && @indentation_warnings['class'].any? { |first_line, last_line| first_line == class_params[:first_line] }
+          class_params[:last_line] = find_last_line(class_params[:first_line])
         end
 
-        current_namespace = class_params.first
+        @classes << SandiMeter::Class.new(class_params)
+
+        current_namespace = class_params[:name]
         scan_sexp(element, current_namespace)
       end
     end
@@ -142,7 +122,11 @@ module SandiMeter
           counter = SandiMeter::MethodArgumentsCounter.new
           arguments_count, line = counter.count(sexp)
 
-          @method_calls << [arguments_count, "#{@file_path}:#{line}"]
+          @method_calls << SandiMeter::MethodCall.new(
+            path: @file_path,
+            first_line: line,
+            number_of_arguments: arguments_count
+          )
 
           find_args_add_block(sexp)
         else
@@ -158,9 +142,8 @@ module SandiMeter
         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] if sexp[1][1][0] == :@ivar
+          method = @methods[current_namespace].find { |m| m.name == method_name }
+          method.ivars << sexp[1][1][1] if sexp[1][1][0] == :@ivar
         else
           scan_def_for_ivars(current_namespace, method_name, sexp)
         end
@@ -175,19 +158,16 @@ module SandiMeter
         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)
-            @misindented_methods[current_namespace] ||= []
-            @misindented_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
+          method_params[:number_of_arguments] = number_of_arguments(element)
+          unless @indentation_warnings['def'] && @indentation_warnings['def'].any? { |first_line, last_line| first_line == method_params[:first_line] }
+            method_params[:last_line] = find_last_line(method_params[:first_line], 'def')
           end
-          if @scan_instance_variables && !@private_or_protected
-            scan_def_for_ivars(current_namespace, method_params.first, element)
+
+          @methods[current_namespace] ||= []
+          @methods[current_namespace] << SandiMeter::Method.new(method_params) unless @private_or_protected
+
+          if @controller && !@private_or_protected
+            scan_def_for_ivars(current_namespace, method_params[:name], element)
           end
 
           find_args_add_block(element)

data/lib/sandi_meter/calculator.rb

@@ -31,16 +31,13 @@ module SandiMeter
     private
     def log_first_rule
       @output[:first_rule][:log] ||= {}
-      @output[:first_rule][:log][:classes] = @data[:classes].inject([]) do |log, class_params|
-        # TODO
-        # wrap each class params into class and get params with
-        # verbose name instead of array keys (class_params[2] should be klass.line_count)
-        log << [class_params.first, class_params[2] - class_params[1] - 1, class_params.last] if class_params[-2] == false
+      @output[:first_rule][:log][:classes] = @data[:classes].inject([]) do |log, klass|
+        log << [klass.name, klass.size, klass.path] if klass.last_line && !klass.small?
         log
       end
 
-      @output[:first_rule][:log][:misindented_classes] = @data[:misindented_classes].inject([]) do |log, class_params|
-        log << [class_params.first, nil, class_params.last]
+      @output[:first_rule][:log][:misindented_classes] = @data[:classes].select { |c| c.last_line.nil? }.inject([]) do |log, klass|
+        log << [klass.name, nil, klass.path]
         log
       end
     end
@@ -51,25 +48,16 @@ module SandiMeter
       @output[:second_rule][:log][:misindented_methods] ||= []
 
       @data[:methods].each_pair do |klass, methods|
-        methods.select { |m| m[-2] == false }.each do |method_params|
-          params = [klass, method_params.first]
-          # TODO
-          # wrap method param to method class so method_params[1] becomes method.first_line
-          # and method_params[2] method.last_line
-          params << method_params[2] - method_params[1] - 1
-          params << method_params.last
-
-          @output[:second_rule][:log][:methods] << params
+        methods.select { |m| !m.misindented? && !m.small? }.each do |method|
+          @output[:second_rule][:log][:methods] << [klass, method.name, method.size, method.path]
         end
       end
 
-      @data[:misindented_methods].each_pair do |klass, methods|
-        methods.each do |method_params|
-          params = [klass, method_params.first]
-          params << nil
-          params << method_params.last
+      @data[:methods].each_pair do |klass, methods|
+        methods.each do |method|
+          next unless method.misindented?
 
-          @output[:second_rule][:log][:misindented_methods] << params
+          @output[:second_rule][:log][:misindented_methods] << [klass, method.name, method.size, method.path]
         end
       end
     end
@@ -80,8 +68,8 @@ module SandiMeter
 
       # TODO
       # add name of method being called
-      proper_method_calls = @data[:method_calls].inject(0) do |sum, params|
-        @output[:third_rule][:log][:method_calls] << params if params.first > 4
+      proper_method_calls = @data[:method_calls].inject(0) do |sum, method_call|
+        @output[:third_rule][:log][:method_calls] << [method_call.number_of_arguments, method_call.path] if method_call.number_of_arguments > 4
       end
     end
 
@@ -89,23 +77,20 @@ module SandiMeter
       @output[:fourth_rule][:log] ||={}
       @output[:fourth_rule][:log][:controllers] ||= []
 
-      @data[:instance_variables].each_pair do |controller, methods|
-        methods.each_pair do |method, instance_variables|
-          if instance_variables.size > 1
-            @output[:fourth_rule][:log][:controllers] << [controller, method, instance_variables]
-          end
+      @data[:classes].select { |c| c.controller }.each do |klass|
+        @data[:methods][klass].each do |method|
+          next if method.ivars.empty?
+
+          @output[:fourth_rule][:log][:controllers] << [klass.name, method.name, method.ivars]
         end
       end
     end
 
     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[-2] == true
-        sum
-      end
+      small_classes_amount = @data[:classes].select(&:small?).size
 
-      misindented_classes_amount = @data[:misindented_classes].size
+      misindented_classes_amount = @data[:classes].select { |c| c.last_line.nil? }
 
       @output[:first_rule] ||= {}
       @output[:first_rule][:small_classes_amount] = small_classes_amount
@@ -120,13 +105,13 @@ module SandiMeter
       small_methods_amount = 0
 
       @data[:methods].each_pair do |klass, methods|
-        small_methods_amount += methods.select { |m| m[-2] == true }.size
+        small_methods_amount += methods.select { |m| m.small? }.size
         total_methods_amount += methods.size
       end
 
       misindented_methods_amount = 0
-      @data[:misindented_methods].each_pair do |klass, methods|
-        misindented_methods_amount += methods.size
+      @data[:methods].each_pair do |klass, methods|
+        misindented_methods_amount += methods.select { |m| m.last_line.nil? }.size
       end
 
       @output[:second_rule] ||= {}
@@ -142,8 +127,8 @@ module SandiMeter
     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
+      proper_method_calls = @data[:method_calls].inject(0) do |sum, method_call|
+        sum += 1 unless method_call.number_of_arguments > 4
         sum
       end
 
@@ -158,9 +143,9 @@ module SandiMeter
       proper_controllers_amount = 0
       total_controllers_amount = 0
 
-      @data[:instance_variables].each_pair do |controller, methods|
+      @data[:classes].select { |c| c.controller? }.each do |klass|
         total_controllers_amount += 1
-        proper_controllers_amount += 1 unless methods.values.map(&:size).any? { |v| v > 1 }
+        proper_controllers_amount += 1 unless @data[:methods][klass.name].select { |m| m.ivars.uniq.size > 1 }.empty?
       end
 
       @output[:fourth_rule] ||= {}

data/lib/sandi_meter/cli.rb

@@ -2,6 +2,7 @@
 require 'mixlib/cli'
 require 'sandi_meter/file_scanner'
 require 'sandi_meter/formatter'
+require 'sandi_meter/rules_checker'
 require 'sandi_meter/logger'
 require 'sandi_meter/version'
 require 'sandi_meter/html_generator'
@@ -61,6 +62,18 @@ module SandiMeter
       cli = CommandParser.new
       cli.parse_options
 
+      if cli.config[:graph]
+        log_dir_path = File.join(cli.config[:path], 'sandi_meter')
+        FileUtils.mkdir(log_dir_path) unless Dir.exists?(log_dir_path)
+        # put ignore file
+        ignore_file_path = File.join(cli.config[:path], 'sandi_meter', '.sandi_meter')
+        if File.directory?(cli.config[:path]) && !File.exists?(ignore_file_path)
+          File.open(ignore_file_path, "w") do |file|
+            file.write %w(db vendor).join("\n")
+          end
+        end
+      end
+
       if cli.config[:version]
         # stolen from gem 'bubs' :)
         puts "SandiMeter ".tr('A-Za-z1-90', 'Ⓐ-Ⓩⓐ-ⓩ①-⑨⓪').split('').join(' ') + SandiMeter::VERSION
@@ -81,28 +94,26 @@ module SandiMeter
 
       if cli.config[:graph]
         if File.directory?(cli.config[:path])
-          logger = SandiMeter::Logger.new
-          logger.log!(cli.config[:path], data)
+          logger = SandiMeter::Logger.new(data)
+          logger.log!(cli.config[:path])
 
           html_generator = SandiMeter::HtmlGenerator.new
           html_generator.copy_assets!(cli.config[:path])
           html_generator.generate_data!(cli.config[:path])
           html_generator.generate_details!(cli.config[:path], data)
 
-          # put ignore file
-          ignore_file_path = File.join(cli.config[:path], 'sandi_meter', '.sandi_meter')
-          if File.directory?(cli.config[:path]) && !File.exists?(ignore_file_path)
-            File.open(ignore_file_path, "w") do |file|
-              file.write %w(db vendor).join("\n")
-            end
-          end
-
           index_html_path = File.join(cli.config[:path], 'sandi_meter/index.html')
           system "open #{index_html_path}"
         else
           puts "WARNING!!! HTML mode works only if you scan folder."
         end
       end
+
+      if RulesChecker.new(data).ok?
+        exit 0
+      else
+        exit 1
+      end
     end
 
     def self.show_sandi_rules

data/lib/sandi_meter/file_scanner.rb

@@ -22,7 +22,7 @@ module SandiMeter
 
     private
     def scan_dir(path)
-      Dir["#{path}/**/*.rb"].reject { |f| @exclude_patterns && f =~ /#{@exclude_patterns}/ }.each do |file|
+      Dir["#{path}/**/*.rb"].reject { |f| !@exclude_patterns.to_s.empty? && f =~ /#{@exclude_patterns}/ }.each do |file|
         scan_file(file)
       end
     end

data/lib/sandi_meter/logger.rb

@@ -1,34 +1,32 @@
 require 'fileutils'
 
 module SandiMeter
-  class Logger
-    def log!(path, data)
-      log_dir_path = File.join(path, 'sandi_meter')
-      FileUtils.mkdir(log_dir_path) unless Dir.exists?(log_dir_path)
-
-      File.open(File.join(log_dir_path, 'sandi_meter.log'), 'a') do |file|
-        file.puts(log_line(data))
+  class Logger < Struct.new(:data)
+    def log!(path)
+      File.open(File.join(path, 'sandi_meter', 'sandi_meter.log'), 'a') do |file|
+        file.puts(log_line)
       end
     end
 
     private
-    def log_line(data)
-      log_line_data = []
-      log_line_data << data[:first_rule][:small_classes_amount]
-      log_line_data << data[:first_rule][:total_classes_amount] - data[:first_rule][:small_classes_amount]
-
-      log_line_data << data[:second_rule][:small_methods_amount]
-      log_line_data << data[:second_rule][:total_methods_amount] - data[:second_rule][:small_methods_amount]
-
-      log_line_data << data[:third_rule][:proper_method_calls]
-      log_line_data << data[:third_rule][:total_method_calls] - data[:third_rule][:proper_method_calls]
-
-      log_line_data << data[:fourth_rule][:proper_controllers_amount]
-      log_line_data << data[:fourth_rule][:total_controllers_amount] - data[:fourth_rule][:proper_controllers_amount]
+    def log_line
+      rules_log.join(';')
+    end
 
-      log_line_data << Time.now.to_i
+    def log_rule(rule_key, proper_key, total_key)
+      [
+        data[rule_key][proper_key],
+        data[rule_key][total_key] - data[rule_key][proper_key]
+      ]
+    end
 
-      log_line_data.join(';')
+    def rules_log
+      log_line_data = [log_rule(:first_rule, :small_classes_amount, :total_classes_amount)]
+      log_line_data += log_rule(:second_rule, :small_methods_amount, :total_methods_amount)
+      log_line_data += log_rule(:third_rule, :proper_method_calls, :total_method_calls)
+      log_line_data += log_rule(:fourth_rule, :proper_controllers_amount, :total_controllers_amount)
+      log_line_data += [Time.now.to_i]
     end
   end
 end
+

data/lib/sandi_meter/rules_checker.rb

@@ -0,0 +1,20 @@
+module SandiMeter
+  class RulesChecker
+    def initialize(data)
+      @rules = []
+      @rules << percentage(data[:first_rule][:small_classes_amount], data[:first_rule][:total_classes_amount])
+      @rules << percentage(data[:second_rule][:small_methods_amount], data[:second_rule][:total_methods_amount])
+      @rules << percentage(data[:third_rule][:proper_method_calls], data[:third_rule][:total_method_calls])
+      @rules << percentage(data[:fourth_rule][:proper_controllers_amount], data[:fourth_rule][:total_controllers_amount])
+    end
+
+    def ok?
+      @rules.all? { |rule| rule == 1 }
+    end
+
+    private
+    def percentage(amount, total)
+      total > 0 ? amount / total : 1
+    end
+  end
+end

data/lib/sandi_meter/sandi_meter/class.rb

@@ -0,0 +1,29 @@
+module SandiMeter
+  class Class
+    MAX_LOC = 100
+
+    attr_accessor :name, :path, :first_line, :last_line, :controller
+
+    def initialize(params = {})
+      params.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+    end
+
+    def size
+      last_line and (last_line - first_line - 1)
+    end
+
+    def small?
+      last_line && size <= MAX_LOC
+    end
+
+    def misindented?
+      !!(last_line)
+    end
+
+    def controller?
+      !!(path =~ /\w+_controller.rb$/)
+    end
+  end
+end

data/lib/sandi_meter/sandi_meter/method.rb

@@ -0,0 +1,26 @@
+module SandiMeter
+  class Method
+    MAX_LOC = 5
+
+    attr_accessor :name, :misindented, :first_line, :last_line, :path, :number_of_arguments, :ivars
+
+    def initialize(params = {})
+      params.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+      @ivars = []
+    end
+
+    def size
+      @last_line - @first_line - 1 if @last_line
+    end
+
+    def misindented?
+      !(@last_line)
+    end
+
+    def small?
+      size <= MAX_LOC if @last_line
+    end
+  end
+end

data/lib/sandi_meter/sandi_meter/method_call.rb

@@ -0,0 +1,11 @@
+module SandiMeter
+  class MethodCall
+    attr_accessor :path, :number_of_arguments, :first_line
+
+    def initialize(params = {})
+      params.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+    end
+  end
+end

data/lib/sandi_meter/version.rb

@@ -1,3 +1,3 @@
 module SandiMeter
-  VERSION = "1.0.3"
+  VERSION = "1.0.4"
 end

data/spec/analyzer_spec.rb

@@ -12,17 +12,34 @@ describe SandiMeter::Analyzer do
     end
 
     it 'finds indentation warnings for method' do
-      analyzer.classes.should eq([["TestClass", 1, 5, true, "#{test_file_path(3)}:1"]])
-      analyzer.misindented_classes.should be_empty
+      klass = analyzer.classes.find { |c| c.name == "TestClass" }
+
+      klass.should have_attributes(
+        first_line: 1,
+        last_line: 5,
+        path: test_file_path(3)
+      )
     end
 
     it 'finds methods' do
-      analyzer.methods.should eq({"TestClass"=>[["blah", 2, 4, 0, true, "#{test_file_path(3)}:2"]]})
-      analyzer.misindented_methods.should be_empty
+      method = analyzer.methods["TestClass"].find { |m| m.name == "blah" }
+
+      method.should have_attributes(
+        first_line: 2,
+        last_line: 4,
+        number_of_arguments: 0,
+        path: test_file_path(3)
+      )
     end
 
     it 'finds method calls that brakes third rule' do
-      analyzer.method_calls.should eq([[5, "#{test_file_path(3)}:3"]])
+      method_call = analyzer.method_calls.first
+
+      method_call.should have_attributes(
+        first_line: 3,
+        number_of_arguments: 5,
+        path: test_file_path(3)
+      )
     end
   end
 
@@ -34,13 +51,24 @@ describe SandiMeter::Analyzer do
     end
 
     it 'finds indentation warnings for method' do
-      analyzer.classes.should be_empty
-      analyzer.misindented_classes.should eq([["MyApp::TestClass", 2, nil, "#{test_file_path(1)}:2"]])
+      klass = analyzer.classes.find { |c| c.name == "MyApp::TestClass" }
+
+      klass.should have_attributes(
+        first_line: 2,
+        last_line: nil,
+        path: test_file_path(1)
+      )
     end
 
     it 'finds methods' do
-      analyzer.methods.should be_empty
-      analyzer.misindented_methods.should eq({"MyApp::TestClass"=>[["blah", 3, nil, 0, "#{test_file_path(1)}:3"]]})
+      method = analyzer.methods["MyApp::TestClass"].find { |m| m.name == "blah" }
+
+      method.should have_attributes(
+        first_line: 3,
+        last_line: nil,
+        number_of_arguments: 0,
+        path: test_file_path(1)
+      )
     end
   end
 
@@ -52,15 +80,41 @@ describe SandiMeter::Analyzer do
     end
 
     it 'finds classes' do
-      analyzer.classes.should include(["FirstTestClass", 1, 4, true, "#{test_file_path(4)}:1"])
-      analyzer.classes.should include(["SecondTestClass", 6, 9, true, "#{test_file_path(4)}:6"])
-      analyzer.misindented_classes.should be_empty
+      klass = analyzer.classes.find { |c| c.name == "FirstTestClass" }
+
+      klass.should have_attributes(
+        first_line: 1,
+        last_line: 4,
+        path: test_file_path(4)
+      )
+
+      klass = analyzer.classes.find { |c| c.name == "SecondTestClass" }
+
+      klass.should have_attributes(
+        first_line: 6,
+        last_line: 9,
+        path: test_file_path(4)
+      )
     end
 
     it 'finds methods' do
-      analyzer.methods["FirstTestClass"].should eq([["first_meth", 2, 3, 1, true, "#{test_file_path(4)}:2"]])
-      analyzer.methods["SecondTestClass"].should eq([["second_meth", 7, 8, 1, true, "#{test_file_path(4)}:7"]])
-      analyzer.misindented_methods.should be_empty
+      method = analyzer.methods["FirstTestClass"].find { |m| m.name == "first_meth" }
+
+      method.should have_attributes(
+        first_line: 2,
+        last_line: 3,
+        number_of_arguments: 1,
+        path: test_file_path(4)
+      )
+
+      method = analyzer.methods["SecondTestClass"].find { |m| m.name == "second_meth" }
+
+      method.should have_attributes(
+        first_line: 7,
+        last_line: 8,
+        number_of_arguments: 1,
+        path: test_file_path(4)
+      )
     end
   end
 
@@ -72,13 +126,17 @@ describe SandiMeter::Analyzer do
     end
 
     it 'finds classes' do
-      analyzer.misindented_classes.should eq([["OneLinerClass", 1, nil, "#{test_file_path(5)}:1"]])
-      analyzer.classes.should be_empty
+      klass = analyzer.classes.find { |c| c.name == "OneLinerClass" }
+
+      klass.should have_attributes(
+        first_line: 1,
+        last_line: nil,
+        path: test_file_path(5)
+      )
     end
 
     it 'finds methods' do
       analyzer.methods.should be_empty
-      analyzer.misindented_methods.should be_empty
     end
   end
 
@@ -90,16 +148,45 @@ describe SandiMeter::Analyzer do
     end
 
     it 'finds class and subclass' do
-      analyzer.classes.should include(["MyApp::Blah::User", 5, 13, true, "#{test_file_path(7)}:5"])
-      analyzer.classes.should include(["MyApp::Blah::User::SubUser", 9, 12, true, "#{test_file_path(7)}:9"])
-      analyzer.misindented_classes.should be_empty
+      klass = analyzer.classes.find { |c| c.name == "MyApp::Blah::User" }
+      klass.should have_attributes(
+        first_line: 5,
+        last_line: 13,
+        path: test_file_path(7)
+      )
+
+      klass = analyzer.classes.find { |c| c.name == "MyApp::Blah::User::SubUser" }
+      klass.should have_attributes(
+        first_line: 9,
+        last_line: 12,
+        path: test_file_path(7)
+      )
     end
 
     it 'finds methods' do
-      analyzer.methods["MyApp::Blah"].should eq([["module_meth", 2, 3, 0, true, "#{test_file_path(7)}:2"]])
-      analyzer.methods["MyApp::Blah::User"].should eq([["class_meth", 6, 7, 0, true, "#{test_file_path(7)}:6"]])
-      analyzer.methods["MyApp::Blah::User::SubUser"].should eq([["sub_meth", 10, 11, 0, true, "#{test_file_path(7)}:10"]])
-      analyzer.misindented_methods.should be_empty
+      method = analyzer.methods["MyApp::Blah"].find { |m| m.name == "module_meth" }
+      method.should have_attributes(
+        first_line: 2,
+        last_line: 3,
+        number_of_arguments: 0,
+        path: test_file_path(7)
+      )
+
+      method = analyzer.methods["MyApp::Blah::User"].find { |m| m.name == "class_meth" }
+      method.should have_attributes(
+        first_line: 6,
+        last_line: 7,
+        number_of_arguments: 0,
+        path: test_file_path(7)
+      )
+
+      method = analyzer.methods["MyApp::Blah::User::SubUser"].find { |m| m.name == "sub_meth" }
+      method.should have_attributes(
+        first_line: 10,
+        last_line: 11,
+        number_of_arguments: 0,
+        path: test_file_path(7)
+      )
     end
   end
 
@@ -111,15 +198,33 @@ describe SandiMeter::Analyzer do
     end
 
     it 'finds class and subclass' do
-      analyzer.classes.should include(["RailsController", 1, 12, true, "#{test_file_path(8)}:1"])
-      analyzer.misindented_classes.should be_empty
+      klass = analyzer.classes.find { |c| c.name == "RailsController" }
+      klass.should have_attributes(
+        first_line: 1,
+        last_line: 12,
+        path: test_file_path(8)
+      )
     end
 
     it 'finds methods' do
-      analyzer.methods["RailsController"].should include(["index", 2, 3, 0, true, "#{test_file_path(8)}:2"])
-      analyzer.methods["RailsController"].should include(["destroy", 5, 6, 0, true, "#{test_file_path(8)}:5"])
-      analyzer.methods["RailsController"].should include(["private_meth", 9, 10, 0, true, "#{test_file_path(8)}:9"])
-      analyzer.misindented_methods.should be_empty
+      method = analyzer.methods["RailsController"].find { |m| m.name == "index" }
+      method.should have_attributes(
+        first_line: 2,
+        last_line: 3,
+        number_of_arguments: 0,
+        path: test_file_path(8)
+      )
+
+      method = analyzer.methods["RailsController"].find { |m| m.name == "destroy" }
+      method.should have_attributes(
+        first_line: 5,
+        last_line: 6,
+        number_of_arguments: 0,
+        path: test_file_path(8)
+      )
+
+      method = analyzer.methods["RailsController"].find { |m| m.name == "private_meth" }
+      method.should be_nil
     end
   end
 
@@ -132,7 +237,8 @@ describe SandiMeter::Analyzer do
       end
 
       it 'finds instance variable' do
-        analyzer.instance_variables.should eq({"UsersController"=>{"index"=>["@users"]}})
+        method = analyzer.methods["UsersController"].find { |m| m.name == "index" }
+        method.ivars.should eq(["@users"])
       end
     end
 
@@ -144,7 +250,8 @@ describe SandiMeter::Analyzer do
       end
 
       it 'does not find instance variables' do
-        analyzer.instance_variables.should eq({"GuestController"=>{"create_guest_user"=>[]}})
+        method = analyzer.methods["GuestController"].find { |m| m.name == "create_guest_user" }
+        method.ivars.should be_empty
       end
     end
 
@@ -156,7 +263,11 @@ describe SandiMeter::Analyzer do
       end
 
       it 'does not find instance variable' do
-        analyzer.instance_variables.should be_empty
+        method = analyzer.methods["User"].find { |m| m.name == "initialize" }
+        method.ivars.should be_empty
+
+        method = analyzer.methods["User"].find { |m| m.name == "hi" }
+        method.ivars.should be_empty
       end
     end
 
@@ -168,22 +279,24 @@ describe SandiMeter::Analyzer do
       end
 
       it 'finds method defined after public keyword' do
-        analyzer.instance_variables["UsersController"].should have_key("create")
+        method = analyzer.methods["UsersController"].find { |m| m.name == "create" }
+        method.ivars.should eq(["@user"])
       end
 
       it 'omits actions without instance variables' do
-        analyzer.instance_variables["UsersController"].should_not have_key("show")
+        method = analyzer.methods["UsersController"].find { |m| m.name == "show" }
+        method.ivars.should be_empty
       end
 
       it 'omits private methods' do
-        analyzer.instance_variables["UsersController"].should_not have_key("find_user")
+        method = analyzer.methods["UsersController"].find { |m| m.name == "find_user" }
+        method.should be_nil
       end
 
       it 'omits protected methods' do
-        analyzer.instance_variables["UsersController"].should_not have_key("protected_find_user")
+        method = analyzer.methods["UsersController"].find { |m| m.name == "protected_find_user" }
+        method.should be_nil
       end
-
-
     end
   end
 
@@ -195,7 +308,13 @@ describe SandiMeter::Analyzer do
     end
 
     it 'counts arguments' do
-      analyzer.method_calls.should eq([[5, "#{test_file_path(11)}:3"]])
+      method_call = analyzer.method_calls.first
+
+      method_call.should have_attributes(
+        first_line: 3,
+        number_of_arguments: 5,
+        path: test_file_path(11)
+      )
     end
   end
 
@@ -207,11 +326,24 @@ describe SandiMeter::Analyzer do
     end
 
     it 'are count for class definition' do
-      analyzer.classes.should eq([["Valera", 1, 109, false, "#{test_file_path(12)}:1"]])
+      klass = analyzer.classes.find { |c| c.name == "Valera" }
+
+      klass.should have_attributes(
+        first_line: 1,
+        last_line: 109,
+        path: test_file_path(12)
+      )
     end
 
     it 'are count for method definition' do
-      analyzer.methods.should eq({"Valera"=>[["doodle", 2, 9, 0, false, "#{test_file_path(12)}:2"]]})
+      method = analyzer.methods["Valera"].find { |m| m.name == "doodle" }
+
+      method.should have_attributes(
+        first_line: 2,
+        last_line: 9,
+        number_of_arguments: 0,
+        path: test_file_path(12)
+      )
     end
   end
 
@@ -236,15 +368,36 @@ describe SandiMeter::Analyzer do
     end
 
     it 'mark 4line methods good' do
-      methods.should include(["render4", 2, 7, 0, true, "#{test_file_path(14)}:2"])
+      method = analyzer.methods["TestClass"].find { |m| m.name == "render4" }
+
+      method.should have_attributes(
+        first_line: 2,
+        last_line: 7,
+        number_of_arguments: 0,
+        path: test_file_path(14)
+      )
     end
 
     it 'mark 5line methods good' do
-      methods.should include(["render5", 9, 15, 0, true, "#{test_file_path(14)}:9"])
+      method = analyzer.methods["TestClass"].find { |m| m.name == "render5" }
+
+      method.should have_attributes(
+        first_line: 9,
+        last_line: 15,
+        number_of_arguments: 0,
+        path: test_file_path(14)
+      )
     end
 
     it 'mark 6line methods bad' do
-      methods.should include(["render6", 17, 24, 0, false, "#{test_file_path(14)}:17"])
+      method = analyzer.methods["TestClass"].find { |m| m.name == "render6" }
+
+      method.should have_attributes(
+        first_line: 17,
+        last_line: 24,
+        number_of_arguments: 0,
+        path: test_file_path(14)
+      )
     end
   end
 end

data/spec/calculator_spec.rb

@@ -16,13 +16,13 @@ describe SandiMeter::Calculator do
 
     it 'counts class lines' do
       output = calculator.calculate!(true)
-      class_params = output[:first_rule][:log][:classes].find { |params| params.first == "User" }
-      class_params[1].should eq(109)
+      klass = output[:first_rule][:log][:classes].find { |params| params.first == "User" }
+      klass[1].should eq(109)
     end
 
     it 'counts method lines' do
       output = calculator.calculate!(true)
-      method_params = output[:second_rule][:log][:methods].find { |params| params.first == "User" && params[1] == "create" }
+      method_params = output[:second_rule][:log][:methods].find { |method| method[1] == "create" }
       method_params[2].should eq(6)
     end
   end

data/spec/rules_checker_spec.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+require_relative '../lib/sandi_meter/rules_checker'
+
+describe SandiMeter::RulesChecker do
+  let(:fail_conditions) do
+    {
+      first_rule:  { small_classes_amount: 1,      total_classes_amount: 2 },
+      second_rule: { small_methods_amount: 2,      total_methods_amount: 2 },
+      third_rule:  { proper_method_calls: 2,       total_method_calls: 2 },
+      fourth_rule: { proper_controllers_amount: 2, total_controllers_amount: 2 }
+    }
+  end
+
+  let(:succeed_conditions) do
+    {
+      first_rule:  { small_classes_amount: 2,      total_classes_amount: 2 },
+      second_rule: { small_methods_amount: 2,      total_methods_amount: 2 },
+      third_rule:  { proper_method_calls: 2,       total_method_calls: 2 },
+      fourth_rule: { proper_controllers_amount: 0, total_controllers_amount: 0 }
+    }
+  end
+
+  describe "#ok?" do
+    it "returns false in any of conditions fail" do
+      expect(SandiMeter::RulesChecker.new(fail_conditions)).to_not be_ok
+    end
+
+    it "returns true if all of conditions succeed" do
+      expect(SandiMeter::RulesChecker.new(succeed_conditions)).to be_ok
+    end
+  end
+end

data/spec/support/args_loader.rb

@@ -0,0 +1,28 @@
+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/support/attr_matcher.rb

@@ -0,0 +1,28 @@
+require 'rspec/expectations'
+
+RSpec::Matchers.define :have_attributes do |expected|
+  match do |actual|
+    result = true
+    expected.each do |key, value|
+      result = false unless actual.send(key) == value
+    end
+
+    result
+  end
+
+  failure_message_for_should do |actual|
+    wrong_fields = {}
+    expected.each do |key, value|
+      wrong_fields[key] = {
+        actual: actual.send(key),
+        expected: value
+      } unless actual.send(key) == value
+    end
+
+    wrong_fields.inject("In #{actual.class.name} ") do |message, wrong_field|
+      key, value = wrong_field
+      message << "expected that #{key} would be #{value[:expected]}, but was #{value[:actual]}\n"
+      message
+    end
+  end
+end

data/spec/support/helper_methods.rb

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

data/spec/test_helper.rb

@@ -1,49 +1,4 @@
 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
+Dir["#{Dir.pwd}/spec/support/**/*.rb"].each { |f| require f }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sandi_meter
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Anatoli Makarevich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-23 00:00:00.000000000 Z
+date: 2013-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -82,6 +82,10 @@ files:
 - lib/sandi_meter/loc_checker.rb
 - lib/sandi_meter/logger.rb
 - lib/sandi_meter/method_arguments_counter.rb
+- lib/sandi_meter/rules_checker.rb
+- lib/sandi_meter/sandi_meter/class.rb
+- lib/sandi_meter/sandi_meter/method.rb
+- lib/sandi_meter/sandi_meter/method_call.rb
 - lib/sandi_meter/version.rb
 - lib/sandi_meter/warning_scanner.rb
 - bin/sandi_meter
@@ -89,6 +93,10 @@ files:
 - spec/calculator_spec.rb
 - spec/loc_checker_spec.rb
 - spec/method_arguments_counter_spec.rb
+- spec/rules_checker_spec.rb
+- spec/support/args_loader.rb
+- spec/support/attr_matcher.rb
+- spec/support/helper_methods.rb
 - spec/test_classes/1.rb
 - spec/test_classes/10.rb
 - spec/test_classes/10_controller.rb
@@ -129,7 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.5
+rubygems_version: 2.1.10
 signing_key: 
 specification_version: 4
 summary: Sandi Metz rules checker