wool 0.5.1

data/lib/wool/warning.rb

@@ -0,0 +1,145 @@
+module Wool
+  class Warning < Struct.new(:name, :file, :body, :line_number, :severity)
+    extend Advice
+    extend ModuleExtensions
+    include LexicalAnalysis
+    include SexpAnalysis
+
+    cattr_accessor :short_name
+    cattr_accessor_with_default :match_filters, []
+    cattr_get_and_setter :severity, :short_desc, :desc
+    attr_accessor :settings
+
+    desc { "#{self.class.name} #{file}:#{line_number} (#{severity})" }
+
+    # This tracks all subclasses (and subclasses of subclasses, etc). Plus, this
+    # method is inherited, so Wool::LineWarning.all_subclasses will have all
+    # subclasses of Wool::LineWarning!
+    def self.all_warnings
+      @all_warnings ||= [self]
+    end
+    
+    # Returns all "concrete" warnings, that is, those that have an actual
+    # implementation. No meta-warnings like FileWarning/LineWarning.
+    #
+    # @return [Array<Class>] the concrete warnings you might want to use
+    def self.concrete_warnings
+      all_warnings - [self, FileWarning, LineWarning]
+    end
+
+    # All types should be shared and modified by *all* subclasses. This makes
+    # Wool::Warning.all_types a global registry.
+    def self.all_types
+      @@all_types ||= Hash.new {|h,k| h[k] = []}
+    end
+
+    # When a Warning subclass is subclassed, store the subclass and inform the
+    # next superclass up the inheritance hierarchy.
+    def self.inherited(klass)
+      self.all_warnings << klass
+      next_klass = self.superclass
+      while next_klass != Wool::Warning.superclass
+        next_klass.send(:inherited, klass)
+        next_klass = next_klass.superclass
+      end
+    end
+
+    # Override in subclasses to provide a list of options to send to Trollop
+    def self.options
+      @options ||= [:debug, "Shows debug output from wool's scanner", {:short => '-d'}]
+    end
+
+    # Adds an option in Trollop format.
+    def self.opt(*args)
+      self.options << args
+    end
+
+    # Modified cattr_get_and_setter that updates the class's short_name and
+    # registers the class as a member of the given type.
+    def self.type(*args)
+      if args.any?
+        @type = args.first.to_s
+        all_types[@type] << self
+        self.short_name = @type[0,2].upcase + all_types[@type].size.to_s
+      else
+        @type
+      end
+    end
+
+    # Adds an instance method that extracts a key from the settings of
+    # the warning. This is a simple way of storing metadata about the
+    # discovered error/issue for presentational purposes.
+    def self.setting_accessor(*syms)
+      syms.each { |sym| class_eval("def #{sym}\n  @settings[#{sym.inspect}]\nend") }
+    end
+
+    # Default initializer.
+    def initialize(file, body, settings={})
+      super(self.class.short_desc, file, body, 0, self.class.severity)
+      @settings = settings
+    end
+
+    def match?(body = self.body)
+      false
+    end
+
+    def generated_warnings(*args)
+      case match_result = match?(*args)
+      when Array then match_result
+      when false, nil then []
+      else [self]
+      end
+    end
+
+    def fix
+      self.body
+    end
+
+    def fixable?
+      self.fix != self.body rescue false
+    end
+
+    def desc
+      case desc = self.class.desc
+      when String then desc
+      when Proc then instance_eval(&self.class.desc)
+      end
+    end
+
+    def indent(string, amt=nil)
+      amt ||= self.body.match(/^(\s*)/)[1].size
+      ' ' * amt + string.lstrip
+    end
+
+    def count_occurrences(string, substring)
+      count = 0
+      0.upto(string.size - substring.size) do |start|
+        if string[start,substring.size] == substring
+          count += 1
+        end
+      end
+      count
+    end
+
+    def get_indent(line = self.body)
+      line =~ /^(\s*).*$/ ? $1 : ''
+    end
+  end
+
+  class LineWarning < Warning
+    alias_method :line, :body
+    def self.options
+      @options ||= []
+    end
+  end
+
+  class FileWarning < Warning
+    def self.options
+      @options ||= []
+    end
+  end
+end
+
+Dir[File.expand_path(File.join(File.dirname(__FILE__), 'warnings', '**', '*.rb'))].each do |file|
+  load file
+end

