reek 1.2.6 → 1.2.7

data/lib/reek/adapters/config_file.rb

@@ -1,31 +0,0 @@
-require 'yaml'
-
-module Reek
-  class ConfigFile
-
-    def initialize(file_path)
-      @file_path = file_path
-      @hash = YAML.load_file(@file_path) || {}
-      problem('not a Hash') unless Hash === @hash
-    end
-
-    #
-    # Configure the given sniffer using the contents of the config file.
-    #
-    def configure(sniffer)
-      @hash.each { |klass_name, config|
-        sniffer.configure(find_class(klass_name), config)
-      }
-    end
-
-    def find_class(name)
-      klass = Reek::Smells.const_get(name)
-      problem("#{name} is not a code smell") unless klass
-      klass
-    end
-
-    def problem(reason)
-      raise "Invalid configuration file \"#{File.basename(@file_path)}\" -- #{reason}"
-    end
-  end
-end

data/lib/reek/adapters/core_extras.rb

@@ -1,64 +0,0 @@
-require 'reek/adapters/source'
-require 'reek/sniffer'
-
-class Object
-  #
-  # Creates a new +Sniffer+ that assumes this object contains Ruby source
-  # code and examines that code for smells. Calls +to_reek_source+ on self
-  # to obtain the +Source+ object wrapper.
-  #
-  def sniff
-    Reek::Sniffer.new(self.to_reek_source)
-  end
-end
-
-class File
-  #
-  # Creates a new +Source+ that assumes this File contains Ruby source
-  # code and prepares it to be examined for code smells.
-  #
-  def to_reek_source
-    Reek::SourceFile.new(self)
-  end
-end
-
-class IO
-  #
-  # Creates a new +Source+ that assumes this IO stream contains Ruby source
-  # code and prepares it to be examined for code smells.
-  #
-  def to_reek_source(description = 'io')
-    Reek::Source.new(self.readlines.join, description)
-  end
-end
-
-class String
-  #
-  # Creates a new +Source+ that assumes this string contains Ruby source
-  # code and prepares it to be examined for code smells.
-  #
-  def to_reek_source
-    Reek::Source.new(self, 'string')
-  end
-end
-
-class Array
-  def paths
-    self.map do |path|
-      if test 'd', path
-        Dir["#{path}/**/*.rb"].paths
-      else
-        path
-      end
-    end.flatten.sort
-  end
-
-  #
-  # Creates a new +Sniffer+ that assumes this Array contains the names
-  # of Ruby source files and examines those files for smells.
-  #
-  def sniff
-    sniffers = paths.map {|path| File.new(path).sniff}
-    Reek::SnifferSet.new(sniffers, 'dir')
-  end
-end

data/lib/reek/adapters/rake_task.rb

@@ -1,121 +0,0 @@
-#!/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/adapters/report.rb

@@ -1,86 +0,0 @@
-require 'set'
-require 'reek/adapters/command_line'   # SMELL: Global Variable
-require 'reek/masking_collection'
-
-module Reek
-  class ReportSection
-
-    SMELL_FORMAT = '%m%c %w (%s)'
-
-    def initialize(sniffer, display_masked_warnings)
-      @cwarnings = MaskingCollection.new
-      @desc = sniffer.desc
-      @display_masked_warnings = display_masked_warnings  # SMELL: Control Couple
-      sniffer.report_on(@cwarnings)
-    end
-
-    # Creates a formatted report of all the +Smells::SmellWarning+ objects recorded in
-    # this report, with a heading.
-    def verbose_report
-      result = header
-      result += ":\n#{smell_list}" if should_report
-      result += "\n"
-      result
-    end
-
-    def quiet_report
-      return '' unless should_report
-      # SMELL: duplicate knowledge of the header layout
-      "#{header}:\n#{smell_list}\n"
-    end
-
-    def header
-      "#{@desc} -- #{visible_header}#{masked_header}"
-    end
-
-    # Creates a formatted report of all the +Smells::SmellWarning+ objects recorded in
-    # this report.
-    def smell_list
-      result = []
-      if @display_masked_warnings
-        @cwarnings.each_item {|smell| result << "  #{smell.report(SMELL_FORMAT)}"}
-      else
-        @cwarnings.each_visible_item {|smell| result << "  #{smell.report(SMELL_FORMAT)}"}
-      end
-      result.join("\n")
-    end
-
-  private
-
-    def should_report
-      @cwarnings.num_visible_items > 0 or (@display_masked_warnings and @cwarnings.num_masked_items > 0)
-    end
-
-    def visible_header
-      num_smells = @cwarnings.num_visible_items
-      result = "#{num_smells} warning"
-      result += 's' unless num_smells == 1
-      result
-    end
-
-    def masked_header
-      num_masked_warnings = @cwarnings.num_masked_items
-      num_masked_warnings == 0 ? '' : " (+#{num_masked_warnings} masked)"
-    end
-  end
-
-  class Report
-    def initialize(sniffers, display_masked_warnings = false)
-      @partials = Array(sniffers).map {|sn| ReportSection.new(sn, display_masked_warnings)}
-    end
-  end
-
-  class VerboseReport < Report
-    # SMELL: Implementation Inheritance
-    def report
-      @partials.map { |section| section.verbose_report }.join
-    end
-  end
-
-  class QuietReport < Report
-    # SMELL: Implementation Inheritance
-    def report
-      @partials.map { |section| section.quiet_report }.join
-    end
-  end
-end

data/lib/reek/adapters/source.rb

@@ -1,72 +0,0 @@
-require 'ruby_parser'
-require 'reek/adapters/config_file'
-require 'reek/tree_dresser'
-
-module Reek
-
-  #
-  # A +Source+ object represents a chunk of Ruby source code.
-  #
-  class Source
-
-    @@err_io = $stderr
-
-    class << self
-      def err_io=(io)
-        original = @@err_io
-        @@err_io = io
-        original
-      end
-    end
-
-    attr_reader :desc
-
-    def initialize(code, desc, parser = RubyParser.new)
-      @source = code
-      @desc = desc
-      @parser = parser
-    end
-
-    def configure(sniffer) end
-
-    def syntax_tree
-      begin
-        ast = @parser.parse(@source, @desc)
-      rescue Exception => error
-        @@err_io.puts "#{desc}: #{error.class.name}: #{error}"
-      end
-      ast ||= s()
-      TreeDresser.new.dress(ast)
-    end
-  end
-
-  #
-  # Represents a file of Ruby source, whose contents will be examined
-  # for code smells.
-  #
-  class SourceFile < Source
-
-    def self.lines(file)
-      IO.readlines(file.path)
-    end
-
-    def initialize(file)
-      @file = file
-      super(SourceFile.lines(@file).join, @file.path)
-    end
-
-    def configure(sniffer)
-      path = File.expand_path(File.dirname(@file.path))
-      all_config_files(path).each { |cf| ConfigFile.new(cf).configure(sniffer) }
-    end
-
-  private
-
-    def all_config_files(path)
-      return [] unless File.exist?(path)
-      parent = File.dirname(path)
-      return [] if path == parent
-      all_config_files(parent) + Dir["#{path}/*.reek"]
-    end
-  end
-end

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