reek 1.2.6 → 1.2.7

data/lib/reek/{object_refs.rb → core/object_refs.rb}

@@ -1,10 +1,14 @@
 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
@@ -29,12 +33,9 @@ module Reek
       @refs.values.max or 0
     end
 
-    # TODO
-    # Should be moved to Hash
-    #
     def max_keys
       max = max_refs
-      @refs.reject {|key,val| val != max}.keys
+      @refs.reject {|key,val| val != max}
     end
 
     def self_is_max?
@@ -42,8 +43,9 @@ module Reek
     end
 
   private
-    
+
     SELF_REF = Sexp.from_array([:lit, :self])
 
   end
+  end
 end

data/lib/reek/{singleton_method_context.rb → core/singleton_method_context.rb}

@@ -1,14 +1,18 @@
-require 'reek/name'
-require 'reek/method_context'
-require 'reek/sexp_formatter'
+require File.join(File.dirname(File.expand_path(__FILE__)), 'method_context')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'source')
 
 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)
-      @name = Name.new(exp[2])
-      @receiver = SexpFormatter.format(exp[1])
+      @name = exp[2].to_s
+      @receiver = Source::SexpFormatter.format(exp[1])
       @scope_connector = ""
       record_depends_on_self
     end
@@ -23,4 +27,5 @@ module Reek
       "#{prefix}#{@receiver}.#{@name}"
     end
   end
+  end
 end

data/lib/reek/core/smell_configuration.rb

@@ -0,0 +1,66 @@
+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
+
+      def deep_copy
+        @options.deep_copy     # SMELL: Open Secret -- returns a Hash
+      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,110 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'detector_stack')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'code_parser')
+require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'smells')
+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)
+        @already_checked_for_smells = false
+        @typed_detectors = nil
+        @detectors = Hash.new
+        Sniffer.smell_classes.each do |klass|
+          @detectors[klass] = DetectorStack.new(klass.new(src.desc))
+        end
+        @source = src
+        src.configure(self)
+      end
+
+      def check_for_smells
+        return if @already_checked_for_smells
+        CodeParser.new(self).process(@source.syntax_tree)
+        @already_checked_for_smells = true
+      end
+
+      def configure(klass, config)
+        @detectors[klass].push(config)
+      end
+
+      def report_on(report)
+        check_for_smells
+        @detectors.each_value { |stack| stack.report_on(report) }
+      end
+
+      def examine(scope, type)
+        listeners = smell_listeners[type]
+        listeners.each {|smell| smell.examine(scope) } if listeners
+      end
+
+  private
+
+      def smell_listeners()
+        unless @typed_detectors
+          @typed_detectors = Hash.new {|hash,key| hash[key] = [] }
+          @detectors.each_value { |stack| stack.listen_to(@typed_detectors) }
+        end
+        @typed_detectors
+      end
+    end
+  end
+end

data/lib/reek/core/stop_context.rb

@@ -0,0 +1,26 @@
+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 count_statements(num)
+        0
+      end
+
+      def full_name
+        ''
+      end
+    end
+  end
+end

data/lib/reek/examiner.rb

@@ -0,0 +1,88 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'core', 'masking_collection')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'core', 'sniffer')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'source')
+
+module Reek
+
+  #
+  # Finds the 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)
+      sniffers = case source
+      when Array
+        @description = 'dir'
+        Source::SourceLocator.new(source).all_sources.map {|src| Core::Sniffer.new(src)}
+      when Source::SourceCode
+        @description = source.desc
+        [Core::Sniffer.new(source)]
+      else
+        src = source.to_reek_source
+        @description = src.desc
+        [Core::Sniffer.new(src)]
+      end
+      @warnings = Core::MaskingCollection.new
+      sniffers.each {|sniffer| sniffer.report_on(@warnings)}
+    end
+
+    #
+    # Returns an Array of SmellWarning objects, one for each non-masked smell
+    # in the source.
+    #
+    # @return [Array<SmellWarning>]
+    #
+    def all_active_smells
+      @warnings.all_active_items.to_a
+    end
+
+    #
+    # Returns an Array of SmellWarning objects, one for each smell
+    # in the source; includes active smells and masked smells.
+    #
+    # @return [Array<SmellWarning>]
+    #
+    def all_smells
+      @warnings.all_items
+    end
+
+    #
+    # Returns the number of non-masked smells in the source.
+    #
+    def num_active_smells
+      @warnings.num_visible_items
+    end
+
+    #
+    # Returns the number of masked smells in the source.
+    #
+    def num_masked_smells
+      @warnings.num_masked_items
+    end
+
+    #
+    # True if and only if there are non-masked code smells in the given source.
+    #
+    def smelly?
+      not all_active_smells.empty?
+    end
+  end
+end

data/lib/reek/rake/task.rb

@@ -0,0 +1,124 @@
+#!/usr/bin/env ruby
+
+require 'rake'
+require 'rake/tasklib'
+
+module Reek
+
+  #
+  # Defines a task library for running reek.
+  #
+  module Rake
+
+    # A Rake task that runs reek on a set of source files.
+    #
+    # Example:
+    #
+    #   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 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')]
+        @source_files = nil
+        @ruby_opts = []
+        @reek_opts = ''
+        @fail_on_error = true
+        @sort = nil
+
+        yield self if block_given?
+        @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] +
+            source_file_list.collect { |fn| %["#{fn}"] }
+      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