reek 2.1.0 → 2.2.0

data/.ruby-gemset

@@ -1 +0,0 @@
-reek

data/lib/reek/examiner.rb

@@ -1,79 +0,0 @@
-require_relative 'source/source_repository'
-require_relative 'core/warning_collector'
-require_relative 'core/smell_repository'
-require_relative 'core/tree_walker'
-
-module Reek
-  #
-  # Applies all available smell detectors to a source.
-  #
-  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.
-    #
-    # @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, smell_types_to_filter_by = [])
-      @sources      = Source::SourceRepository.parse(source)
-      @description  = @sources.description
-      @collector    = Core::WarningCollector.new
-      @smell_types  = eligible_smell_types(smell_types_to_filter_by)
-
-      run
-    end
-
-    #
-    # List the smells found in the source.
-    #
-    # @return [Array<SmellWarning>]
-    #
-    def smells
-      @smells ||= @collector.warnings
-    end
-
-    #
-    # Returns the number of smells found in the source
-    #
-    def smells_count
-      smells.length
-    end
-
-    #
-    # True if and only if there are code smells in the source.
-    #
-    def smelly?
-      !smells.empty?
-    end
-
-    private
-
-    def run
-      @sources.each do |source|
-        smell_repository = Core::SmellRepository.new(source.desc, @smell_types)
-        syntax_tree = source.syntax_tree
-        Core::TreeWalker.new(smell_repository).process(syntax_tree) if syntax_tree
-        smell_repository.report_on(@collector)
-      end
-    end
-
-    def eligible_smell_types(smell_types_to_filter_by = [])
-      if smell_types_to_filter_by.any?
-        Core::SmellRepository.smell_types.select do |klass|
-          smell_types_to_filter_by.include? klass.smell_type
-        end
-      else
-        Core::SmellRepository.smell_types
-      end
-    end
-  end
-end

data/lib/reek/smell_warning.rb

@@ -1,87 +0,0 @@
-require 'forwardable'
-
-module Reek
-  #
-  # Reports a warning that a smell has been found.
-  #
-  class SmellWarning
-    include Comparable
-    extend Forwardable
-    attr_accessor :smell_detector, :context, :lines, :message, :parameters
-    def_delegators :smell_detector, :smell_category, :smell_type, :source
-
-    def initialize(smell_detector, options = {})
-      self.smell_detector = smell_detector
-      self.context        = options.fetch(:context, '').to_s
-      self.lines          = options.fetch(:lines)
-      self.message        = options.fetch(:message)
-      self.parameters     = options.fetch(:parameters, {})
-    end
-
-    def smell_classes
-      [smell_detector.smell_category, smell_detector.smell_type]
-    end
-
-    def hash
-      sort_key.hash
-    end
-
-    def <=>(other)
-      sort_key <=> other.sort_key
-    end
-
-    def eql?(other)
-      (self <=> other) == 0
-    end
-
-    def matches?(klass, other_parameters = {})
-      smell_classes.include?(klass.to_s) && common_parameters_equal?(other_parameters)
-    end
-
-    def report_on(listener)
-      listener.found_smell(self)
-    end
-
-    def yaml_hash(warning_formatter = nil)
-      result = {
-        'smell_category' => smell_detector.smell_category,
-        'smell_type'     => smell_detector.smell_type,
-        'source'         => smell_detector.source,
-        'context'        => context,
-        'lines'          => lines,
-        'message'        => message
-      }
-      if warning_formatter.respond_to?(:explanatory_link)
-        result.merge!('wiki_link' => warning_formatter.explanatory_link(smell_detector))
-      end
-      parameters.each do |key, value|
-        result[key.to_s] = value
-      end
-      result
-    end
-
-    protected
-
-    def sort_key
-      [context, message, smell_category]
-    end
-
-    def common_parameters_equal?(other_parameters)
-      other_parameters.keys.each do |key|
-        unless parameters.key?(key)
-          raise ArgumentError, "The parameter #{key} you want to check for doesn't exist"
-        end
-      end
-
-      # Why not check for strict parameter equality instead of just the common ones?
-      #
-      # In `self`, `parameters` might look like this:  {:name=>"@other.thing", :count=>2}
-      # Coming from specs, 'other_parameters' might look like this, e.g.:
-      # {:name=>"@other.thing"}
-      # So in this spec we are just specifying the "name" parameter but not the "count".
-      # In order to allow for this kind of leniency we just test for common parameter equality,
-      # not for a strict one.
-      parameters.values_at(*other_parameters.keys) == other_parameters.values
-    end
-  end
-end

