teksymmetry-reek 1.1.3.1

data/lib/reek/method_context.rb

@@ -0,0 +1,91 @@
+require 'reek/name'
+require 'reek/code_context'
+require 'reek/object_refs'
+
+module Reek
+  class MethodContext < CodeContext
+    attr_reader :parameters
+    attr_reader :calls
+    attr_reader :refs
+    attr_reader :num_statements
+
+    def initialize(outer, exp, record = true)
+      super(outer, exp)
+      @parameters = []
+      @local_variables = []
+      @name = Name.new(exp[1])
+      @num_statements = 0
+      @calls = Hash.new(0)
+      @depends_on_self = false
+      @refs = ObjectRefs.new
+      @outer.record_method(@name)    # TODO: should be children of outer?
+    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
+      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 record_local_variable(sym)
+      @local_variables << Name.new(sym)
+    end
+
+    def self.is_block_arg?(param)
+      (Array === param and param[0] == :block) or (param.to_s =~ /^\&/)
+    end
+
+    def record_parameter(param)
+      @parameters << Name.new(param) unless MethodContext.is_block_arg?(param)
+    end
+
+    def outer_name
+      "#{@outer.outer_name}#{@name}/"
+    end
+
+    def to_s
+      "#{@outer.outer_name}#{@name}"
+    end
+
+    def envious_receivers
+      return [] if @refs.self_is_max?
+      @refs.max_keys
+    end
+
+    def variable_names
+      @parameters + @local_variables
+    end
+  end
+end

data/lib/reek/module_context.rb

@@ -0,0 +1,33 @@
+require 'reek/code_context'
+
+module Reek
+  class ModuleContext < CodeContext
+
+    def ModuleContext.create(outer, exp)
+      res = Name.resolve(exp[1], outer)
+      ModuleContext.new(res[0], res[1])
+    end
+
+    def initialize(outer, name)
+      super(outer, nil)
+      @name = name
+    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 outer_name
+      "#{@outer.outer_name}#{@name}::"
+    end
+
+    def variable_names
+      []
+    end
+  end
+end

data/lib/reek/name.rb

@@ -0,0 +1,49 @@
+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 <=>(other)  # :nodoc:
+      @name <=> other.to_s
+    end
+
+    alias eql? <=>
+
+    def effective_name
+      @name.gsub(/^@*/, '')
+    end
+
+    def to_s
+      @name
+    end
+  end
+end

data/lib/reek/object_refs.rb

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'sexp_processor'
+
+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/object_source.rb

@@ -0,0 +1,53 @@
+module Reek
+  class Source
+    #
+    # Factory method: creates a +Source+ from obj.
+    # The code is not parsed until +report+ is called.
+    # (This feature is only enabled if you have the ParseTree gem installed.)
+    #
+    def self.from_object(obj)
+      return ObjectSource.new(obj, obj.to_s)
+    end
+  end
+
+  class ObjectSource < Source   # :nodoc:
+
+    def self.unify(sexp)   # :nodoc:
+      unifier = Unifier.new
+      unifier.processors.each do |proc|
+        proc.unsupported.delete :cfunc # HACK
+      end
+      return unifier.process(sexp[0])
+    end
+
+    def can_parse_objects?
+      return true if Object.const_defined?(:ParseTree)
+      begin
+        require 'parse_tree'
+        true
+      rescue LoadError
+        false
+      end
+    end
+
+    def generate_syntax_tree
+      if can_parse_objects?
+        ObjectSource.unify(ParseTree.new.parse_tree(@source))
+      else
+        throw ArgumentError.new('You must install the ParseTree gem to use this feature')
+      end
+    end
+  end
+end
+
+class Object
+  #
+  # Constructs a Source representing this object; the source can then be used
+  # to generate an abstract syntax tree for the object, which can in turn then
+  # be examined for code smells.
+  # (This feature is only enabled if you have the ParseTree gem installed.)
+  #
+  def to_source
+    Reek::Source.from_object(self)
+  end
+end

data/lib/reek/options.rb