data/lib/wool/warnings/comment_spacing.rb

@@ -0,0 +1,30 @@
+# Warning for insufficient space between inline comments and code
+class Wool::InlineCommentSpaceWarning < Wool::LineWarning
+  OPTION_KEY = :inline_comment_space
+  DEFAULT_SPACE = 2
+  type :style
+  short_desc 'Inline comment spacing error'
+  desc { "Inline comments must be at least #{@settings[OPTION_KEY]} spaces from code." }
+  opt OPTION_KEY, 'Number of spaces between code and inline comments', :default => DEFAULT_SPACE
+
+  def match?(line = self.body)
+    return false unless comment_token = find_token(:on_comment)
+    comment_pos = comment_token.col - 1
+    left_of_comment = line[0..comment_pos]
+    stripped = left_of_comment.rstrip
+    return false if stripped.empty?
+    padding_size = left_of_comment.size - stripped.size
+    return spacing != padding_size
+  end
+
+  def fix
+    comment_token = find_token(:on_comment)
+    comment_pos = comment_token.col - 1
+    left_of_comment = line[0..comment_pos].rstrip
+    left_of_comment + (' ' * spacing) + comment_token.body
+  end
+
+  def spacing
+    @settings[OPTION_KEY] || DEFAULT_SPACE
+  end
+end

data/lib/wool/warnings/extra_blank_lines.rb

@@ -0,0 +1,29 @@
+  # Warning for using semicolons outside of class declarations.
+class Wool::ExtraBlankLinesWarning < Wool::FileWarning
+  EXTRA_LINE = /\n[\t ]*\Z/
+  type :style
+  severity 1
+  short_desc 'Extra blank lines'
+  desc { "This file has #{count_extra_lines} blank lines at the end of it." }
+
+  def match?(body = self.body)
+    body =~ EXTRA_LINE
+  end
+
+  def fix
+    body.gsub(/\s*\Z/, '')
+  end
+
+  # Counts how many extra lines there are at the end of the file.
+  def count_extra_lines
+    # We use this logic because #lines ignores blank lines at the end, and
+    # split(/\n/) does as well.
+    count = 0
+    working_body = self.body.dup
+    while working_body =~ EXTRA_LINE
+      working_body.sub!(EXTRA_LINE, '')
+      count += 1
+    end
+    count
+  end
+end

data/lib/wool/warnings/extra_whitespace.rb

@@ -0,0 +1,15 @@
+# Warning for having extra space at the end of a line.
+class Wool::ExtraWhitespaceWarning < Wool::LineWarning
+  type :style
+  severity 2
+  short_desc 'Extra Whitespace'
+  desc 'The line has trailing whitespace.'
+
+  def match?(body = self.body)
+    /\s+$/ === line
+  end
+
+  def fix
+    self.line.gsub(/\s+$/, '')
+  end
+end

data/lib/wool/warnings/line_length.rb

