reek 1.2.6 → 1.2.7

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

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/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/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