@@ -0,0 +1,100 @@
+require 'optparse'
+require 'reek/source'
+
+module Reek
+    
+  class Options
+
+    CTX_SORT = '%c %w (%s)' if !const_defined?(:CTX_SORT)
+    SMELL_SORT = '[%s] %c %w' if !const_defined?(:SMELL_SORT)
+
+    def self.default_options
+      {
+        :format => CTX_SORT
+      }
+    end
+    
+    @@opts = default_options
+
+    def self.[](key)
+      @@opts[key]
+    end
+
+    def self.parse_args(args)
+      result = default_options
+      parser = OptionParser.new { |opts| set_options(opts, result) }
+      parser.parse!(args)
+      result
+    end
+    
+    def self.set_options(opts, config)
+      opts.banner = <<EOB
+Usage: #{opts.program_name} [options] files...
+
+If no files are given, Reek reads source code from standard input.
+See http://wiki.github.com/kevinrutherford/reek for detailed help.
+EOB
+      
+      opts.separator "\nOptions:"
+      set_help_option(opts)
+      set_sort_option(config, opts)
+      set_version_option(opts)
+      set_output_format_option(config, opts)
+    end
+
+    def self.parse(args)
+      begin
+        @@opts = parse_args(args)
+        if args.length > 0
+          return Source.from_pathlist(args)
+        else
+          return Source.from_io($stdin, 'stdin')
+        end
+      rescue OptionParser::ParseError, SystemCallError => err
+        fatal_error(err)
+      end
+    end
+
+  private
+    def self.set_output_format_option(p_config, p_opts)
+      p_opts.on('-of', '--output-format',
+          "Render output in the specified format, ie. html, " +
+          "by default 'text' is used.") do |value|
+        p_config[:output_format] = value
+      end
+    end
+
+    def self.set_version_option(opts)
+      opts.on("-v", "--version", "Show version") do
+        puts "#{opts.program_name} #{Reek::VERSION}"
+        exit(0)
+      end
+    end
+
+    def self.set_help_option(opts)
+      opts.on("-h", "--help", "Show this message") do
+        puts opts
+        exit(0)
+      end
+    end
+
+    def self.set_sort_option(config, opts)
+      opts.on('-f', "--format FORMAT", 'Specify the format of smell warnings') do |arg|
+        config[:format] = arg unless arg.nil?
+      end
+      opts.on('-c', '--context-first', "Sort by context; sets the format string to \"#{CTX_SORT}\"") do
+        config[:format] = CTX_SORT
+      end
+      opts.on('-s', '--smell-first', "Sort by smell; sets the format string to \"#{SMELL_SORT}\"") do
+        config[:format] = SMELL_SORT
+      end
+    end
+    
+    def self.fatal_error(err) # :nodoc:
+      puts "Error: #{err}"
+      puts "Use '-h' for help."
+      exit(1)
+    end
+    
+  end
+end

data/lib/reek/rake_task.rb

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+
+# Define a task library for running reek.
+
+require 'rake'
+require 'rake/tasklib'
+
+module Reek
+
+  # A Rake task that runs reek on a set of source files.
+  #
+  # Example:
+  #
+  #   Reek::RakeTask.new do |t|
+  #     t.fail_on_error = false
+  #   end
+  #
+  # This will create a task that can be run with:
+  #
+  #   rake reek
+  #
+  # Examples:
+  #
+  #   rake reek                                # checks lib/**/*.rb
+  #   rake reek REEK_SRC=just_one_file.rb      # checks a single source file
+  #   rake reek REEK_OPTS=-s                   # sorts the report by smell
+  #
+  class RakeTask < ::Rake::TaskLib
+
+    # Name of reek task.
+    # Defaults to :reek.
+    attr_accessor :name
+
+    # Array of directories to be added to $LOAD_PATH before running reek.
+    # Defaults to ['<the absolute path to reek's lib directory>']
+    attr_accessor :libs
+
+    # Glob pattern to match source files.
+    # Setting the REEK_SRC environment variable overrides this.
+    # Defaults to 'lib/**/*.rb'.
+    attr_accessor :source_files
+
+    # String containing commandline options to be passed to Reek.
+    # Setting the REEK_OPTS environment variable overrides this value.
+    # Defaults to ''.
+    attr_accessor :reek_opts
+
+    # Array of commandline options to pass to ruby. Defaults to [].
+    attr_accessor :ruby_opts
+
+    # Whether or not to fail Rake when an error occurs (typically when smells are found).
+    # Defaults to true.
+    attr_accessor :fail_on_error
+
+    # Use verbose output. If this is set to true, the task will print
+    # the reek command to stdout. Defaults to false.
+    attr_accessor :verbose
+
+    # Defines a new task, using the name +name+.
+    def initialize(name = :reek)
+      @name = name
+      @libs = [File.expand_path(File.dirname(__FILE__) + '/../../lib')]
+      @source_files = nil
+      @ruby_opts = []
+      @reek_opts = ''
+      @fail_on_error = true
+      @sort = nil
+
+      yield self if block_given?
+      @source_files ||= 'lib/**/*.rb'
+      define
+    end
+
+private
+    
+    def define # :nodoc:
+      desc 'Check for code smells' unless ::Rake.application.last_comment
+      task(name) { run_task }
+      self
+    end
+    
+    def run_task
+      return if source_file_list.empty?
+      cmd = cmd_words.join(' ')
+      puts cmd if @verbose
+      raise('Smells found!') if !system(cmd) and fail_on_error
+    end
+
+    def self.reek_script
+      File.expand_path(File.dirname(__FILE__) + '/../../bin/reek')
+    end
+
+    def self.ruby_exe
+      File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+    end
+
+    def cmd_words
+      [RakeTask.ruby_exe] +
+          ruby_options +
+          [ %Q|"#{RakeTask.reek_script}"| ] +
+          [sort_option] +
+          source_file_list.collect { |fn| %["#{fn}"] }
+    end
+
+    def ruby_options
+      lib_path = @libs.join(File::PATH_SEPARATOR)
+      @ruby_opts.clone << "-I\"#{lib_path}\""
+    end
+    
+    def sort_option
+      ENV['REEK_OPTS'] || @reek_opts
+    end
+
+    def source_file_list # :nodoc:
+      files = ENV['REEK_SRC'] || @source_files
+      return [] unless files
+      return FileList[files]
+    end
+
+  end
+end