@@ -0,0 +1,113 @@
+class Wool::GenericLineLengthWarning < Wool::LineWarning
+  cattr_accessor_with_default :line_length_limit, 80000
+  type :style
+  short_desc 'Line too long'
+  desc { "Line length: #{line.size} > #{self.class.line_length_limit} (max)" }
+
+  def self.inspect
+    "Wool::GenericLineLengthWarning<#{line_length_limit}>"
+  end
+
+  def match?(body = self.body)
+    !!(line.rstrip.size > self.class.line_length_limit)
+  end
+
+  def fix(content_stack = nil)
+    result = handle_long_comments(self.line)
+    return result if result
+    result = try_to_fix_guarded_lines(self.line)
+    return result if result
+    self.line
+  end
+
+  def try_to_fix_guarded_lines(line)
+    return nil if line !~ /\b(if|unless)\s/  # quick fast check
+    code, guard = split_on_keyword(:if, :unless)
+    code.rstrip!
+    return nil if code.empty? || guard.empty? || code.strip == 'end'
+    # check guard for closing braces
+    return nil if count_occurrences(guard, '}') != count_occurrences(guard, '{')
+    indent = get_indent(line)
+    indent_unit = ' ' * @settings[:indent_size]
+
+    result = code
+    until guard.empty?
+      condition = indent + guard.strip
+      body = result.split(/\n/).map { |line| indent_unit + line}.join("\n")
+      new_condition, guard = split_on_keyword(condition[indent.size+1..-1], :if, :unless)
+      if new_condition.empty?
+        new_condition, guard = guard.rstrip, ''
+      else
+        new_condition = "#{condition[indent.size,1]}#{new_condition.rstrip}"
+      end
+      condition = indent + new_condition unless guard.empty?
+      result = condition + "\n" + body + "\n" + indent + 'end'
+    end
+
+    result
+  end
+
+  def handle_long_comments(line)
+    code, comment = split_on_token(line, :on_comment)
+    return nil if comment.empty?
+    indent, code = code.match(/^(\s*)(.*)$/)[1..2]
+    hashes, comment = comment.match(/^(#+\s*)(.*)$/)[1..2]
+    comment_cleaned = fix_long_comment(indent + hashes + comment)
+    code_cleaned = !code.strip.empty? ? "\n" + indent + code.rstrip : ''
+    comment_cleaned + code_cleaned
+  end
+
+  def fix_long_comment(text)
+    # Must have no leading text
+    return nil unless text =~ /^(\s*)(#+\s*)(.*)\Z/
+    indent, hashes, comment = $1, $2, $3
+    indent_size = indent.size
+    # The "+ 2" is (indent)#(single space)
+    space_for_text_per_line = self.class.line_length_limit - (indent_size + hashes.size)
+    lines = ['']
+    words = comment.split(/\s/)
+    quota = space_for_text_per_line
+    current_line = 0
+    while words.any?
+      word = words.shift
+      # break on word big enough to make a new line, unless its the first word
+      if quota - (word.size + 1) < 0 && quota < space_for_text_per_line
+        current_line += 1
+        lines << ''
+        quota = space_for_text_per_line
+      end
+      unless lines[current_line].empty?
+        lines[current_line] << ' '
+        quota -= 1
+      end
+      lines[current_line] << word
+      quota -= word.size
+    end
+    lines.map { |line| indent + hashes + line }.join("\n")
+  end
+end
+
+module Wool
+  def LineLengthCustomSeverity(size, severity)
+    Wool.class_eval do
+      if const_defined?("GenericLineLengthWarning_#{size}_#{severity}")
+        return const_get("GenericLineLengthWarning_#{size}_#{severity}")
+      end
+      new_warning = Class.new(Wool::GenericLineLengthWarning)
+      const_set("GenericLineLengthWarning_#{size}_#{severity}", new_warning)
+      new_warning.line_length_limit = size
+      new_warning.severity = severity
+      new_warning.desc = Wool::GenericLineLengthWarning.desc
+      new_warning
+    end
+  end
+
+  def LineLengthMaximum(size)
+    (@table ||= {})[size] ||= LineLengthCustomSeverity(size, 8)
+  end
+
+  def LineLengthWarning(size)
+    (@table ||= {})[size] ||= LineLengthCustomSeverity(size, 3)
+  end
+  module_function :LineLengthMaximum, :LineLengthWarning, :LineLengthCustomSeverity
+end

data/lib/wool/warnings/misaligned_unindentation.rb

@@ -0,0 +1,16 @@
+# This warning is used when
+class Wool::MisalignedUnindentationWarning < Wool::LineWarning
+  type :style
+  severity 2
+  short_desc 'Misaligned Unindentation'
+  desc { "Expected #{@expectation} spaces, but instead found #{get_indent.size}" }
+
+  def initialize(file, line, expectation)
+    super(file, line)
+    @expectation = expectation
+  end
+
+  def fix
+    indent self.line, @expectation
+  end
+end

data/lib/wool/warnings/operator_spacing.rb

@@ -0,0 +1,63 @@
+# Warning for not putting space around operators
+class Wool::OperatorSpacing < Wool::LineWarning
+  include Wool::Advice::CommentAdvice
+  OPERATORS = %w(+ - / * != !== = == === ~= !~ += -= *= /= ** **= ||= || && &&= &= |= | & ^)
+
+  type :style
+  severity 5
+  short_desc 'No operator spacing'
+  desc { "Insufficient spacing around #{self.match?(self.line).body}" }
+
+  def match?(line = self.body)
+    working_line = ignore_block_params line
+    working_line = ignore_splat_args working_line
+    working_line = ignore_to_proc_args working_line
+    working_line = ignore_array_splat_idiom working_line
+    lexed = lex(working_line)
+    lexed.each_with_index do |token, idx|
+      next unless token.type == :on_op
+      next if idx == lexed.size - 1  # Last token on line (continuation) is ok
+      next if token.body == '-' && [:on_float, :on_int].include?(lexed[idx+1].type)
+      return token if lexed[idx+1].type != :on_sp && lexed[idx+1].type != :on_op
+      return token if idx > 0 && ![:on_sp, :on_op].include?(lexed[idx-1].type)
+    end
+    nil
+  end
+  
+  def generated_warnings(*args)
+    match?(*args) ? [self] : []
+  end
+
+  def ignore_block_params(line)
+    line.gsub(/(\{|(do))\s*\|.*\|/, '\1')
+  end
+
+  def ignore_splat_args(line)
+    line.gsub(/(\(|(, ))\&([a-z][A-Za-z0-9_]*)((, )|\)|\Z)/, '\1')
+  end
+
+  def ignore_array_splat_idiom(line)
+    line.gsub(/\[\*([a-z][A-Za-z0-9_]*)\]/, '\1')
+  end
+
+  def ignore_to_proc_args(line)
+    line.gsub(/(\(|(, ))\*([a-z][A-Za-z0-9_]*)((, )|\)|\Z)/, '\1')
+  end
+
+  def is_block_line?(line)
+    line =~ /do\s*\|/ || line =~ /\{\s*\|/
+  end
+
+  def fix
+    line = self.line.dup
+    OPERATORS.each do |op|
+      next if op == '==' && line =~ /!==/
+      next if op == '=' && line =~ /!=/
+      next if op == '|' && self.is_block_line?(line)
+      embed = op.gsub(/(\+|\-|\*|\||\^)/, '\\\\\\1')
+      line.gsub!(/([A-Za-z0-9_]!|[A-Za-z0-9_?])(#{embed})/, '\1 \2')
+      line.gsub!(/(#{embed})([$A-Za-z0-9_?!])/, '\1 \2')
+    end
+    line
+  end
+end

data/lib/wool/warnings/rescue_exception.rb

@@ -0,0 +1,41 @@
+# Warning for rescuing "Exception" or "Object".
+class Wool::RescueExceptionWarning < Wool::FileWarning
+  severity 5
+  type :dangerous
+  short_desc 'rescue Exception is dangerous'
+  desc 'The line rescues "Exception" or "Object", which is too broad. Rescue StandardError instead.'
+  setting_accessor :position
+
+  def match?(file = self.body)
+    find_sexps(:rescue).map do |_, types, name|
+      case types[0]
+      when :mrhs_new_from_args
+        list = types[1] + types[2..-1]
+      when Array
+        list = types
+      end
+      list.map do |type|
+        if type[0] == :var_ref &&
+           type[1][0] == :@const && type[1][1] == "Exception"
+          warning = RescueExceptionWarning.new(file, body, :position => type[1][2])
+          warning.position[0] -= 1
+          warning.line_number = type[1][2][1]
+          warning
+        end
+      end.compact
+    end.flatten
+  end
+
+  def fix
+    result = ""
+    all_lines = self.body.lines.to_a
+    result << all_lines[0..position[0]-1].join if position[0]-1 >= 0
+    result << all_lines[position[0]][0,position[1]]
+    result << 'StandardError'
+    if trailing = all_lines[position[0]][position[1] + 'Exception'.size .. -1]
+      result << trailing
+    end
+    result << all_lines[position[0]+1..-1].join if position[0]+1 < all_lines.size
+    result
+  end
+end