reek 1.2.6 → 1.2.8

data/lib/reek/adapters/spec.rb

@@ -1,133 +0,0 @@
-require 'reek/sniffer'
-require 'reek/adapters/core_extras'
-require 'reek/adapters/report'
-
-module Reek
-
-  #
-  # Provides matchers for Rspec, making it easy to check code quality.
-  #
-  # If you require this module somewhere within your spec (or in your spec_helper),
-  # Reek will arrange to update Spec::Runner's config so that it knows about the
-  # matchers defined here.
-  #
-  # === Examples
-  #
-  # Here's a spec that ensures there are no smell warnings in the current project:
-  #
-  #  describe 'source code quality' do
-  #    Dir['lib/**/*.rb'].each do |path|
-  #      it "reports no smells in #{path}" do
-  #        File.new(path).should_not reek
-  #      end
-  #    end
-  #  end
-  #
-  # And here's an even simpler way to do the same:
-  #
-  #  it 'has no code smells' do
-  #    Dir['lib/**/*.rb'].should_not reek
-  #  end
-  #
-  # Here's a simple check of a code fragment:
-  #
-  #  'def equals(other) other.thing == self.thing end'.should_not reek
-  #
-  # And a more complex example, making use of one of the factory methods for
-  # +Source+ so that the code is parsed and analysed only once:
-  # 
-  #   ruby = 'def double_thing() @other.thing.foo + @other.thing.foo end'.sniff
-  #   ruby.should reek_of(:Duplication, /@other.thing[^\.]/)
-  #   ruby.should reek_of(:Duplication, /@other.thing.foo/)
-  #   ruby.should_not reek_of(:FeatureEnvy)
-  #
-  module Spec
-    module ReekMatcher
-      def create_reporter(sniffers)
-        QuietReport.new(sniffers, false)
-      end
-      def report
-        create_reporter(@sniffer.sniffers).report
-      end
-
-      module_function :create_reporter
-    end
-
-    class ShouldReek        # :nodoc:
-      include ReekMatcher
-
-      def matches?(actual)
-        @sniffer = actual.sniff
-        @sniffer.smelly?
-      end
-      def failure_message_for_should
-        "Expected #{@sniffer.desc} to reek, but it didn't"
-      end
-      def failure_message_for_should_not
-        "Expected no smells, but got:\n#{report}"
-      end
-    end
-
-    class ShouldReekOf        # :nodoc:
-      include ReekMatcher
-
-      def initialize(klass, patterns)
-        @klass = klass
-        @patterns = patterns
-      end
-      def matches?(actual)
-        @sniffer = actual.sniff
-        @sniffer.has_smell?(@klass, @patterns)
-      end
-      def failure_message_for_should
-        "Expected #{@sniffer.desc} to reek of #{@klass}, but it didn't"
-      end
-      def failure_message_for_should_not
-        "Expected #{@sniffer.desc} not to reek of #{@klass}, but got:\n#{report}"
-      end
-    end
-
-    class ShouldReekOnlyOf < ShouldReekOf        # :nodoc:
-      def matches?(actual)
-        @sniffer = actual.sniff
-        @sniffer.num_smells == 1 and @sniffer.has_smell?(@klass, @patterns)
-      end
-      def failure_message_for_should
-        "Expected #{@sniffer.desc} to reek only of #{@klass}, but got:\n#{report}"
-      end
-      def failure_message_for_should_not
-        "Expected #{@sniffer.desc} not to reek only of #{@klass}, but it did"
-      end
-    end
-
-    #
-    # Returns +true+ if and only if the target source code contains smells.
-    #
-    def reek
-      ShouldReek.new
-    end
-
-    #
-    # Checks the target source code for instances of +smell_class+,
-    # and returns +true+ only if one of them has a report string matching
-    # all of the +patterns+.
-    #
-    def reek_of(smell_class, *patterns)
-      ShouldReekOf.new(smell_class, patterns)
-    end
-
-    #
-    # As for reek_of, but the matched smell warning must be the only warning of
-    # any kind in the target source code's Reek report.
-    #
-    def reek_only_of(smell_class, *patterns)
-      ShouldReekOnlyOf.new(smell_class, patterns)
-    end
-  end
-end
-
-if Object.const_defined?(:Spec)
-  Spec::Runner.configure do |config|
-    config.include(Reek::Spec)
-  end
-end

