reek 1.2.6 → 1.2.8

data/lib/reek/method_context.rb

@@ -1,138 +0,0 @@
-require 'reek/name'
-require 'reek/block_context'
-require 'reek/object_refs'
-
-class Array
-  def power_set
-    self.inject([[]]) { |cum, element| cum.cross(element) }
-  end
-
-  def bounded_power_set(lower_bound)
-    power_set.select {|ps| ps.length > lower_bound}
-  end
-
-  def cross(element)
-    result = []
-    self.each do |set|
-      result << set
-      result << (set + [element])
-    end
-    result
-  end
-
-  def intersection
-    self.inject { |res, elem| elem & res }
-  end
-end
-
-module Reek
-
-  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]] = exp[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| Name.new(arg)}
-    end
-
-    def length
-      names.length
-    end
-
-    def include?(name)
-      names.include?(name)
-    end
-
-    def to_s
-      "[#{names.map{|nm| nm.to_s}.join(', ')}]"
-    end
-  end
-
-  class MethodContext < VariableContainer
-    attr_reader :parameters
-    attr_reader :calls
-    attr_reader :refs
-    attr_reader :num_statements
-
-    def initialize(outer, exp)
-      # SMELL: Unused Parameter
-      super(outer, exp)
-      @parameters = exp[exp[0] == :defn ? 2 : 3]  # SMELL: SimulatedPolymorphism
-      @parameters ||= []
-      @parameters.extend(MethodParameters)
-      @name = Name.new(exp[1])
-      @scope_connector = '#'
-      @num_statements = 0
-      @calls = Hash.new(0)
-      @depends_on_self = false
-      @refs = ObjectRefs.new
-      @outer.record_method(self)    # SMELL: these could be found by tree walking
-    end
-
-    def count_statements(num)
-      @num_statements += num
-    end
-
-    def depends_on_instance?
-      @depends_on_self || is_overriding_method?(@name)
-    end
-
-    def has_parameter(sym)
-      @parameters.include?(sym.to_s)
-    end
-
-    def record_call_to(exp)
-      @calls[exp] += 1
-      record_receiver(exp)
-    end
-
-    def record_receiver(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
-      record_depends_on_self
-      @refs.record_reference_to_self
-    end
-
-    def record_instance_variable(sym)
-      record_use_of_self
-      @outer.record_instance_variable(sym)
-    end
-    
-    def record_depends_on_self
-      @depends_on_self = true
-    end
-
-    def envious_receivers
-      return [] if @refs.self_is_max?
-      @refs.max_keys
-    end
-
-    def variable_names
-      @parameters.names + @local_variables.to_a
-    end
-  end
-end

data/lib/reek/module_context.rb

@@ -1,49 +0,0 @@
-require 'reek/code_context'
-require 'reek/code_parser'
-require 'reek/sniffer'
-
-module Reek
-  class ModuleContext < CodeContext
-
-    class << self
-      def create(outer, exp)
-        res = Name.resolve(exp[1], outer)
-        new(res[0], res[1], exp)
-      end
-
-      def from_s(src)
-        source = src.to_reek_source
-        sniffer = Sniffer.new(source)
-        CodeParser.new(sniffer).do_module_or_class(source.syntax_tree, self)
-      end
-    end
-
-    def initialize(outer, name, exp)
-      super(outer, exp)
-      @name = name
-      @scope_connector = '::'
-      @parsed_methods = []
-    end
-
-    def myself
-      @myself ||= @outer.find_module(@name)
-    end
-
-    def find_module(modname)
-      return nil unless myself
-      @myself.const_or_nil(modname.to_s)
-    end
-
-    def parameterized_methods(min_clump_size)
-      @parsed_methods.select {|meth| meth.parameters.length >= min_clump_size }
-    end
-
-    def record_method(meth)
-      @parsed_methods << meth
-    end
-
-    def variable_names
-      []
-    end
-  end
-end

data/lib/reek/name.rb

@@ -1,57 +0,0 @@
-require 'ruby_parser'
-
-module Reek
-  class Name
-    include Comparable
-
-    def self.resolve(exp, context)
-      unless Array === exp
-        return resolve_string(exp.to_s, context)
-      end
-      name = exp[1]
-      case exp[0]
-      when :colon2
-        return [resolve(name, context)[0], new(exp[2])]
-      when :const
-        return [ModuleContext.create(context, exp), new(name)]
-      when :colon3
-        return [StopContext.new, new(name)]
-      else
-        return [context, new(name)]
-      end
-    end
-
-    def self.resolve_string(str, context)
-      return [context, new(str)] unless str =~ /::/
-      resolve(RubyParser.new.parse(str), context)
-    end
-
-    def initialize(sym)
-      @name = sym.to_s
-    end
-
-    def hash  # :nodoc:
-      @name.hash
-    end
-
-    def eql?(other)
-      self == other
-    end
-
-    def <=>(other)  # :nodoc:
-      @name <=> other.to_s
-    end
-
-    def effective_name
-      @name.gsub(/^@*/, '')
-    end
-
-    def inspect
-      @name.inspect
-    end
-
-    def to_s
-      @name
-    end
-  end
-end

data/lib/reek/object_refs.rb

@@ -1,49 +0,0 @@
-module Reek
-
-  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
-
-    # TODO
-    # Should be moved to Hash
-    #
-    def max_keys
-      max = max_refs
-      @refs.reject {|key,val| val != max}.keys
-    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

data/lib/reek/reek_command.rb

@@ -1,28 +0,0 @@
-require 'reek/sniffer'
-
-module Reek
-
-  class ReekCommand
-
-    def initialize(sources, report_class, show_all)
-      @sniffer = sources.length > 0 ? sources.sniff : sniff_stdin
-      @report_class = report_class
-      @show_all = show_all
-    end
-
-    def sniff_stdin
-      Reek::Sniffer.new($stdin.to_reek_source('$stdin'))
-    end
-
-    def execute(view)
-      rpt = @report_class.new(@sniffer.sniffers, @show_all)
-      view.output(rpt.report)
-      if @sniffer.smelly?
-        view.report_smells
-      else
-        view.report_success
-      end
-    end
-  end
-
-end

data/lib/reek/sexp_formatter.rb

@@ -1,10 +0,0 @@
-require 'ruby2ruby'
-
-module Reek
-  class SexpFormatter
-    def self.format(sexp)
-      sexp = YAML::load(YAML::dump(sexp))
-      Ruby2Ruby.new.process(sexp)
-    end
-  end
-end

data/lib/reek/singleton_method_context.rb

@@ -1,26 +0,0 @@
-require 'reek/name'
-require 'reek/method_context'
-require 'reek/sexp_formatter'
-
-module Reek
-  class SingletonMethodContext < MethodContext
-
-    def initialize(outer, exp)
-      super(outer, exp)
-      @name = Name.new(exp[2])
-      @receiver = SexpFormatter.format(exp[1])
-      @scope_connector = ""
-      record_depends_on_self
-    end
-
-    def envious_receivers
-      []
-    end
-
-    def full_name
-      outer = @outer ? @outer.full_name : ''
-      prefix = outer == '' ? '' : "#{outer}#"
-      "#{prefix}#{@receiver}.#{@name}"
-    end
-  end
-end

data/lib/reek/smells/uncommunicative_name.rb

@@ -1,84 +0,0 @@
-require 'reek/smells/smell_detector'
-require 'reek/smell_warning'
-
-module Reek
-  module Smells
-
-    #
-    # An Uncommunicative Name is a name that doesn't communicate its intent
-    # well enough.
-    # 
-    # Poor names make it hard for the reader to build a mental picture
-    # of what's going on in the code. They can also be mis-interpreted;
-    # and they hurt the flow of reading, because the reader must slow
-    # down to interpret the names.
-    #
-    # Currently +UncommunicativeName+ checks for
-    # * 1-character names
-    # * names ending with a number
-    #
-    class UncommunicativeName < SmellDetector
-
-      # The name of the config field that lists the regexps of
-      # smelly names to be reported.
-      REJECT_KEY = 'reject'
-
-      DEFAULT_REJECT_SET = [/^.$/, /[0-9]$/]
-      
-      # The name of the config field that lists the specific names that are
-      # to be treated as exceptions; these names will not be reported as
-      # uncommunicative.
-      ACCEPT_KEY = 'accept'
-
-      DEFAULT_ACCEPT_SET = ['Inline::C']
-
-      def self.default_config
-        super.adopt(
-          REJECT_KEY => DEFAULT_REJECT_SET,
-          ACCEPT_KEY => DEFAULT_ACCEPT_SET
-        )
-      end
-
-      def self.contexts      # :nodoc:
-        [:module, :class, :defn, :defs, :iter]
-      end
-
-      def initialize(config = UncommunicativeName.default_config)
-        super(config)
-      end
-
-      #
-      # Checks the given +context+ for uncommunicative names.
-      # Remembers any smells found.
-      #
-      def examine_context(context)
-        consider_name(context)
-        consider_variables(context)
-      end
-
-      def consider_variables(context) # :nodoc:
-        context.variable_names.each do |name|
-          next unless is_bad_name?(name, context)
-          found(context, "has the variable name '#{name}'")
-        end
-      end
-
-      def consider_name(context)  # :nodoc:
-        name = context.name
-        return false if accept?(context)
-        return false unless is_bad_name?(name, context)
-        found(context, "has the name '#{name}'")
-      end
-
-      def accept?(context)
-        value(ACCEPT_KEY, context, DEFAULT_ACCEPT_SET).include?(context.full_name)
-      end
-
-      def is_bad_name?(name, context)  # :nodoc:
-        var = name.effective_name
-        return false if var == '*' or value(ACCEPT_KEY, context, DEFAULT_ACCEPT_SET).include?(var)
-        value(REJECT_KEY, context, DEFAULT_REJECT_SET).detect {|patt| patt === var}
-      end
-    end
-  end
-end

data/lib/reek/sniffer.rb

@@ -1,177 +0,0 @@
-require 'reek/detector_stack'
-
-# SMELL: Duplication -- all these should be found automagically
-require 'reek/smells/attribute'
-require 'reek/smells/class_variable'
-require 'reek/smells/control_couple'
-require 'reek/smells/data_clump'
-require 'reek/smells/duplication'
-require 'reek/smells/feature_envy'
-require 'reek/smells/large_class'
-require 'reek/smells/long_method'
-require 'reek/smells/long_parameter_list'
-require 'reek/smells/long_yield_list'
-require 'reek/smells/nested_iterators'
-require 'reek/smells/simulated_polymorphism'
-require 'reek/smells/uncommunicative_name'
-require 'reek/smells/utility_function'
-require 'reek/code_parser'
-require 'yaml'
-
-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
-  class Sniffer
-
-    def self.smell_classes
-      # SMELL: Duplication -- these should be loaded by listing the files
-      [
-        Smells::Attribute,
-        Smells::ClassVariable,
-        Smells::ControlCouple,
-        Smells::DataClump,
-        Smells::Duplication,
-        Smells::FeatureEnvy,
-        Smells::LargeClass,
-        Smells::LongMethod,
-        Smells::LongParameterList,
-        Smells::LongYieldList,
-        Smells::NestedIterators,
-        Smells::SimulatedPolymorphism,
-        Smells::UncommunicativeName,
-        Smells::UtilityFunction,
-      ]
-    end
-
-    def initialize(src)
-      @already_checked_for_smells = false
-      @typed_detectors = nil
-      @detectors = Hash.new
-      Sniffer.smell_classes.each { |klass| @detectors[klass] = DetectorStack.new(klass.new) }
-      @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
-
-    def smelly?
-      check_for_smells
-      @detectors.each_value { |stack| return true if stack.smelly? }
-      false
-    end
-
-    def num_smells
-      check_for_smells
-      total = 0
-      @detectors.each_value { |stack| total += stack.num_smells }
-      total
-    end
-
-    def desc
-      # SMELL: Special Case
-      # Only used in the Report tests, because they don't always create a Source.
-      @source ? @source.desc : "unknown"
-    end
-
-    #
-    # Checks for instances of +smell_class+, and returns +true+
-    # only if one of them has a report string matching all of the +patterns+.
-    #
-    def has_smell?(smell_class, patterns=[])
-      check_for_smells
-      stack = @detectors[Reek::Smells.const_get(smell_class)]      # SMELL: Duplication of code in ConfigFile
-      stack.has_smell?(patterns)
-    end
-
-    def sniff
-      self
-    end
-
-    def sniffers
-      [self]
-    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
-
-  class SnifferSet
-
-    attr_reader :desc, :sniffers
-
-    def initialize(sniffers, desc)
-      @sniffers = sniffers
-      @desc = desc
-    end
-
-    def smelly?
-      @sniffers.any? {|sniffer| sniffer.smelly? }
-    end
-
-    #
-    # Checks for instances of +smell_class+, and returns +true+
-    # only if one of them has a report string matching all of the +patterns+.
-    #
-    def has_smell?(smell_class, patterns=[])
-      @sniffers.any? {|sniffer| sniffer.has_smell?(smell_class, patterns)}
-    end
-
-    def num_smells
-      @sniffers.inject(0) {|total, sniffer| total += sniffer.num_smells}
-    end
-
-    def sniff
-      self
-    end
-
-  end
-end

data/lib/reek/stop_context.rb

@@ -1,35 +0,0 @@
-module Reek
-  class StopContext
-    
-    def initialize
-      @refs = ObjectRefs.new
-      @name = ''
-      @myself = Object
-    end
-
-    def method_missing(method, *args)
-      nil
-    end
-
-    def count_statements(num)
-      0
-    end
-
-    def find_module(name)
-      sym = name.to_s
-      @myself.const_defined?(sym) ? @myself.const_get(sym) : nil
-    end
-
-    def full_name
-      ''
-    end
-    
-    def inside_a_block?
-      false
-    end
-
-    def is_overriding_method?(name)
-      false
-    end
-  end
-end