reek 1.2.6 → 1.2.8

data/lib/reek/core/method_context.rb

@@ -0,0 +1,84 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'code_context')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'object_refs')
+
+module Reek
+  module Core
+
+    #
+    # The parameters in a method's definition.
+    #
+    module MethodParameters
+      def default_assignments
+        assignments = self[-1]
+        result = []
+        return result unless is_assignment_block?(assignments)
+        assignments[1..-1].each do |exp|
+          result << exp[1..2] if exp[0] == :lasgn
+        end
+        result
+      end
+      def is_arg?(param)
+        return false if is_assignment_block?(param)
+        return !(param.to_s =~ /^\&/)
+      end
+      def is_assignment_block?(param)
+        Array === param and param[0] == :block
+      end
+
+      def names
+        return @names if @names
+        @names = self[1..-1].select {|arg| is_arg?(arg)}.map {|arg| arg.to_s }
+      end
+
+      def length
+        names.length
+      end
+
+      def include?(name)
+        names.include?(name)
+      end
+    end
+
+    #
+    # A context wrapper for any method definition found in a syntax tree.
+    #
+    class MethodContext < CodeContext
+      attr_reader :parameters
+      attr_reader :refs
+      attr_reader :num_statements
+
+      def initialize(outer, exp)
+        super(outer, exp)
+        @parameters = exp[exp[0] == :defn ? 2 : 3]  # SMELL: SimulatedPolymorphism
+        @parameters ||= []
+        @parameters.extend(MethodParameters)
+        @num_statements = 0
+        @refs = ObjectRefs.new
+      end
+
+      def count_statements(num)
+        @num_statements += num
+      end
+
+      def record_call_to(exp)
+        receiver, meth = exp[1..2]
+        receiver ||= [:self]
+        case receiver[0]
+        when :lvar
+          @refs.record_ref(receiver) unless meth == :new
+        when :self
+          record_use_of_self
+        end
+      end
+
+      def record_use_of_self
+        @refs.record_reference_to_self
+      end
+
+      def envious_receivers
+        return [] if @refs.self_is_max?
+        @refs.max_keys
+      end
+    end
+  end
+end

data/lib/reek/core/module_context.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'code_context')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'code_parser')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'sniffer')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'source', 'sexp_formatter')
+
+module Reek
+  module Core
+
+    #
+    # A context wrapper for any module found in a syntax tree.
+    #
+    class ModuleContext < CodeContext
+
+      def initialize(outer, name, exp)
+        super(outer, exp)
+        @name = name
+      end
+    end
+  end
+end

data/lib/reek/core/object_refs.rb

@@ -0,0 +1,51 @@
+module Reek
+  module Core
+
+    #
+    # Manages and counts the references out of a method to other objects.
+    #
+    class ObjectRefs  # :nodoc:
+      def initialize
+        @refs = Hash.new(0)
+      end
+
+      def record_reference_to_self
+        record_ref(SELF_REF)
+      end
+
+      def record_ref(exp)
+        type = exp[0]
+        case type
+        when :gvar
+          return
+        when :self
+          record_reference_to_self
+        else
+          @refs[exp] += 1
+        end
+      end
+
+      def refs_to_self
+        @refs[SELF_REF]
+      end
+
+      def max_refs
+        @refs.values.max or 0
+      end
+
+      def max_keys
+        max = max_refs
+        @refs.reject {|key,val| val != max}
+      end
+
+      def self_is_max?
+        max_keys.length == 0 || @refs[SELF_REF] == max_refs
+      end
+
+    private
+
+      SELF_REF = Sexp.from_array([:lit, :self])
+
+    end
+  end
+end

data/lib/reek/core/singleton_method_context.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'method_context')
+
+module Reek
+  module Core
+
+    #
+    # A context wrapper for any singleton method definition found in a syntax tree.
+    #
+    class SingletonMethodContext < MethodContext
+
+      def initialize(outer, exp)
+        super(outer, exp)
+      end
+
+      def envious_receivers
+        []
+      end
+    end
+  end
+end

data/lib/reek/core/smell_configuration.rb