data/lib/reek/block_context.rb

@@ -1,62 +0,0 @@
-require 'set'
-require 'reek/code_context'
-
-module Reek
-
-  module ParameterSet
-    def names
-      return @names if @names
-      return (@names = []) if empty?
-      arg = slice(1)
-      case slice(0)
-      when :masgn
-        @names = arg[1..-1].map {|lasgn| Name.new(lasgn[1]) }
-      when :lasgn, :iasgn
-        @names = [Name.new(arg)]
-      end
-    end
-
-    def include?(name)
-      names.include?(name)
-    end
-  end
-
-  class VariableContainer < CodeContext
-
-    def initialize(outer, exp)
-      super
-      @local_variables = Set.new
-    end
-
-    def record_local_variable(sym)
-      @local_variables << Name.new(sym)
-    end
-  end
-
-  class BlockContext < VariableContainer
-
-    def initialize(outer, exp)
-      super
-      @name = Name.new('block')
-      @scope_connector = '/'
-      @parameters = exp[2] || []
-      @parameters.extend(ParameterSet)
-    end
-
-    def inside_a_block?
-      true
-    end
-
-    def has_parameter(name)
-      @parameters.include?(name) or @outer.has_parameter(name)
-    end
-
-    def nested_block?
-      @outer.inside_a_block?
-    end
-    
-    def variable_names
-      @parameters.names + @local_variables.to_a
-    end
-  end
-end

data/lib/reek/class_context.rb

@@ -1,41 +0,0 @@
-require 'set'
-require 'reek/module_context'
-
-class Class
-  def is_overriding_method?(name)
-    sym = name.to_sym
-    mine = instance_methods(false)
-    dads = superclass.instance_methods(true)
-    (mine.include?(sym) and dads.include?(sym)) or (mine.include?(name) and dads.include?(name))
-  end
-end
-
-module Reek
-  class ClassContext < ModuleContext
-
-    attr_reader :parsed_methods
-
-    def initialize(outer, name, exp)
-      super
-      @superclass = exp[2]
-      @instance_variables = Set.new
-    end
-
-    def is_overriding_method?(name)
-      return false unless myself
-      @myself.is_overriding_method?(name.to_s)
-    end
-    
-    def is_struct?
-      @superclass == [:const, :Struct]
-    end
-
-    def record_instance_variable(sym)
-      @instance_variables << Name.new(sym)
-    end
-
-    def variable_names
-      @instance_variables
-    end
-  end
-end

data/lib/reek/code_context.rb

@@ -1,68 +0,0 @@
-class Module
-
-  def const_or_nil(sym)
-    const_defined?(sym) ? const_get(sym) : nil
-  end
-end
-
-module Reek
-  
-  #
-  # Superclass for all types of source code context. Each instance represents
-  # a code element of some kind, and each provides behaviour relevant to that
-  # code element. CodeContexts form a tree in the same way the code does,
-  # with each context holding a reference to a unique outer context.
-  #
-  class CodeContext
-
-    attr_reader :name, :exp
-
-    def initialize(outer, exp)
-      @outer = outer
-      @exp = exp
-      @scope_connector = ''
-      @myself = nil
-    end
-
-    def local_nodes(type, &blk)
-      each_node(type, [:class, :module], &blk)
-    end
-
-    def each_node(type, ignoring, &blk)
-      if block_given?
-        @exp.look_for(type, ignoring, &blk)
-      else
-        result = []
-        @exp.look_for(type, ignoring) {|exp| result << exp}
-        result
-      end
-    end
-
-    # SMELL: Temporary Field -- @name isn't always initialized
-    def matches?(strings)
-      me = @name.to_s
-      strings.any? do |str|
-        re = /#{str}/
-        re === me or re === self.full_name
-      end
-    end
-    
-    #
-    # Bounces messages up the context tree to the first enclosing context
-    # that knows how to deal with the request.
-    #
-    def method_missing(method, *args)
-      @outer.send(method, *args)
-    end
-
-    def num_methods
-      0
-    end
-
-    def full_name
-      outer = @outer ? @outer.full_name : ''
-      prefix = outer == '' ? '' : "#{outer}#{@scope_connector}"
-      "#{prefix}#{@name}"
-    end
-  end
-end

