improve_your_code 1.0.0

data/lib/improve_your_code/smell_detectors/base_detector.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative '../smell_warning'
+require_relative '../smell_configuration'
+
+module ImproveYourCode
+  module SmellDetectors
+    class BaseDetector
+      attr_reader :config
+
+      EXCLUDE_KEY = 'exclude'
+
+      def initialize(context:)
+        @config = SmellConfiguration.new(self.class.default_config)
+        @context = context
+      end
+
+      def self.todo_configuration_for(smells)
+        default_exclusions = default_config.fetch EXCLUDE_KEY
+        exclusions = default_exclusions + smells.map(&:context)
+
+        { smell_type => { EXCLUDE_KEY => exclusions.uniq } }
+      end
+
+      def run
+        sniff
+      end
+
+      def smell_type
+        self.class.smell_type
+      end
+
+      private
+
+      attr_reader :context
+
+      def config_for(ctx)
+        ctx.config_for(self.class)
+      end
+
+      def enabled?
+        config.enabled? && config_for(context)[
+          SmellConfiguration::ENABLED_KEY
+        ] != false
+      end
+
+      def exception?
+        context.matches?(value(EXCLUDE_KEY, context))
+      end
+
+      def expression
+        @expression ||= context.exp
+      end
+
+      def smell_warning(options = {})
+        context = options.fetch(:context)
+        exp = context.exp
+        SmellWarning.new(self,
+          source: exp.source,
+          context: context.full_name,
+          lines: options.fetch(:lines),
+          message: options.fetch(:message),
+          parameters: options.fetch(:parameters, {}))
+      end
+
+      def source_line
+        @line ||= expression.line
+      end
+
+      def value(key, ctx)
+        config_for(ctx)[key] || config.value(key, ctx)
+      end
+
+      class << self
+        def smell_type
+          @smell_type ||= name.split(/::/).last
+        end
+
+        def contexts
+          %i[def defs]
+        end
+
+        def default_config
+          {
+            SmellConfiguration::ENABLED_KEY => true,
+            EXCLUDE_KEY => []
+          }
+        end
+
+        def inherited(subclass)
+          descendants << subclass
+        end
+
+        def descendants
+          @descendants ||= []
+        end
+
+        def valid_detector?(detector)
+          descendants.map { |descendant| descendant.to_s.split('::').last }
+            .include?(detector)
+        end
+
+        def to_detector(detector_name)
+          SmellDetectors.const_get detector_name
+        end
+
+        def configuration_keys
+          Set.new(default_config.keys.map(&:to_sym))
+        end
+      end
+    end
+  end
+end

data/lib/improve_your_code/smell_detectors/long_parameter_list.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'base_detector'
+
+module ImproveYourCode
+  module SmellDetectors
+    class LongParameterList < BaseDetector
+      MAX_ALLOWED_PARAMS_KEY = 'max_params'
+
+      def self.default_config
+        super.merge(
+          MAX_ALLOWED_PARAMS_KEY => 3,
+          SmellConfiguration::OVERRIDES_KEY => {
+            'initialize' => { MAX_ALLOWED_PARAMS_KEY => 3 }
+          }
+        )
+      end
+
+      def sniff
+        count = expression.arg_names.length
+
+        return [] if count <= max_allowed_params
+
+        message = "has #{count} parameters. "\
+                  "We propose to use Builder Pattern."
+
+        [
+          smell_warning(
+            context: context,
+            lines: [source_line],
+            message: message,
+            parameters: { count: count }
+          )
+        ]
+      end
+
+      private
+
+      def max_allowed_params
+        value(MAX_ALLOWED_PARAMS_KEY, context)
+      end
+    end
+  end
+end

