laser 0.7.0.pre1

data/lib/laser/warning_sets/default.yml

@@ -0,0 +1,13 @@
+---
+- "AssignmentInConditionWarning"
+- "InlineCommentSpaceWarning"
+- "ExtraBlankLinesWarning"
+- "ExtraWhitespaceWarning"
+- "MisalignedUnindentationWarning"
+- "OperatorSpacing"
+- "ParensOnDeclarationWarning"
+- "RescueExceptionWarning"
+- "SemicolonWarning"
+- "UselessDoubleQuotesWarning"
+- "HashSymbol19Warning"
+- "SexpErrorWarning"

data/lib/laser/warnings/assignment_in_condition.rb

@@ -0,0 +1,20 @@
+# Warning for not having parens in a method declaration with arguments
+class Laser::AssignmentInConditionWarning < Laser::FileWarning
+  type :gotcha
+  severity 3
+  short_desc 'Assignment in condition not in parentheses'
+  
+  def match?(body = self.body)
+    to_search = find_sexps(:if) + find_sexps(:unless) + find_sexps(:elsif)
+    to_search.map do |sym, condition, _, _|
+      assignments = find_sexps(:assign, condition)
+      assignments.reject do |node|
+        ancestors = node.ancestors.map(&:type)
+        path_to_node = ancestors[ancestors.rindex(sym)..-1]
+        path_to_node.include?(:paren)
+      end
+    end.compact.flatten.map do |node|
+      Laser::AssignmentInConditionWarning.new(file, body)
+    end
+  end
+end

data/lib/laser/warnings/comment_spacing.rb

@@ -0,0 +1,31 @@
+# Warning for insufficient space between inline comments and code
+class Laser::InlineCommentSpaceWarning < Laser::LineWarning
+  OPTION_KEY = :inline_comment_space
+  DEFAULT_SPACE = 2
+  type :style
+  short_desc 'Inline comment spacing error'
+  desc { "Inline comments must be exactly #{@settings[OPTION_KEY]} spaces from code." }
+  opt OPTION_KEY, 'Number of spaces between code and inline comments', default: DEFAULT_SPACE
+  fixable true
+
+  def match?(line = self.body)
+    return false unless comment_token = find_token(:on_comment)
+    left_of_comment = line[0,comment_token.col].lstrip
+    return false if left_of_comment[0,1] == '#'
+    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/laser/warnings/extra_blank_lines.rb

@@ -0,0 +1,30 @@
+  # Warning for using semicolons outside of class declarations.
+class Laser::ExtraBlankLinesWarning < Laser::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." }
+  fixable true
+
+  def match?(body = self.body)
+    body =~ EXTRA_LINE
+  end
+
+  def fix(body = self.body)
+    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/laser/warnings/extra_whitespace.rb

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

data/lib/laser/warnings/hash_symbol_18_warning.rb

@@ -0,0 +1,63 @@
+# Warning for rescuing "Exception" or "Object".
+class Laser::HashSymbol18Warning < Laser::FileWarning
+  severity 1
+  type :style
+  short_desc 'symbol hash key in 1.8 style'
+  desc { "The Hash key :#{tokens[1][1]} is used in a Hash literal in 1.8 style." }
+  fixable true
+  setting_accessor :tokens
+  setting_accessor :line_adjustments
+  
+  MATCH_18 = ObjectRegex.new('symbeg (ident | kw) sp? hashrocket')
+
+  # Must implement reg_desc slightly differently from LexicalAnalysis::Token
+  HS18Token = Struct.new(:type, :body, :line, :col) do
+    # Unpacks the token from Ripper and breaks it into its separate components.
+    #
+    # @param [Array<Array<Integer, Integer>, Symbol, String>] token the token
+    #     from Ripper that we're wrapping
+    def initialize(token)
+      (self.line, self.col), self.type, self.body = token
+    end
+    
+    def width
+      body.size
+    end
+    
+    def reg_desc
+      if type == :on_op && body == '=>'
+        'hashrocket'
+      else
+        type.to_s.sub(/^on_/, '')
+      end
+    end
+  end
+
+  def match?(body = self.body)
+    tokens = lex(body, HS18Token)
+    matches = MATCH_18.all_matches(tokens)
+    line_adjustments = Hash.new(0)
+    matches.map do |match_tokens|
+      result = Laser::HashSymbol18Warning.new(file, body,
+          tokens: match_tokens,
+          line_adjustments: line_adjustments)
+      result.line_number = match_tokens[0].line
+      result
+    end
+  end
+
+  def fix(body = self.body)
+    lines = body.lines.to_a  # eagerly expand lines
+    symbeg, ident, *spacing_and_comments, rocket = tokens
+    lines[symbeg.line - 1][symbeg.col + line_adjustments[symbeg.line],1] = ''
+    lines[ident.line - 1].insert(ident.col + line_adjustments[ident.line] + ident.width - 1, ':')
+    lines[rocket.line - 1][rocket.col + line_adjustments[rocket.line],2] = ''
+    if spacing_and_comments.last != nil && spacing_and_comments.last.type == :on_sp
+      lines[rocket.line - 1][rocket.col + line_adjustments[rocket.line] - 1,1] = ''
+      line_adjustments[rocket.line] -= 3  # chomped " =>"
+    else
+      line_adjustments[rocket.line] -= 2  # only chomped the "=>"
+    end
+    lines.join
+  end
+end

