reek 3.1 → 3.2

data/lib/reek/rake/task.rb

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 
+require 'private_attr/everywhere'
 require 'rake'
 require 'rake/tasklib'
 require 'pathname'
@@ -38,17 +39,17 @@ module Reek
 
       # Path to reek's config file.
       # Setting the REEK_CFG environment variable overrides this.
-      attr_writer :config_file
+      attr_accessor :config_file
 
       # Glob pattern to match source files.
       # Setting the REEK_SRC environment variable overrides this.
       # Defaults to 'lib/**/*.rb'.
-      attr_writer :source_files
+      attr_accessor :source_files
 
       # String containing commandline options to be passed to Reek.
       # Setting the REEK_OPTS environment variable overrides this value.
       # Defaults to ''.
-      attr_writer :reek_opts
+      attr_accessor :reek_opts
 
       # Whether or not to fail Rake when an error occurs (typically when smells are found).
       # Defaults to true.
@@ -59,10 +60,11 @@ module Reek
       attr_writer :verbose
 
       def initialize(name = :reek)
+        @config_file   = ENV['REEK_CFG']
         @name          = name
-        @reek_opts     = ''
+        @reek_opts     = ENV['REEK_OPTS'] || ''
         @fail_on_error = true
-        @source_files  = 'lib/**/*.rb'
+        @source_files  = ENV['REEK_SRC'] || 'lib/**/*.rb'
         @verbose       = false
 
         yield self if block_given?
@@ -71,15 +73,17 @@ module Reek
 
       private
 
+      private_attr_reader :fail_on_error, :name, :verbose
+
       def define_task
         desc 'Check for code smells'
-        task(@name) { run_task }
+        task(name) { run_task }
       end
 
       def run_task
-        puts "\n\n!!! Running 'reek' rake command: #{command}\n\n" if @verbose
+        puts "\n\n!!! Running 'reek' rake command: #{command}\n\n" if verbose
         system(*command)
-        abort("\n\n!!! `reek` has found smells - exiting!") if sys_call_failed? && @fail_on_error
+        abort("\n\n!!! `reek` has found smells - exiting!") if sys_call_failed? && fail_on_error
       end
 
       def command
@@ -88,25 +92,12 @@ module Reek
           reject(&:empty?)
       end
 
-      def source_files
-        FileList[ENV['REEK_SRC'] || @source_files]
-      end
-
-      def reek_opts
-        ENV['REEK_OPTS'] || @reek_opts
-      end
-
-      def config_file
-        ENV['REEK_CFG'] || @config_file
-      end
-
       def sys_call_failed?
         !$CHILD_STATUS.success?
       end
 
       def config_file_as_argument
-        return [] unless @config_file
-        ['-c', @config_file]
+        config_file ? ['-c', config_file] : []
       end
 
       def reek_opts_as_arguments

data/lib/reek/report/formatter.rb

@@ -35,7 +35,7 @@ module Reek
       end
 
       def format(warning)
-        "#{@location_formatter.format(warning)}#{base_format(warning)}"
+        "#{location_formatter.format(warning)}#{base_format(warning)}"
       end
 
       private
@@ -43,6 +43,10 @@ module Reek
       def base_format(warning)
         "#{warning.context} #{warning.message} (#{warning.smell_type})"
       end
+
+      private
+
+      private_attr_reader :location_formatter
     end
 
     #

data/lib/reek/report/report.rb

@@ -30,8 +30,8 @@ module Reek
       #
       # @param [Reek::Examiner] examiner object to report on
       def add_examiner(examiner)
-        @total_smell_count += examiner.smells_count
-        @examiners << examiner
+        self.total_smell_count += examiner.smells_count
+        examiners << examiner
         self
       end
 
@@ -42,13 +42,22 @@ module Reek
 
       # @api private
       def smells?
-        @total_smell_count > 0
+        total_smell_count > 0
       end
 
       # @api private
       def smells
-        @examiners.map(&:smells).flatten
+        examiners.map(&:smells).flatten
       end
+
+      protected
+
+      attr_accessor :total_smell_count
+
+      private
+
+      private_attr_reader :examiners, :options, :report_formatter,
+                          :sort_by_issue_count, :warning_formatter
     end
 
     #
@@ -64,7 +73,7 @@ module Reek
       private
 
       def smell_summaries
-        @examiners.map { |ex| summarize_single_examiner(ex) }.reject(&:empty?)
+        examiners.map { |ex| summarize_single_examiner(ex) }.reject(&:empty?)
       end
 
       def display_summary
@@ -72,33 +81,33 @@ module Reek
       end
 
       def display_total_smell_count
-        return unless @examiners.size > 1
+        return unless examiners.size > 1
         print total_smell_count_message
       end
 
       def summarize_single_examiner(examiner)
         result = heading_formatter.header(examiner)
         if examiner.smelly?
-          formatted_list = @report_formatter.format_list(examiner.smells,
-                                                         @warning_formatter)
+          formatted_list = report_formatter.format_list(examiner.smells,
+                                                        warning_formatter)
           result += ":\n#{formatted_list}"
         end
         result
       end
 
       def sort_examiners