data/lib/improve_your_code/smell_detectors/too_many_constants.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'base_detector'
+
+module ImproveYourCode
+  module SmellDetectors
+    class TooManyConstants < BaseDetector
+      MAX_ALLOWED_CONSTANTS_KEY = 'max_constants'
+      DEFAULT_MAX_CONSTANTS = 3
+      IGNORED_NODES = %i[module class].freeze
+
+      def self.contexts
+        %i[class module]
+      end
+
+      def self.default_config
+        super.merge(
+          MAX_ALLOWED_CONSTANTS_KEY => DEFAULT_MAX_CONSTANTS,
+          EXCLUDE_KEY => []
+        )
+      end
+
+      def sniff
+        count = constants_count
+
+        return [] if count <= max_allowed_constants
+
+        build_smell_warning(count)
+      end
+
+      private
+
+      def constants_count
+        context.each_node(:casgn, IGNORED_NODES)
+          .delete_if(&:defines_module?).length
+      end
+
+      def max_allowed_constants
+        value(MAX_ALLOWED_CONSTANTS_KEY, context)
+      end
+
+      def build_smell_warning(count)
+        [
+          smell_warning(
+            context: context,
+            lines: [source_line],
+            message: "has #{count} constants",
+            parameters: { count: count }
+          )
+        ]
+      end
+    end
+  end
+end

data/lib/improve_your_code/smell_detectors/too_many_instance_variables.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'base_detector'
+
+module ImproveYourCode
+  module SmellDetectors
+    class TooManyInstanceVariables < BaseDetector
+      MAX_ALLOWED_IVARS_KEY = 'max_instance_variables'
+      DEFAULT_MAX_IVARS = 3
+
+      def self.contexts
+        [:class]
+      end
+
+      def self.default_config
+        super.merge(
+          MAX_ALLOWED_IVARS_KEY => DEFAULT_MAX_IVARS,
+          EXCLUDE_KEY => []
+        )
+      end
+
+      def sniff
+        variables = context.local_nodes(:ivasgn, [:or_asgn]).map(&:name)
+        count = variables.uniq.size
+
+        return [] if count <= max_allowed_ivars
+
+        message = "has at least #{count} instance variables. "\
+                  "We propose to use Facade Pattern"
+
+        [
+          smell_warning(
+            context: context,
+            lines: [source_line],
+            message: message,
+            parameters: { count: count }
+          )
+        ]
+      end
+
+      private
+
+      def max_allowed_ivars
+        value(MAX_ALLOWED_IVARS_KEY, context)
+      end
+    end
+  end
+end

data/lib/improve_your_code/smell_detectors/too_many_methods.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'base_detector'
+
+module ImproveYourCode
+  module SmellDetectors
+    class TooManyMethods < BaseDetector
+      MAX_ALLOWED_METHODS_KEY = 'max_methods'
+      DEFAULT_MAX_METHODS = 5
+
+      def self.contexts
+        [:class]
+      end
+
+      def self.default_config
+        super.merge(
+          MAX_ALLOWED_METHODS_KEY => DEFAULT_MAX_METHODS,
+          EXCLUDE_KEY => []
+        )
+      end
+
+      def sniff
+        count = context.node_instance_methods.length
+
+        return [] if count <= max_allowed_methods
+
+        message = "Your class has #{count} methods. "\
+                  'We propose to use ExtractClass Pattern'
+
+        [
+          smell_warning(
+            context: context,
+            lines: [source_line],
+            message: message,
+            parameters: { count: count }
+          )
+        ]
+      end
+
+      private
+
+      def max_allowed_methods
+        value(MAX_ALLOWED_METHODS_KEY, context)
+      end
+    end
+  end
+end

data/lib/improve_your_code/smell_detectors/too_many_statements.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'base_detector'
+
+module ImproveYourCode
+  module SmellDetectors
+    class TooManyStatements < BaseDetector
+      MAX_ALLOWED_STATEMENTS_KEY = 'max_statements'
+      DEFAULT_MAX_STATEMENTS = 5
+
+      def self.default_config
+        super.merge(
+          MAX_ALLOWED_STATEMENTS_KEY => DEFAULT_MAX_STATEMENTS,
+          EXCLUDE_KEY => ['initialize']
+        )
+      end
+
+      def sniff
+        count = context.number_of_statements
+
+        return [] if count <= max_allowed_statements
+
+        message = "Your method has #{count} statements. "\
+                  'We propose to use ExtractMethod Pattern'
+
+        [
+          smell_warning(
+            context: context,
+            lines: [source_line],
+            message: message,
+            parameters: { count: count }
+          )
+        ]
+      end
+
+      private
+
+      def max_allowed_statements
+        value(MAX_ALLOWED_STATEMENTS_KEY, context)
+      end
+    end
+  end
+end

