improve_your_code 1.0.0

data/lib/improve_your_code/context_builder.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative 'context/attribute_context'
+require_relative 'context/method_context'
+require_relative 'context/module_context'
+require_relative 'context/root_context'
+require_relative 'context/send_context'
+require_relative 'context/singleton_attribute_context'
+require_relative 'context/singleton_method_context'
+require_relative 'ast/node'
+
+module ImproveYourCode
+  class ContextBuilder
+    attr_reader :context_tree
+
+    def initialize(syntax_tree)
+      @exp = syntax_tree
+      @current_context = Context::RootContext.new(exp)
+      @context_tree = build(exp)
+    end
+
+    private
+
+    attr_accessor :current_context
+    attr_reader :exp
+
+    def build(exp, parent_exp = nil)
+      context_processor = "process_#{exp.type}"
+
+      if context_processor_exists?(context_processor)
+        send(context_processor, exp, parent_exp)
+      else
+        process exp
+      end
+      current_context
+    end
+
+    def process(exp)
+      exp.children.grep(AST::Node).each { |child| build(child, exp) }
+    end
+
+    def process_module(exp, _parent)
+      inside_new_context(Context::ModuleContext, exp) do
+        process(exp)
+      end
+    end
+
+    alias process_class process_module
+
+    def process_def(exp, parent)
+      inside_new_context(current_context.method_context_class, exp, parent) do
+        increase_statement_count_by(exp.body)
+        process(exp)
+      end
+    end
+
+    def process_send(exp, _parent)
+      process(exp)
+      case current_context
+      when Context::ModuleContext
+        handle_send_for_modules exp
+      when Context::MethodContext
+        handle_send_for_methods exp
+      end
+    end
+
+    def process_begin(exp, _parent)
+      increase_statement_count_by(exp.children)
+      decrease_statement_count
+      process(exp)
+    end
+
+    alias process_kwbegin process_begin
+
+    def context_processor_exists?(name)
+      self.class.private_method_defined?(name)
+    end
+
+    def increase_statement_count_by(sexp)
+      current_context.statement_counter.increase_by sexp
+    end
+
+    def decrease_statement_count
+      current_context.statement_counter.decrease_by 1
+    end
+
+    def inside_new_context(klass, *args)
+      new_context = append_new_context(klass, *args)
+
+      orig = current_context
+      self.current_context = new_context
+      yield
+      self.current_context = orig
+    end
+
+    def append_new_context(klass, *args)
+      klass.new(*args).tap do |new_context|
+        new_context.register_with_parent(current_context)
+      end
+    end
+
+    def handle_send_for_modules(exp)
+      arg_names = exp.args.map { |arg| arg.children.first }
+      current_context.track_visibility(exp.name, arg_names)
+      register_attributes(exp)
+    end
+
+    def handle_send_for_methods(exp)
+      append_new_context(Context::SendContext, exp, exp.name)
+      current_context.record_call_to(exp)
+    end
+
+    def register_attributes(exp)
+      return unless exp.attribute_writer?
+      klass = current_context.attribute_context_class
+      exp.args.each do |arg|
+        append_new_context(klass, arg, exp)
+      end
+    end
+  end
+end

data/lib/improve_your_code/detector_repository.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'smell_detectors'
+require_relative 'smell_detectors/base_detector'
+
+module ImproveYourCode
+  class DetectorRepository
+    def self.eligible_smell_types
+      ImproveYourCode::SmellDetectors::BaseDetector
+        .descendants.sort_by(&:name)
+    end
+
+    def initialize(smell_types: self.class.smell_types)
+      @smell_types = smell_types
+    end
+
+    def examine(context)
+      smell_detectors_for(context.type).flat_map do |klass|
+        detector = klass.new context: context
+        detector.run
+      end
+    end
+
+    private
+
+    attr_reader :smell_types
+
+    def smell_detectors_for(type)
+      smell_types.select { |detector| detector.contexts.include? type }
+    end
+  end
+end

data/lib/improve_your_code/examiner.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'context_builder'
+require_relative 'detector_repository'
+require_relative 'source/source_code'
+
+module ImproveYourCode
+  class Examiner
+    def initialize(source)
+      @source = Source::SourceCode.from(source)
+      @smell_types = DetectorRepository.eligible_smell_types
+    end
+
+    def description
+      @description ||= source.origin
+    end
+
+    def smells
+      @smells ||= examine_tree.sort.uniq
+    end
+
+    def smells_count
+      smells.length
+    end
+
+    def smelly?
+      smells.any?
+    end
+
+    private
+
+    attr_reader :source
+
+    def detector_repository
+      DetectorRepository.new(smell_types: @smell_types)
+    end
+
+    def syntax_tree
+      @syntax_tree ||= source.syntax_tree
+    end
+
+    def examine_tree
+      ContextBuilder.new(syntax_tree).context_tree.flat_map do |element|
+        detector_repository.examine(element)
+      end
+    end
+  end
+end

data/lib/improve_your_code/report/formatter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'formatter/heading_formatter'
+require_relative 'formatter/progress_formatter'
+require_relative 'formatter/simple_warning_formatter'
+
+module ImproveYourCode
+  module Report
+    module Formatter
+      module_function
+
+      def format_list(warnings, formatter: SimpleWarningFormatter.new)
+        warnings.map { |warning| "  #{formatter.format(warning)}" }.join("\n")
+      end
+
+      def header(examiner)
+        count = examiner.smells_count
+        result = Rainbow("#{examiner.description} -- ").cyan +
+                 Rainbow("#{count} warning").yellow
+        result += Rainbow('s').yellow unless count == 1
+        result
+      end
+    end
+  end
+end