data/lib/reek/code_parser.rb

@@ -1,203 +0,0 @@
-require 'sexp'
-require 'reek/block_context'
-require 'reek/class_context'
-require 'reek/module_context'
-require 'reek/stop_context'
-require 'reek/if_context'
-require 'reek/method_context'
-require 'reek/singleton_method_context'
-require 'reek/yield_call_context'
-
-module Reek
-  #
-  # Traverses a Sexp abstract syntax tree and fires events whenever
-  # it encounters specific node types.
-  #
-  class CodeParser
-    def initialize(sniffer, ctx = StopContext.new)
-      @sniffer = sniffer
-      @element = ctx
-    end
-
-    def process(exp)
-      meth = "process_#{exp[0]}"
-      meth = :process_default unless self.respond_to?(meth)
-      self.send(meth, exp)
-      @element
-    end
-
-    def process_default(exp)
-      exp[0..-1].each { |sub| process(sub) if Array === sub }
-    end
-
-    def do_module_or_class(exp, context_class)
-      scope = context_class.create(@element, exp)
-      push(scope) do
-        process_default(exp) unless @element.is_struct?
-        check_smells(exp[0])
-      end
-      scope
-    end
-
-    def process_module(exp)
-      do_module_or_class(exp, ModuleContext)
-    end
-
-    def process_class(exp)
-      do_module_or_class(exp, ClassContext)
-    end
-
-    def process_defn(exp)
-      handle_context(MethodContext, exp[0], exp)
-    end
-
-    def process_defs(exp)
-      handle_context(SingletonMethodContext, exp[0], exp)
-    end
-
-    def process_args(exp) end
-
-    def process_attrset(exp)
-      @element.record_depends_on_self if /^@/ === exp[1].to_s
-    end
-
-    def process_zsuper(exp)
-      @element.record_use_of_self
-    end
-
-    def process_lit(exp)
-      val = exp[1]
-      @element.record_depends_on_self if val == :self
-    end
-
-    def process_iter(exp)
-      process(exp[1])
-      scope = BlockContext.new(@element, exp)
-      push(scope) do
-        process_default(exp[2..-1])
-        check_smells(exp[0])
-      end
-      scope
-    end
-
-    def process_block(exp)
-      @element.count_statements(CodeParser.count_statements(exp))
-      process_default(exp)
-    end
-
-    def process_yield(exp)
-      handle_context(YieldCallContext, exp[0], exp)
-    end
-
-    def process_call(exp)
-      @element.record_call_to(exp)
-      process_default(exp)
-    end
-
-    def process_cfunc(exp)
-      @element.record_depends_on_self
-    end
-
-    def process_attrasgn(exp)
-      process_call(exp)
-    end
-
-    def process_op_asgn1(exp)
-      process_call(exp)
-    end
-
-    def process_if(exp)
-      count_clause(exp[2])
-      count_clause(exp[3])
-      handle_context(IfContext, exp[0], exp)
-      @element.count_statements(-1)
-    end
-
-    def process_while(exp)
-      process_until(exp)
-    end
-
-    def process_until(exp)
-      count_clause(exp[2])
-      process_case(exp)
-    end
-
-    def process_for(exp)
-      count_clause(exp[3])
-      process_case(exp)
-    end
-
-    def process_rescue(exp)
-      count_clause(exp[1])
-      process_case(exp)
-    end
-
-    def process_resbody(exp)
-      process_when(exp)
-    end
-
-    def process_case(exp)
-      process_default(exp)
-      @element.count_statements(-1)
-    end
-
-    def process_when(exp)
-      count_clause(exp[2])
-      process_default(exp)
-    end
-
-    def process_ivar(exp)
-      process_iasgn(exp)
-    end
-
-    def process_lasgn(exp)
-      @element.record_local_variable(exp[1])
-      process_default(exp)
-    end
-
-    def process_iasgn(exp)
-      @element.record_instance_variable(exp[1])
-      @element.record_depends_on_self
-      process_default(exp)
-    end
-
-    def process_self(exp)
-      @element.record_use_of_self
-    end
-
-    def count_clause(sexp)
-      if sexp and !sexp.has_type?(:block)
-        @element.count_statements(1)
-      end
-    end
-
-    def self.count_statements(exp)
-      stmts = exp[1..-1]
-      ignore = 0
-      ignore += 1 if stmts[1] == s(:nil)
-      stmts.length - ignore
-    end
-
-  private
-
-    def handle_context(klass, type, exp)
-      scope = klass.new(@element, exp)
-      push(scope) do
-        process_default(exp)
-        check_smells(type)
-      end
-      scope
-    end
-
-    def check_smells(type)
-      @sniffer.examine(@element, type)
-    end
-
-    def push(context)
-      orig = @element
-      @element = context
-      yield
-      @element = orig
-    end
-  end
-end

