wool 0.5.1

data/lib/wool/analysis/signature.rb

@@ -0,0 +1,16 @@
+module Wool
+  module SexpAnalysis
+    # A single signature in the Wool protocol system. This is just
+    # a simple specification of a method that an object can receive,
+    # either explicitly or implicitly defined, and the protocols of the
+    # return type and all arguments.
+    class Signature < Struct.new(:name, :return_protocol, :argument_protocols)
+      include Comparable
+
+      def <=>(other)
+        [self.name, self.return_protocol, self.argument_protocols] <=>
+            [other.name, other.return_protocol, other.argument_protocols]
+      end
+    end
+  end
+end

data/lib/wool/analysis/symbol.rb

@@ -0,0 +1,10 @@
+module Wool
+  module SexpAnalysis
+    # This class represents a Symbol in Ruby. It may have a known protocol (type),
+    # class, value (if constant!), and a variety of other details.
+    class Symbol < Struct.new(:protocol, :class_used, :value, :scope, :name)
+      include Comparable
+      
+    end
+  end
+end

data/lib/wool/analysis/visitor.rb

@@ -0,0 +1,36 @@
+module Wool
+  module SexpAnalysis
+    # Visitor: a set of methods for visiting an AST. The
+    # default implementations visit each child and do no
+    # other processing. By including this module, and
+    # implementing certain methods, you can do your own
+    # processing on, say, every instance of a :rescue AST node.
+    # The default implementation will go arbitrarily deep in the AST
+    # tree until it hits a method you define.
+    module Visitor
+      def visit(node)
+        case node
+        when Sexp
+          case node[0]
+          when ::Symbol
+            send("visit_#{node[0]}", node)
+          when Array
+            node.each {|x| visit(x)}
+          end
+        end
+      end
+      
+      def default_visit(node)
+        node.children.select {|x| Sexp === x}.each {|x| visit(x) }
+      end
+      
+      def method_missing(meth, *args, &blk)
+        if meth.to_s[0,6] == 'visit_'
+          default_visit args.first
+        else
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/wool/analysis/wool_class.rb

@@ -0,0 +1,47 @@
+module Wool
+  module SexpAnalysis
+    # Wool representation of a class. I named it WoolClass so it wouldn't
+    # clash with regular Class. This links the class to its protocol. It
+    # has lists of methods, instance variables, and so on.
+    class WoolClass
+      attr_reader :path, :methods, :protocol, :scope, :class_object
+      attr_accessor :superclass
+
+      def initialize(full_path, scope = Scope::GlobalScope)
+        @path = full_path
+        @methods = {}
+        @protocol = Protocols::ClassProtocol.new(self)
+        @scope = scope
+        @class_object = Symbol.new(@protocol, self)
+        ProtocolRegistry.add_class_protocol(@protocol)
+        yield self if block_given?
+      end
+      
+      def add_method(method)
+        @methods[method.name] = method
+      end
+      
+      def signatures
+        @methods.values.map(&:signatures).flatten
+      end
+    end
+    
+    # Wool representation of a method. This name is tweaked so it doesn't
+    # collide with ::Method.
+    class WoolMethod
+      extend ModuleExtensions
+      attr_reader :name, :signatures
+      attr_accessor_with_default :pure, false
+      
+      def initialize(name)
+        @name = name
+        @signatures = []
+        yield self if block_given?
+      end
+      
+      def add_signature(return_proto, arg_protos)
+        @signatures << Signature.new(self.name, return_proto, arg_protos)
+      end
+    end
+  end
+end

data/lib/wool/rake/task.rb