@@ -0,0 +1,62 @@
+module Reek
+  module Core
+
+    #
+    # Represents a single set of configuration options for a smell detector
+    #
+    class SmellConfiguration
+
+      # The name of the config field that specifies whether a smell is
+      # enabled. Set to +true+ or +false+.
+      ENABLED_KEY = 'enabled'
+
+      # The name of the config field that sets scope-specific overrides
+      # for other values in the current smell detector's configuration.
+      OVERRIDES_KEY = 'overrides'
+
+      def initialize(hash)
+        @options = hash
+      end
+
+      def adopt!(options)
+        @options.adopt!(options)
+      end
+
+      #
+      # Is this smell detector active?
+      #--
+      #  SMELL: Getter
+      def enabled?
+        @options[ENABLED_KEY]
+      end
+
+      def overrides_for(context)
+        Overrides.new(@options.fetch(OVERRIDES_KEY, {})).for_context(context)
+      end
+
+      # Retrieves the value, if any, for the given +key+.
+      #
+      # Returns +fall_back+ if this config has no value for the key.
+      #
+      def value(key, context, fall_back)
+        overrides_for(context).each { |conf| return conf[key] if conf.has_key?(key) }
+        return @options.fetch(key, fall_back)
+      end
+    end
+
+    #
+    # A set of context-specific overrides for smell detectors.
+    #
+    class Overrides
+      def initialize(hash)
+        @hash = hash
+      end
+
+      # Find any overrides that match the supplied context
+      def for_context(context)
+        contexts = @hash.keys.select {|ckey| context.matches?([ckey])}
+        contexts.map { |exc| @hash[exc] }
+      end
+    end
+  end
+end

data/lib/reek/core/sniffer.rb

@@ -0,0 +1,105 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'code_parser')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smells')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'source', 'config_file')
+require 'yaml'
+
+#
+# Extensions to +Hash+ needed by Reek.
+#
+class Hash
+  def push_keys(hash)
+    keys.each {|key| hash[key].adopt!(self[key]) }
+  end
+
+  def adopt!(other)
+    other.keys.each do |key|
+      ov = other[key]
+      if Array === ov and has_key?(key)
+        self[key] += ov
+      else
+        self[key] = ov
+      end
+    end
+    self
+  end
+  
+  def adopt(other)
+    self.deep_copy.adopt!(other)
+  end
+  
+  def deep_copy
+    YAML::load(YAML::dump(self))
+  end
+end
+
+module Reek
+  module Core
+
+    #
+    # Configures all available smell detectors and applies them to a source.
+    #
+    class Sniffer
+
+      def self.smell_classes
+        # SMELL: Duplication -- these should be loaded by listing the files
+        [
+          Smells::Attribute,
+          Smells::BooleanParameter,
+          Smells::ClassVariable,
+          Smells::ControlCouple,
+          Smells::DataClump,
+          Smells::Duplication,
+          Smells::FeatureEnvy,
+          Smells::IrresponsibleModule,
+          Smells::LargeClass,
+          Smells::LongMethod,
+          Smells::LongParameterList,
+          Smells::LongYieldList,
+          Smells::NestedIterators,
+          Smells::SimulatedPolymorphism,
+          Smells::UncommunicativeMethodName,
+          Smells::UncommunicativeModuleName,
+          Smells::UncommunicativeParameterName,
+          Smells::UncommunicativeVariableName,
+          Smells::UtilityFunction,
+        ]
+      end
+
+      def initialize(src, config_files = [])
+        @typed_detectors = nil
+        @detectors = Hash.new
+        Sniffer.smell_classes.each do |klass|
+          @detectors[klass] = klass.new(src.desc)
+        end
+        config_files.each{ |cf| Reek::Source::ConfigFile.new(cf).configure(self) }
+        @source = src
+        src.configure(self)
+      end
+
+      def configure(klass, config)
+        @detectors[klass].configure_with(config)
+      end
+
+      def report_on(listener)
+        CodeParser.new(self).process(@source.syntax_tree)
+        @detectors.each_value { |detector| detector.report_on(listener) }
+      end
+
+      def examine(scope, node_type)
+        smell_listeners[node_type].each do |detector|
+          detector.examine(scope)
+        end
+      end
+
+  private
+
+      def smell_listeners()
+        unless @typed_detectors
+          @typed_detectors = Hash.new {|hash,key| hash[key] = [] }
+          @detectors.each_value { |detector| detector.register(@typed_detectors) }
+        end
+        @typed_detectors
+      end
+    end
+  end
+end

