reek 1.2.6 → 1.2.7

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