@@ -0,0 +1,42 @@
+module Wool
+  module Rake
+    class WoolTask
+      class Settings < Struct.new(:libs, :extras, :options, :using, :fix)
+        def initialize(*args)
+          super
+          self.libs ||= []
+          self.extras ||= []
+          self.options ||= ''
+          self.using ||= []
+          self.fix ||= []
+        end
+      end
+
+      attr_accessor :settings
+
+      def initialize(task_name)
+        @settings = Settings.new
+        yield @settings if block_given?
+        @settings.using = [:all] if @settings.using.empty?
+        task task_name do
+          run
+        end
+      end
+
+      def run
+        files = []
+        if @settings.libs.any?
+          @settings.libs.each do |lib|
+            Dir["#{lib}/**/*.rb"].each do |file|
+              files << file
+            end
+          end
+        end
+        runner = Wool::Runner.new(self.settings.options.split(/\s/) + files)
+        runner.using = self.settings.using
+        runner.fix = self.settings.fix
+        runner.run
+      end
+    end
+  end
+end

data/lib/wool/runner.rb

@@ -0,0 +1,156 @@
+module Wool
+  class Runner
+    attr_accessor :using, :fix
+
+    def initialize(argv)
+      @argv = argv
+      @using = [:all]
+      @fix = [:all]
+    end
+
+    def run
+      settings, files = collect_options_and_arguments
+      settings[:__using__] = warnings_to_consider
+      settings[:__fix__] = warnings_to_fix
+      scanner = Scanner.new(settings)
+      warnings = collect_warnings(files, scanner)
+      display_warnings(warnings, settings) if settings[:display]
+    end
+
+    def collect_options_and_arguments
+      swizzling_argv do
+        settings = get_settings
+        handle_global_options(settings)
+        p settings if settings[:debug]
+        files = ARGV.dup
+        [settings, files]
+      end
+    end
+    
+    # Processes the global options, which includes picking which warnings to
+    # run against the source code. The settings provided determine what
+    # modifies the runner's settings.
+    #
+    # @param [Hash] settings the settings from the command-line to process.
+    # @option settings :only (String) a list of warning names or short names
+    #   that will be the only warnings run. The names should be whitespace-delimited.
+    # @option settings :"line-length" (Integer) a maximum line length to
+    #   generate a warning for. A common choice is 80/83.
+    def handle_global_options(settings)
+      if settings[:"line-length"]
+        @using << Wool.LineLengthWarning(settings[:"line-length"])
+      end
+      if (only_name = settings[:only])
+        @fix = @using = Warning.concrete_warnings.select do |w|
+          (w.name && w.name.index(only_name)) || (w.short_name && only_name.index(w.short_name))
+        end
+      end
+      ARGV.replace(['(stdin)']) if settings[:stdin]
+    end
+
+    # Parses the command-line options using Trollop
+    #
+    # @return [Hash{Symbol => Object}] the settings entered by the user
+    def get_settings
+      warning_opts = get_warning_options
+      Trollop::options do
+        banner 'Ask Peeves - the Ruby Linter'
+        opt :fix, 'Should errors be fixed in-line?', :short => '-f'
+        opt :display, 'Should errors be displayed?', :short => '-b', :default => true
+        opt :"report-fixed", 'Should fixed errors be reported anyway?', :short => '-r'
+        opt :"line-length", 'Warn at the given line length', :short => '-l', :type => :int
+        opt :only, 'Only consider the given warning (by short or full name)', :short => '-O', :type => :string
+        opt :stdin, 'Read Ruby code from standard input', :short => '-s'
+        warning_opts.each { |warning| opt(*warning) }
+      end
+    end
+
+    # Gets all the options from the warning plugins and collects them
+    # with overriding rules. The later the declaration is run, the higher the
+    # priority the option has.
+    def get_warning_options
+      all_options = Warning.all_warnings.inject({}) do |result, warning|
+        options = warning.options
+        options = [options] if options.any? && !options[0].is_a?(Array)
+        options.each do |option|
+          result[option.first] = option
+        end
+        result
+      end
+      all_options.values
+    end
+
+    # Converts a list of warnings and symbol shortcuts for warnings to just a
+    # list of warnings.
+    def convert_warning_list(list)
+      list.map do |list|
+        case list
+        when :all then Warning.all_warnings
+        when :whitespace
+          [ExtraBlankLinesWarning, ExtraWhitespaceWarning,
+           OperatorSpacing, MisalignedUnindentationWarning]
+          else list
+        end
+      end.flatten
+    end
+
+    # Returns the list of warnings the user has activated for use.
+    def warnings_to_consider
+      convert_warning_list(@using)
+    end
+
+    # Returns the list of warnings the user has selected for fixing
+    def warnings_to_fix
+      convert_warning_list(@fix)
+    end
+
+    # Sets the ARGV variable to the runner's arguments during the execution
+    # of the block.
+    def swizzling_argv
+      old_argv = ARGV.dup
+      ARGV.replace @argv
+      yield
+    ensure
+      ARGV.replace old_argv
+    end
+
+    # Collects warnings from all the provided files by running them through
+    # the scanner.
+    #
+    # @param [Array<String>] files the files to scan. If (stdin) is in the
+    #   array, then data will be read from STDIN until EOF is reached.
+    # @param [Scanner] scanner the scanner that will look for warnings
+    #   in the source text.
+    # @return [Array<Warning>] a set of warnings, ordered by file.
+    def collect_warnings(files, scanner)
+      full_list = files.map do |file|
+        data = file == '(stdin)' ? STDIN.read : File.read(file)
+        if scanner.settings[:fix]
+          scanner.settings[:output_file] = scanner.settings[:stdin] ? STDOUT : File.open(file, 'w')
+        end
+        results = scanner.scan(data, file)
+        scanner.settings[:output_file].close if scanner.settings[:fix] && !scanner.settings[:stdin]
+        results
+      end
+      full_list.flatten
+    end
+
+    # Displays warnings using user-provided settings.
+    #
+    # @param [Array<Warning>] warnings the warnings generated by the input
+    #   files, ordered by file
+    # @param [Hash{Symbol => Object}] settings the user-set display settings
+    def display_warnings(warnings, settings)
+      num_fixable = warnings.select { |warn| warn.fixable? }.size
+      num_total = warnings.size
+
+      results = "#{num_total} warnings found. #{num_fixable} are fixable."
+      puts results
+      puts '=' * results.size
+
+      warnings.each do |warning|
+        puts "#{warning.file}:#{warning.line_number} #{warning.name} (#{warning.severity}) - #{warning.desc}"
+      end
+    end
+  end
+end