data/lib/improve_your_code/smell_detectors/uncommunicative_method_name.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'base_detector'
+
+module ImproveYourCode
+  module SmellDetectors
+    class UncommunicativeMethodName < BaseDetector
+      REJECT_KEY = 'reject'
+      ACCEPT_KEY = 'accept'
+      DEFAULT_REJECT_PATTERNS = [/^[a-z]$/, /[0-9]$/, /[A-Z]/].freeze
+      DEFAULT_ACCEPT_PATTERNS = [].freeze
+
+      def self.default_config
+        super.merge(
+          REJECT_KEY => DEFAULT_REJECT_PATTERNS,
+          ACCEPT_KEY => DEFAULT_ACCEPT_PATTERNS
+        )
+      end
+
+      def sniff
+        name = context.name.to_s
+
+        return [] if acceptable_name?(name)
+
+        [
+          smell_warning(
+            context: context,
+            lines: [source_line],
+            message: "has the name '#{name}'",
+            parameters: { name: name }
+          )
+        ]
+      end
+
+      private
+
+      def acceptable_name?(name)
+        any_acceptance_patterns?(name) || any_reject_patterns?(name)
+      end
+
+      def any_acceptance_patterns?(name)
+        accept_patterns.any? { |accept_pattern| name.match accept_pattern }
+      end
+
+      def any_reject_patterns?(name)
+        reject_patterns.none? { |reject_pattern| name.match reject_pattern }
+      end
+
+      def reject_patterns
+        Array value(REJECT_KEY, context)
+      end
+
+      def accept_patterns
+        Array value(ACCEPT_KEY, context)
+      end
+    end
+  end
+end

data/lib/improve_your_code/smell_detectors/uncommunicative_module_name.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative 'base_detector'
+
+module ImproveYourCode
+  module SmellDetectors
+    class UncommunicativeModuleName < BaseDetector
+      REJECT_KEY = 'reject'
+      DEFAULT_REJECT_PATTERNS = [/^.$/, /[0-9]$/].freeze
+      ACCEPT_KEY = 'accept'
+      DEFAULT_ACCEPT_PATTERNS = [].freeze
+
+      def self.default_config
+        super.merge(
+          REJECT_KEY => DEFAULT_REJECT_PATTERNS,
+          ACCEPT_KEY => DEFAULT_ACCEPT_PATTERNS
+        )
+      end
+
+      def self.contexts
+        %i[module class]
+      end
+
+      def sniff
+        fully_qualified_name = context.full_name
+        module_name          = expression.simple_name
+
+        return [] if acceptable_name?(
+          module_name: module_name,
+          fully_qualified_name: fully_qualified_name
+        )
+
+        [
+          smell_warning(
+            context: context,
+            lines: [source_line],
+            message: "has the name '#{module_name}'",
+            parameters: { name: module_name }
+          )
+        ]
+      end
+
+      private
+
+      def acceptable_name?(module_name:, fully_qualified_name:)
+        any_accept_patterns?(module_name) ||
+          any_reject_patterns?(fully_qualified_name)
+      end
+
+      def any_accept_patterns?(fully_qualified_name)
+        accept_patterns.any? do |accept_pattern|
+          fully_qualified_name.match accept_pattern
+        end
+      end
+
+      def any_reject_patterns?(module_name)
+        reject_patterns.none? do |reject_pattern|
+          module_name.match reject_pattern
+        end
+      end
+
+      def reject_patterns
+        @reject_patterns ||= Array value(REJECT_KEY, context)
+      end
+
+      def accept_patterns
+        @accept_patterns ||= Array value(ACCEPT_KEY, context)
+      end
+    end
+  end
+end