-        @examiners.sort_by!(&:smells_count).reverse! if @sort_by_issue_count
+        examiners.sort_by!(&:smells_count).reverse! if sort_by_issue_count
       end
 
       def total_smell_count_message
         colour = smells? ? WARNINGS_COLOR : NO_WARNINGS_COLOR
-        s = @total_smell_count == 1 ? '' : 's'
-        Rainbow("#{@total_smell_count} total warning#{s}\n").color(colour)
+        s = total_smell_count == 1 ? '' : 's'
+        Rainbow("#{total_smell_count} total warning#{s}\n").color(colour)
       end
 
       def heading_formatter
         @heading_formatter ||=
-          @options.fetch(:heading_formatter, HeadingFormatter::Quiet).new(@report_formatter)
+          options.fetch(:heading_formatter, HeadingFormatter::Quiet).new(report_formatter)
       end
     end
 
@@ -118,7 +127,7 @@ module Reek
       def show
         print ::JSON.generate(
           smells.map do |smell|
-            smell.yaml_hash(@warning_formatter)
+            smell.yaml_hash(warning_formatter)
           end
         )
       end
@@ -144,53 +153,46 @@ module Reek
       require 'rexml/document'
 
       def show
-        checkstyle = REXML::Element.new('checkstyle', document)
-
-        smells.group_by(&:source).each do |file, file_smells|
-          file_to_xml(file, file_smells, checkstyle)
-        end
-
-        print_xml(checkstyle.parent)
+        document.write output: $stdout, indent: 2
+        $stdout.puts
       end
 
       private
 
       def document
-        REXML::Document.new.tap do |doc|
-          doc << REXML::XMLDecl.new
+        REXML::Document.new.tap do |document|
+          document << REXML::XMLDecl.new << checkstyle
         end
       end
 
-      def file_to_xml(file, file_smells, parent)
-        REXML::Element.new('file', parent).tap do |element|
-          element.attributes['name'] = File.realpath(file)
-          smells_to_xml(file_smells, element)
+      def checkstyle
+        REXML::Element.new('checkstyle').tap do |checkstyle|
+          smells.group_by(&:source).each do |source, source_smells|
+            checkstyle << file(source, source_smells)
+          end
         end
       end
 
-      def smells_to_xml(smells, parent)
-        smells.each do |smell|
-          smell_to_xml(smell, parent)
+      def file(name, smells)
+        REXML::Element.new('file').tap do |file|
+          file.add_attribute 'name', File.realpath(name)
+          smells.each do |smell|
+            smell.lines.each do |line|
+              file << error(smell, line)
+            end
+          end
         end
       end
 
-      def smell_to_xml(smell, parent)
-        REXML::Element.new('error', parent).tap do |element|
-          attributes = [
-            ['line', smell.lines.first],
-            ['column', 0],
-            ['severity', 'warning'],
-            ['message', smell.message],
-            ['source', smell.smell_type]
-          ]
-          element.add_attributes(attributes)
+      def error(smell, line)
+        REXML::Element.new('error').tap do |error|
+          error.add_attributes 'column'   => 0,
+                               'line'     => line,
+                               'message'  => smell.message,
+                               'severity' => 'warning',
+                               'source'   => smell.smell_type
         end
       end
-
-      def print_xml(document)
-        formatter = REXML::Formatters::Default.new
-        puts formatter.write(document, '')
-      end
     end
   end
 end

data/lib/reek/smells/attribute.rb

@@ -9,22 +9,18 @@ module Reek
     # invites client classes to become too intimate with its inner workings,
     # and in particular with its representation of state.
     #
-    # Currently this detector raises a warning for every +attr+,
-    # +attr_reader+, +attr_writer+ and +attr_accessor+ -- including those
-    # that are private.
+    # This detector raises a warning for every public +attr_writer+,
+    # +attr_accessor+, and +attr+ with the writable flag set to +true+.
     #
     # See {file:docs/Attribute.md} for details.
     # @api private
     #
     # TODO: Catch attributes declared "by hand"
     class Attribute < SmellDetector
-      ATTR_DEFN_METHODS = [:attr, :attr_reader, :attr_writer, :attr_accessor]
+      ATTR_DEFN_METHODS = [:attr_writer, :attr_accessor]
       VISIBILITY_MODIFIERS = [:private, :public, :protected]
 
       def initialize(*args)
-        @visiblity_tracker = {}
-        @visiblity_mode = :public
-        @result = Set.new
         super
       end
 
@@ -32,39 +28,61 @@ module Reek
         [:class, :module]
       end
 
-      def self.default_config
-        super.merge(SmellConfiguration::ENABLED_KEY => false)
-      end
-
       #
       # Checks whether the given class declares any attributes.
       #
       # @return [Array<SmellWarning>]
       #
       def examine_context(ctx)
+        self.visiblity_tracker = {}
+        self.visiblity_mode = :public
         attributes_in(ctx).map do |attribute, line|
           SmellWarning.new self,
                            context: ctx.full_name,
                            lines: [line],