data/lib/wool/scanner.rb

@@ -0,0 +1,160 @@
+module Wool
+  class Scanner
+    attr_accessor :settings
+    attr_accessor :indent_stack
+
+    DEFAULT_SETTINGS = {:fix => false, :output => STDOUT, :indent_size => 2,
+                        :__using__ => Wool::Warning.all_warnings,
+                        :__fix__ => Wool::Warning.all_warnings}
+
+    # Initializes the scanner with the given settings
+    #
+    # @param [Hash] settings the settings to use to customize this scanner's
+    #   scanning behavior
+    def initialize(settings = DEFAULT_SETTINGS)
+      @settings = DEFAULT_SETTINGS.merge(settings)
+      @settings[:__scanner__] = self
+      self.indent_stack = []
+    end
+
+    # Returns the list of warnings to use for scanning.
+    def using
+      @settings[:__using__]
+    end
+
+    # Should we use this warning?
+    def using?(warning)
+      @settings[:__using__].include? warning
+    end
+
+    # Returns the list of warnings to use for scanning.
+    def fix
+      @settings[:__fix__]
+    end
+
+    # Should we use this warning?
+    def fixing?(warning)
+      @settings[:__fix__].include? warning.class
+    end
+
+    # Scans the text for warnings.
+    #
+    # @param [String] text the input ruby file to scan
+    # @return [Array[Wool::Warnings]] the warnings generated by the code.
+    #   If the code is clean, an empty array is returned.
+    def scan(text, filename='(none)')
+      warnings = scan_for_file_warnings(text, filename)
+      text = filter_fixable(warnings).inject(text) do |text, warning|
+        warning.fix(text)
+      end
+      with_fixing_piped_to_output do
+        text.split(/\n/).each_with_index do |line, number|
+          warnings.concat process_line(line, number + 1, filename)
+        end
+      end
+      warnings
+    end
+
+    def with_fixing_piped_to_output
+      self.settings[:output_lines] = []
+      yield
+      if @settings[:fix]
+        self.settings[:output_file].write self.settings[:output_lines].join("\n")
+      end
+    end
+
+    # Finds all matching warnings, and if the user wishes, fix a subset of them.
+    def process_line(line, line_number, filename)
+      warnings = all_warnings_for_line(line, line_number, filename)
+      fix_input(warnings, line, line_number, filename) if @settings[:fix]
+      warnings
+    end
+
+    # Tries to fix the given line with a set of matching warnings for that line.
+    # May recurse if there are multiple warnings on the same line.
+    def fix_input(warnings, line, line_number, filename)
+      fixable_warnings = filter_fixable warnings
+      if fixable_warnings.size == 1
+        self.settings[:output_lines] << fixable_warnings.first.fix rescue line
+      elsif fixable_warnings.size > 1
+        new_text = fixable_warnings.first.fix rescue line
+        process_line(new_text, line_number, filename)
+      else
+        self.settings[:output_lines] << line
+      end
+    end
+
+    # Returns all warnings that match the line
+    def all_warnings_for_line(line, line_number, filename)
+      new_warnings = check_for_indent_warnings!(line, filename)
+      new_warnings.concat scan_for_line_warnings(line, filename)
+      new_warnings.each {|warning| warning.line_number = line_number}
+    end
+
+    # Returns only the warnings that we should fix
+    def filter_fixable(warnings)
+      warnings.select {|warning| warning.fixable? && fixing?(warning) }
+    end
+
+    # Checks for new warnings based on indentation.
+    def check_for_indent_warnings!(line, filename)
+      return [] if line == ""
+      indent_size = get_indent_size line
+      if indent_size > current_indent
+        self.indent_stack.push indent_size
+      elsif indent_size < current_indent
+        previous = self.indent_stack.pop
+        if indent_size != current_indent &&
+           using.include?(MisalignedUnindentationWarning)
+          warnings_to_check = [MisalignedUnindentationWarning.new(filename, line, current_indent)]
+          return filtered_warnings_from_line(line, warnings_to_check)
+        end
+      end
+      []
+    end
+
+    # Gets the current indent size
+    def current_indent
+      self.indent_stack.last || 0
+    end
+
+    # Gets the indent size of a given line
+    def get_indent_size(line)
+      line.match(/^\s*/)[0].size
+    end
+
+    # Goes through all file warning subclasses and see what warnings the file
+    # generates as a whole.
+    def scan_for_file_warnings(file, filename)
+      scan_for_warnings(using & FileWarning.all_warnings, file, filename)
+    end
+
+    # Goes through all line warning subclasses and checks if we got some new
+    # warnings for a given line
+    def scan_for_line_warnings(line, filename)
+      warnings = scan_for_warnings(using & LineWarning.all_warnings, line, filename)
+      filtered_warnings_from_line(line, warnings)
+    end
+
+    private
+
+    # Filters the list of warnings by checking the line for warnings to
+    # ignore. The line should contain "wool: ignore ClassToIgnore" in a comment,
+    # though you can omit the space between "wool:" and "ignore".
+    def filtered_warnings_from_line(line, warnings)
+      match = line.match(/#.*wool:\s*ignore\s+(.*)$/)
+      return warnings unless match && ignore_label = match[1]
+      class_names = ignore_label.split
+      result = warnings.reject do |warning|
+        class_names.include?(warning.class.name.gsub(/.*::(.*)/, '\1')) ||
+          class_names.include?(warning.class.short_name)
+      end
+      result
+    end
+
+    def scan_for_warnings(warnings, content, filename)
+      warnings.map! { |warning| warning.new(filename, content, @settings)}
+      warnings.map { |warning| warning.generated_warnings(warning.body)}.flatten.uniq
+    end
+  end
+end