data/lib/improve_your_code/report/formatter/heading_formatter.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ImproveYourCode
+  module Report
+    module Formatter
+      class HeadingFormatterBase
+        attr_reader :report_formatter
+
+        def initialize(report_formatter)
+          @report_formatter = report_formatter
+        end
+
+        def show_header?(_examiner)
+          raise NotImplementedError
+        end
+
+        def header(examiner)
+          if show_header?(examiner)
+            report_formatter.header examiner
+          else
+            ''
+          end
+        end
+      end
+
+      class QuietHeadingFormatter < HeadingFormatterBase
+        def show_header?(examiner)
+          examiner.smelly?
+        end
+      end
+    end
+  end
+end

data/lib/improve_your_code/report/formatter/progress_formatter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ImproveYourCode
+  module Report
+    module Formatter
+      module ProgressFormatter
+        class Dots
+          def progress(examiner)
+            examiner.smelly? ? display_smelly : display_clean
+          end
+
+          private
+
+          def display_clean
+            Rainbow('.').color(:green)
+          end
+
+          def display_smelly
+            Rainbow('W').color(:red)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/improve_your_code/report/formatter/simple_warning_formatter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ImproveYourCode
+  module Report
+    module Formatter
+      class SimpleWarningFormatter
+        def format(warning)
+          "#{warning.lines.sort.inspect}:#{warning.base_message}"
+        end
+      end
+    end
+  end
+end

data/lib/improve_your_code/report/text_report.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'pathname'
+require 'rainbow'
+
+require_relative 'formatter'
+
+module ImproveYourCode
+  module Report
+    class TextReport
+      NO_WARNINGS_COLOR = :green
+      WARNINGS_COLOR = :red
+
+      def initialize
+        @examiners           = []
+        @total_smell_count   = 0
+        @heading_formatter   = Formatter::QuietHeadingFormatter.new(Formatter)
+        @progress_formatter  = Report::Formatter::ProgressFormatter::Dots.new
+        @warning_formatter   = Report::Formatter::SimpleWarningFormatter.new
+      end
+
+      def add_examiner(examiner)
+        print progress_formatter.progress examiner
+        
+        self.total_smell_count += examiner.smells_count
+
+        examiners << examiner
+      end
+
+      def show
+        print "\n\n"
+
+        display_summary
+
+        print total_smell_count_message
+      end
+
+      protected
+
+      attr_accessor :total_smell_count
+
+      private
+
+      attr_reader :examiners, :heading_formatter,
+        :warning_formatter, :progress_formatter
+
+      def smell_summaries
+        examiners.map { |ex| summarize_single_examiner(ex) }.reject(&:empty?)
+      end
+
+      def display_summary
+        smell_summaries.each { |smell| puts smell }
+      end
+
+      def summarize_single_examiner(examiner)
+        result = heading_formatter.header(examiner)
+        if examiner.smelly?
+          formatted_list = Formatter.format_list(examiner.smells,
+            formatter: warning_formatter)
+          result += ":\n#{formatted_list}"
+        end
+        result
+      end
+
+      def smells?
+        total_smell_count > 0
+      end
+
+      def total_smell_count_message
+        colour = smells? ? WARNINGS_COLOR : NO_WARNINGS_COLOR
+        Rainbow("#{total_smell_count} total warning#{total_smell_count == 1 ? '' : 's'}\n").color(colour)
+      end
+    end
+  end
+end

data/lib/improve_your_code/smell_configuration.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ImproveYourCode
+  class SmellConfiguration
+    ENABLED_KEY = 'enabled'
+    OVERRIDES_KEY = 'overrides'
+
+    def initialize(hash)
+      @options = hash
+    end
+
+    def merge(new_options)
+      options.merge!(new_options)
+    end
+
+    def enabled?
+      options[ENABLED_KEY]
+    end
+
+    def overrides_for(context)
+      Overrides.new(options.fetch(OVERRIDES_KEY, {})).for_context(context)
+    end
+
+    def value(key, context)
+      overrides_for(context).each { |conf| return conf[key] if conf.key?(key) }
+      options.fetch(key)
+    end
+
+    private
+
+    attr_reader :options
+  end
+
+  class Overrides
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def for_context(context)
+      contexts = hash.keys.select { |ckey| context.matches?([ckey]) }
+      contexts.map { |exc| hash[exc] }
+    end
+
+    private
+
+    attr_reader :hash
+  end
+end

data/lib/improve_your_code/smell_detectors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'smell_detectors/long_parameter_list'
+require_relative 'smell_detectors/too_many_instance_variables'
+require_relative 'smell_detectors/too_many_constants'
+require_relative 'smell_detectors/too_many_methods'
+require_relative 'smell_detectors/too_many_statements'
+require_relative 'smell_detectors/uncommunicative_method_name'
+require_relative 'smell_detectors/uncommunicative_module_name'
+require_relative 'smell_detectors/uncommunicative_variable_name'
+require_relative 'smell_detectors/unused_parameters'
+require_relative 'smell_detectors/unused_private_method'