data/lib/reek/core/stop_context.rb

@@ -0,0 +1,30 @@
+module Reek
+  module Core
+
+    #
+    # A context wrapper representing the root of an abstract syntax tree.
+    #
+    class StopContext
+
+      def initialize
+        @name = ''
+      end
+
+      def method_missing(method, *args)
+        nil
+      end
+
+      def config
+        {}
+      end
+
+      def count_statements(num)
+        0
+      end
+
+      def full_name
+        ''
+      end
+    end
+  end
+end

data/lib/reek/core/warning_collector.rb

@@ -0,0 +1,27 @@
+require 'set'
+
+module Reek
+  module Core
+
+    #
+    # Collects and sorts smells warnings.
+    #
+    class WarningCollector
+      def initialize
+        @warnings = Set.new
+      end
+
+      def found_smell(warning)
+        @warnings.add(warning)
+      end
+
+      def warnings
+        @warnings.to_a.sort do |first,second|
+          first_sig = [first.context, first.message, first.smell_class]
+          second_sig = [second.context, second.message, second.smell_class]
+          first_sig <=> second_sig
+        end
+      end
+    end
+  end
+end

data/lib/reek/examiner.rb

@@ -0,0 +1,104 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'core', 'sniffer')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'core', 'warning_collector')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'source')
+
+module Reek
+
+  #
+  # Finds the active code smells in Ruby source code.
+  #
+  class Examiner
+
+    #
+    # A simple description of the source being analysed for smells.
+    # If the source is a single File, this will be the file's path.
+    #
+    attr_accessor :description
+
+    #
+    # Creates an Examiner which scans the given +source+ for code smells.
+    #
+    # The smells reported against any source file can be "masked" by
+    # creating *.reek files. See TBS for details.
+    #
+    # @param [Source::SourceCode, Array<String>, #to_reek_source]
+    #   If +source+ is a String it is assumed to be Ruby source code;
+    #   if it is a File, the file is opened and parsed for Ruby source code;
+    #   and if it is an Array, it is assumed to be a list of file paths,
+    #   each of which is opened and parsed for source code.
+    #
+    def initialize(source, config_files = [])
+      sources = case source
+      when Array
+        @description = 'dir'
+        Source::SourceLocator.new(source).all_sources
+      when Source::SourceCode
+        @description = source.desc
+        [source]
+      else
+        src = source.to_reek_source
+        @description = src.desc
+        [src]
+      end
+      collector = Core::WarningCollector.new
+      sources.each { |src| Core::Sniffer.new(src, config_files).report_on(collector) }
+      @smells = collector.warnings
+    end
+
+    #
+    # List the smells found in the source.
+    #
+    # @return [Array<SmellWarning>]
+    #
+    def smells
+      @smells
+    end
+
+    #
+    # True if and only if there are code smells in the source.
+    #
+    def smelly?
+      not @smells.empty?
+    end
+
+    #
+    # Returns an Array of SmellWarning objects, one for each non-masked smell
+    # in the source.
+    #
+    # @deprecated Use #smells instead.
+    #
+    def all_active_smells
+      @smells
+    end
+
+    #
+    # Returns an Array of SmellWarning objects, one for each smell
+    # in the source; includes active smells and masked smells.
+    #
+    # @return [Array<SmellWarning>]
+    #
+    # @deprecated Use #smells instead.
+    #
+    def all_smells
+      @smells
+    end
+
+    #
+    # Returns the number of non-masked smells in the source.
+    #
+    # @deprecated Use #smells instead.
+    #
+    def num_active_smells
+      @smells.length
+    end
+
+    #
+    # Returns the number of masked smells in the source.
+    #
+    # @deprecated Masked smells are no longer reported; this method always returns 0.
+    #
+    def num_masked_smells
+      0
+    end
+  end
+end