data/lib/reek/report.rb

@@ -0,0 +1,81 @@
+require 'set'
+require 'reek/smells/smell_detector'
+
+module Reek
+  class Report
+    include Enumerable
+
+    def initialize  # :nodoc:
+      @report = SortedSet.new
+    end
+
+    #
+    # Yields, in turn, each SmellWarning in this report.
+    #
+    def each
+      @report.each { |smell| yield smell }
+    end
+
+    def <<(smell)  # :nodoc:
+      @report << smell
+      true
+    end
+    
+    def empty?
+      @report.empty?
+    end
+
+    def length
+      @report.length
+    end
+    
+    alias size length
+
+    def [](index)  # :nodoc:
+      @report.to_a[index]
+    end
+
+    # Creates a formatted report of all the +Smells::SmellWarning+ objects recorded in
+    # this report, with a heading.
+    def full_report(desc)
+      "\"#{desc}\" -- #{length} warnings:\n#{to_s}\n"
+    end
+
+    # Creates a formatted report of all the +Smells::SmellWarning+ objects recorded in
+    # this report.
+    def to_s
+      @report.map {|smell| smell.report}.join("\n")
+    end
+  end
+
+  class ReportList
+    include Enumerable
+
+    def initialize(sources)
+      @sources = sources
+    end
+
+    #
+    # Yields, in turn, each SmellWarning in every report in this report.
+    #
+    def each(&blk)
+      @sources.each {|src| src.report.each(&blk) }
+    end
+
+    def empty?
+      length == 0
+    end
+
+    def length
+      @sources.inject(0) {|sum, src| sum + src.report.length }
+    end
+
+    def smelly_sources
+      @sources.select {|src| src.smelly? }
+    end
+
+    def to_s
+      smelly_sources.map { |src| src.full_report }.join("\n")
+    end
+  end
+end

data/lib/reek/sexp_formatter.rb

@@ -0,0 +1,10 @@
+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

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

data/lib/reek/smell_warning.rb

@@ -0,0 +1,49 @@
+require 'reek/options'
+
+module Reek
+
+  #
+  # Reports a warning that a smell has been found.
+  #
+  class SmellWarning
+    include Comparable
+
+    def initialize(smell, context, warning)
+      @smell = smell
+      @context = context
+      @warning = warning
+    end
+
+    def hash  # :nodoc:
+      report.hash
+    end
+
+    def <=>(other)
+      report <=> other.report
+    end
+
+    alias eql? <=>  # :nodoc:
+
+    #
+    # Returns +true+ only if this is a warning about an instance of
+    # +smell_class+ and its report string matches all of the +patterns+.
+    #
+    def matches?(smell_class, patterns)
+      return false unless smell_class.to_s == @smell.class.class_name
+      rpt = report
+      return patterns.all? {|exp| exp === rpt}
+    end
+
+    #
+    # Returns a copy of the current report format (see +Options+)
+    # in which the following magic tokens have been substituted:
+    #
+    # * %s <-- the name of the smell that was detected
+    # * %c <-- a description of the +CodeContext+ containing the smell
+    # * %w <-- the specific problem that was detected
+    #
+    def report
+      Options[:format].gsub(/\%s/, @smell.smell_name).gsub(/\%c/, @context.to_s).gsub(/\%w/, @warning)
+    end
+  end
+end