data/lib/laser/warnings/hash_symbol_19_warning.rb

@@ -0,0 +1,29 @@
+# Warning for rescuing "Exception" or "Object".
+class Laser::HashSymbol19Warning < Laser::FileWarning
+  severity 1
+  type :style
+  short_desc 'symbol hash key in 1.9 style'
+  desc { "The Hash key #{token[1]} is used in a Hash literal in 1.9 style." }
+  fixable true
+  setting_accessor :token
+  setting_accessor :line_adjustments
+
+  def match?(body = self.body)
+    line_adjustments = Hash.new(0)
+    lex.map do |token|
+      if token.type == :on_label
+        Laser::HashSymbol19Warning.new(file, body,
+            token: token,
+            line_adjustments: line_adjustments)
+      end
+    end.compact
+  end
+
+  def fix(body = self.body)
+    lines = body.lines.to_a  # eagerly expand lines
+    label = token
+    lines[label.line - 1][label.col + line_adjustments[label.line],label.body.size] = ":#{label.body[0..-2]} =>"
+    line_adjustments[label.line] += 3  # " =>" is inserted and is 3 chars
+    lines.join
+  end
+end

data/lib/laser/warnings/line_length.rb

@@ -0,0 +1,115 @@
+class Laser::GenericLineLengthWarning < Laser::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)" }
+  fixable true
+
+  def self.inspect
+    "Laser::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 Laser
+  def LineLengthCustomSeverity(size, severity)
+    Laser.class_eval do
+      if const_defined?("GenericLineLengthWarning_#{size}_#{severity}")
+        return const_get("GenericLineLengthWarning_#{size}_#{severity}")
+      end
+      new_warning = Class.new(Laser::GenericLineLengthWarning)
+      const_set("GenericLineLengthWarning_#{size}_#{severity}", new_warning)
+      new_warning.line_length_limit = size
+      new_warning.severity = severity
+      new_warning.desc = Laser::GenericLineLengthWarning.desc
+	  new_warning.type(Laser::GenericLineLengthWarning.type)
+      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/laser/warnings/misaligned_unindentation.rb

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

data/lib/laser/warnings/operator_spacing.rb

@@ -0,0 +1,68 @@
+# Warning for not putting space around operators
+class Laser::OperatorSpacing < Laser::LineWarning
+  OPERATORS = %w(+ - / * != !== = == === ~= !~ += -= *= /= ** **= ||= || && &&= &= |= | & ^)
+
+  type :style
+  severity 5
+  short_desc 'No operator spacing'
+  desc { "Insufficient spacing around #{self.match?(self.line).body}" }
+  fixable true
+
+  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 token.body == '::' || token.body[0,2] == '..'
+      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)
+      if token.body == '&' && (idx == 0 || [:on_sp, :on_lparen, :on_comma].include?(lexed[idx-1].type))
+        next if [:on_lparen, :on_comma, :on_sp].include?(lexed[idx+1].type) || 
+                (lexed[idx+2] && [:on_rparen, :on_comma].include?(lexed[idx+2].type))
+      end
+      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/laser/warnings/parens_on_declaration.rb

@@ -0,0 +1,30 @@
+# Warning for not having parens in a method declaration with arguments
+class Laser::ParensOnDeclarationWarning < Laser::FileWarning
+  type :style
+  severity 1
+  short_desc 'Missing parentheses in method declaration'
+  setting_accessor :method_name
+  desc do
+    "The method #{method_name} should have its arguments wrapped in parentheses."
+  end
+  
+  def match?(body = self.body)
+    def_list = find_sexps(:def).select do |sym, name, args, body|
+      case args.type
+      when :params then args.children.any?
+      when :paren then !args[1].children.any?
+      end
+    end.map do |sym, name, args, body|
+      Laser::ParensOnDeclarationWarning.new(file, body, method_name: name[1])
+    end
+    sdef_list = find_sexps(:defs).select do |sym, target, op, name, args, body|
+      case args.type
+      when :params then args.children.any?
+      when :paren then !args[1].children.any?
+      end
+    end.map do |sym, target, op, name, args, body|
+      Laser::ParensOnDeclarationWarning.new(file, body, method_name: name[1])
+    end
+    def_list + sdef_list
+  end
+end