data/lib/reek/rake/task.rb

@@ -0,0 +1,142 @@
+#!/usr/bin/env ruby
+
+require 'rake'
+require 'rake/tasklib'
+
+module Reek
+
+  #
+  # Defines a task library for running reek.
+  # (Classes here will be configured via the Rakefile, and therefore will
+  # possess a :reek:attribute or two.)
+  #
+  module Rake
+
+    # A Rake task that runs reek on a set of source files.
+    #
+    # Example:
+    #
+    #   require 'reek/rake/task'
+    #
+    #   Reek::Rake::Task.new do |t|
+    #     t.fail_on_error = false
+    #   end
+    #
+    # This will create a task that can be run with:
+    #
+    #   rake reek
+    #
+    # Examples:
+    #
+    #   rake reek                                # checks lib/**/*.rb
+    #   rake reek REEK_SRC=just_one_file.rb      # checks a single source file
+    #   rake reek REEK_OPTS=-s                   # sorts the report by smell
+    #
+    class Task < ::Rake::TaskLib
+
+      # Name of reek task.
+      # Defaults to :reek.
+      attr_accessor :name
+
+      # Array of directories to be added to $LOAD_PATH before running reek.
+      # Defaults to ['<the absolute path to reek's lib directory>']
+      attr_accessor :libs
+
+      # Glob pattern to match config files.
+      # Setting the REEK_CFG environment variable overrides this.
+      # Defaults to 'config/**/*.reek'.
+      attr_accessor :config_files
+
+      # Glob pattern to match source files.
+      # Setting the REEK_SRC environment variable overrides this.
+      # Defaults to 'lib/**/*.rb'.
+      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_accessor :reek_opts
+
+      # Array of commandline options to pass to ruby. Defaults to [].
+      attr_accessor :ruby_opts
+
+      # Whether or not to fail Rake when an error occurs (typically when smells are found).
+      # Defaults to true.
+      attr_accessor :fail_on_error
+
+      # Use verbose output. If this is set to true, the task will print
+      # the reek command to stdout. Defaults to false.
+      attr_accessor :verbose
+
+      # Defines a new task, using the name +name+.
+      def initialize(name = :reek)
+        @name = name
+        @libs = [File.expand_path(File.dirname(__FILE__) + '/../../../lib')]
+        @config_files = nil
+        @source_files = nil
+        @ruby_opts = []
+        @reek_opts = ''
+        @fail_on_error = true
+        @sort = nil
+
+        yield self if block_given?
+        @config_files ||= 'config/**/*.reek'
+        @source_files ||= 'lib/**/*.rb'
+        define
+      end
+
+  private
+
+      def define # :nodoc:
+        desc 'Check for code smells' unless ::Rake.application.last_comment
+        task(name) { run_task }
+        self
+      end
+
+      def run_task
+        return if source_file_list.empty?
+        cmd = cmd_words.join(' ')
+        puts cmd if @verbose
+        raise('Smells found!') if !system(cmd) and fail_on_error
+      end
+
+      def self.reek_script
+        File.expand_path(File.dirname(__FILE__) + '/../../../bin/reek')
+      end
+
+      def self.ruby_exe
+        File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+      end
+
+      def cmd_words
+        [Task.ruby_exe] +
+            ruby_options +
+            [ %Q|"#{Task.reek_script}"| ] +
+            [sort_option] +
+            config_file_list.collect { |fn| ['-c', %["#{fn}"]] }.flatten +
+            source_file_list.collect { |fn| %["#{fn}"] }
+      end
+
+      def config_file_list
+        files = ENV['REEK_CFG'] || @config_files
+        return [] unless files
+        return FileList[files]
+      end
+
+      def ruby_options
+        lib_path = @libs.join(File::PATH_SEPARATOR)
+        @ruby_opts.clone << "-I\"#{lib_path}\""
+      end
+
+      def sort_option
+        ENV['REEK_OPTS'] || @reek_opts
+      end
+
+      def source_file_list # :nodoc:
+        files = ENV['REEK_SRC'] || @source_files
+        return [] unless files
+        return FileList[files]
+      end
+    end
+  end
+end