data/lib/reek/configuration.rb

@@ -1,57 +0,0 @@
-module Reek
-
-  #
-  # 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
-
-    # 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
-
-  class Overrides
-    def initialize(hash)
-      @hash = hash
-    end
-
-    def for_context(context)
-      contexts = @hash.keys.select {|ckey| context.matches?([ckey])}
-      contexts.map { |exc| @hash[exc] }
-    end
-  end
-end

data/lib/reek/detector_stack.rb

@@ -1,37 +0,0 @@
-
-module Reek
-  class DetectorStack
-
-    def initialize(default_detector)
-      @detectors = [default_detector]
-    end
-
-    def push(config)
-      clone = @detectors[-1].supersede_with(config)
-      @detectors << clone
-    end
-
-    def listen_to(hooks)
-      @detectors.each { |det| det.listen_to(hooks) }
-    end
-
-    def report_on(report)
-      @detectors.each { |det| det.report_on(report) }
-    end
-
-    def num_smells
-      @detectors.inject(0) { |total, detector| total += detector.num_smells }
-    end
-
-    def has_smell?(patterns)
-      @detectors.each { |det| return true if det.has_smell?(patterns) }
-      false
-    end
-
-    def smelly?
-      # SMELL: Duplication: look at all those loops!
-      @detectors.each { |det| return true if det.smelly? }
-      false
-    end
-  end
-end

data/lib/reek/help_command.rb

@@ -1,14 +0,0 @@
-
-module Reek
-
-  class HelpCommand
-    def initialize(parser)
-      @parser = parser
-    end
-    def execute(view)
-      view.output(@parser.to_s)
-      view.report_success
-    end
-  end
-
-end

data/lib/reek/if_context.rb

@@ -1,18 +0,0 @@
-require 'reek/code_context'
-
-module Reek
-  class IfContext < CodeContext
-    attr_reader :if_expr
-    
-    def initialize(outer, exp)
-      super
-      @name = ''
-      @scope_connector = ''
-      @if_expr = exp[1]
-    end
-    
-    def tests_a_parameter?
-      @if_expr[0] == :lvar and has_parameter(@if_expr[1])
-    end
-  end
-end

data/lib/reek/masking_collection.rb

@@ -1,33 +0,0 @@
-require 'set'
-
-#
-# A set of items that can be "masked" or "visible". If an item is added
-# more than once, only the "visible" copy is retained.
-#
-class MaskingCollection
-  def initialize
-    @visible_items = SortedSet.new
-    @masked_items = SortedSet.new
-  end
-  def found_smell(item)
-    @visible_items.add(item)
-    @masked_items.delete(item) if @masked_items.include?(item)
-  end
-  def found_masked_smell(item)
-    @masked_items.add(item) unless @visible_items.include?(item)
-  end
-  def num_visible_items
-    @visible_items.length
-  end
-  def num_masked_items
-    @masked_items.length
-  end
-  def each_item(&blk)
-    all = SortedSet.new(@visible_items)
-    all.merge(@masked_items)
-    all.each(&blk)
-  end
-  def each_visible_item(&blk)
-    @visible_items.each(&blk)
-  end
-end