data/lib/reek/source/reference_collector.rb

@@ -1,27 +0,0 @@
-
-module Reek
-  module Source
-    #
-    # Locates references to the current object within a portion
-    # of an abstract syntax tree.
-    #
-    class ReferenceCollector
-      STOP_NODES = [:class, :module, :def, :defs]
-
-      def initialize(ast)
-        @ast = ast
-      end
-
-      def num_refs_to_self
-        result = 0
-        [:self, :zsuper, :ivar, :ivasgn].each do |node_type|
-          @ast.look_for(node_type, STOP_NODES) { result += 1 }
-        end
-        @ast.look_for(:send, STOP_NODES) do |call|
-          result += 1 unless call.receiver
-        end
-        result
-      end
-    end
-  end
-end

data/lib/reek/source/sexp_formatter.rb

@@ -1,22 +0,0 @@
-old_verbose, $VERBOSE = $VERBOSE, nil
-require 'unparser'
-$VERBOSE = old_verbose
-
-module Reek
-  module Source
-    #
-    # Formats snippets of syntax tree back into Ruby source code.
-    #
-    class SexpFormatter
-      def self.format(sexp)
-        return sexp.to_s unless sexp.is_a? AST::Node
-        lines = Unparser.unparse(sexp).split "\n"
-        if lines.length > 1
-          "#{lines.first} ... #{lines.last}"
-        else
-          lines.first
-        end
-      end
-    end
-  end
-end

data/lib/reek/source/sexp_node.rb

@@ -1,79 +0,0 @@
-module Reek
-  module Source
-    #
-    # Extensions to +Sexp+ to allow +TreeWalker+ to navigate the abstract
-    # syntax tree more easily.
-    #
-    module SexpNode
-      def self.format(expr)
-        case expr
-        when AST::Node then expr.format_ruby
-        else expr.to_s
-        end
-      end
-
-      def hash
-        inspect.hash
-      end
-
-      def each_node(type, ignoring = [], &blk)
-        if block_given?
-          look_for(type, ignoring, &blk)
-        else
-          result = []
-          look_for(type, ignoring) { |exp| result << exp }
-          result
-        end
-      end
-
-      def find_nodes(types, ignoring = [])
-        result = []
-        look_for_alt(types, ignoring) { |exp| result << exp }
-        result
-      end
-
-      def each_sexp
-        children.each { |elem| yield elem if elem.is_a? AST::Node }
-      end
-
-      #
-      # Carries out a depth-first traversal of this syntax tree, yielding
-      # every Sexp of type +target_type+. The traversal ignores any node
-      # whose type is listed in the Array +ignoring+.
-      #
-      def look_for(target_type, ignoring = [], &blk)
-        each_sexp do |elem|
-          elem.look_for(target_type, ignoring, &blk) unless ignoring.include?(elem.type)
-        end
-        blk.call(self) if type == target_type
-      end
-
-      #
-      # Carries out a depth-first traversal of this syntax tree, yielding
-      # every Sexp of type +target_type+. The traversal ignores any node
-      # whose type is listed in the Array +ignoring+, includeing the top node.
-      #
-      # Also, doesn't nest
-      #
-      def look_for_alt(target_types, ignoring = [], &blk)
-        return if ignoring.include?(type)
-        if target_types.include? type
-          blk.call(self)
-        else
-          each_sexp do |elem|
-            elem.look_for_alt(target_types, ignoring, &blk)
-          end
-        end
-      end
-
-      def contains_nested_node?(target_type)
-        look_for(target_type) { |_elem| return true }
-        false
-      end
-
-      def format_ruby
-        SexpFormatter.format(self)
-      end
-    end
-  end
-end

data/spec/reek/source/tree_dresser_spec.rb

@@ -1,16 +0,0 @@
-require_relative '../../spec_helper'
-require_relative '../../../lib/reek/source/tree_dresser'
-
-describe Reek::Source::TreeDresser do
-  let(:ifnode) { Parser::AST::Node.new(:if) }
-  let(:sendnode) { Parser::AST::Node.new(:send) }
-  let(:dresser) { Reek::Source::TreeDresser.new }
-
-  it 'dresses :if sexp with IfNode' do
-    expect(dresser.dress(ifnode, {})).to be_a Reek::Source::SexpExtensions::IfNode
-  end
-
-  it 'dresses :send sexp with SendNode' do
-    expect(dresser.dress(sendnode, {})).to be_a Reek::Source::SexpExtensions::SendNode
-  end
-end