-                           message:  "declares the attribute #{attribute}",
+                           message:  "declares the writable attribute #{attribute}",
                            parameters: { name: attribute.to_s }
         end
       end
 
       private
 
+      private_attr_accessor :visiblity_mode, :visiblity_tracker
+      private_attr_reader :result
+
       def attributes_in(module_ctx)
+        attributes = Set.new
         module_ctx.local_nodes(:send) do |call_node|
-          if visibility_modifier?(call_node)
-            track_visibility(call_node)
-          elsif ATTR_DEFN_METHODS.include?(call_node.method_name)
-            call_node.arg_names.each do |arg|
-              @visiblity_tracker[arg] = @visiblity_mode
-              @result << [arg, call_node.line]
-            end
-          end
+          attributes += track_attributes(call_node)
         end
-        @result.select { |args| recorded_public_methods.include?(args[0]) }
+        attributes.select { |name, _line| recorded_public_methods.include?(name) }
+      end
+
+      def track_attributes(call_node)
+        if attribute_writer? call_node
+          return track_arguments call_node.args, call_node.line
+        end
+        track_visibility call_node if visibility_modifier? call_node
+        []
+      end
+
+      def attribute_writer?(call_node)
+        ATTR_DEFN_METHODS.include?(call_node.method_name) ||
+          attr_with_writable_flag?(call_node)
+      end
+
+      def attr_with_writable_flag?(call_node)
+        call_node.method_name == :attr && call_node.args.last.type == :true
+      end
+
+      def track_arguments(args, line)
+        args.select { |arg| arg.type == :sym }.map { |arg| track_argument(arg, line) }
+      end
+
+      def track_argument(arg, line)
+        arg_name = arg.children.first
+        visiblity_tracker[arg_name] = visiblity_mode
+        [arg_name, line]
       end
 
       def visibility_modifier?(call_node)
@@ -73,14 +91,14 @@ module Reek
 
       def track_visibility(call_node)
         if call_node.arg_names.any?
-          call_node.arg_names.each { |arg| @visiblity_tracker[arg] = call_node.method_name }
+          call_node.arg_names.each { |arg| visiblity_tracker[arg] = call_node.method_name }
         else
-          @visiblity_mode = call_node.method_name
+          self.visiblity_mode = call_node.method_name
         end
       end
 
       def recorded_public_methods
-        @visiblity_tracker.select { |_, visbility| visbility == :public }
+        visiblity_tracker.select { |_, visbility| visbility == :public }
       end
     end
   end

data/lib/reek/smells/control_parameter.rb

@@ -73,16 +73,20 @@ module Reek
         end
 
         def smells?
-          @occurences.any?
+          occurences.any?
         end
 
         def lines
-          @occurences.map(&:line)
+          occurences.map(&:line)
         end
 
         def name
-          @param.to_s
+          param.to_s
         end
+
+        private
+
+        private_attr_reader :occurences, :param
       end
 
       # Finds cases of ControlParameter in a particular node for a particular parameter
@@ -108,13 +112,15 @@ module Reek
 
         private
 
+        private_attr_reader :node, :param
+
         def conditional_nodes
-          @node.body_nodes(CONDITIONAL_NODE_TYPES)
+          node.body_nodes(CONDITIONAL_NODE_TYPES)
         end
 
         def nested_finders
           @nested_finders ||= conditional_nodes.flat_map do |node|
-            self.class.new(node, @param)
+            self.class.new(node, param)
           end
         end
 
@@ -129,12 +135,12 @@ module Reek
 
         def uses_of_param_in_condition
           return [] unless condition
-          condition.each_node(:lvar).select { |inner| inner.var_name == @param }
+          condition.each_node(:lvar).select { |inner| inner.var_name == param }
         end
 
         def condition
-          return nil unless CONDITIONAL_NODE_TYPES.include? @node.type
-          @node.condition
+          return nil unless CONDITIONAL_NODE_TYPES.include? node.type
+          node.condition
         end
 
         def regular_call_involving_param?(call_node)
@@ -150,12 +156,12 @@ module Reek
         end
 
         def call_involving_param?(call_node)
-          call_node.each_node(:lvar).any? { |it| it.var_name == @param }
+          call_node.each_node(:lvar).any? { |it| it.var_name == param }
         end
 
         def uses_param_in_body?
-          nodes = @node.body_nodes([:lvar], [:if, :case, :and, :or])
-          nodes.any? { |lvar_node| lvar_node.var_name == @param }
+          nodes = node.body_nodes([:lvar], [:if, :case, :and, :or])
+          nodes.any? { |lvar_node| lvar_node.var_name == param }
         end
       end
 
@@ -175,12 +181,14 @@ module Reek
 
         private
 
+        private_attr_reader :context
+
         def potential_parameters
-          @context.exp.parameter_names
+          context.exp.parameter_names
         end
 
         def find_matches(param)
-          ControlParameterFinder.new(@context.exp, param).find_matches
+          ControlParameterFinder.new(context.exp, param).find_matches
         end
       end
     end