laser 0.7.0.pre1

data/lib/laser/warnings/rescue_exception.rb

@@ -0,0 +1,42 @@
+# Warning for rescuing "Exception" or "Object".
+class Laser::RescueExceptionWarning < Laser::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
+  fixable true
+
+  def match?(body = 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 = Laser::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(body = self.body)
+    result = ""
+    all_lines = 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

data/lib/laser/warnings/semicolon.rb

@@ -0,0 +1,25 @@
+# Warning for using semicolons outside of class declarations.
+class Laser::SemicolonWarning < Laser::LineWarning
+  type :style
+  short_desc 'Semicolon for multiple statements'
+  desc 'The line uses a semicolon to separate multiple statements outside of a class declaration.'
+  fixable true
+
+  def initialize(*args)
+    super
+    self.severity = line =~ /['"]/ ? 2 : 4
+  end
+
+  def match?(line = self.body)
+    !!(find_token(line, :on_semicolon) && !find_keyword(line, :class))
+  end
+
+  def fix(line = self.body)
+    left, right = split_on_token(line, :on_semicolon)
+    return line if right.empty?
+    return right[1..-1] if left.empty?
+
+    right = fix(right[1..-1])
+    "#{indent left}\n#{indent right}"
+  end
+end

data/lib/laser/warnings/sexp_errors.rb

@@ -0,0 +1,24 @@
+class Laser::SexpErrorWarning < Laser::FileWarning
+  type :dangerous
+  short_desc "Error"
+  desc { error.message }
+  setting_accessor :error
+
+  def line_number
+    error.ast_node.line_number
+  end
+  
+  def severity
+    error.severity
+  end
+
+  def ==(other)
+    super && self.error == other.error
+  end
+
+  def match?(body = self.body)
+    parse.all_errors.map do |error|
+      Laser::SexpErrorWarning.new(error.ast_node.file_name, body, error: error)
+    end
+  end
+end

data/lib/laser/warnings/uncalled_method_warning.rb

@@ -0,0 +1,7 @@
+# Warning for methods that are not called, ever.
+class Laser::UncalledMethodWarning < Laser::FileWarning
+	type :dangerous
+  short_desc "Unused method"
+  desc { "The method #{method.owner.name}##{method.name} is never called." }
+  setting_accessor :method
+end

data/lib/laser/warnings/useless_double_quotes.rb

@@ -0,0 +1,38 @@
+# Warning for using semicolons outside of class declarations.
+class Laser::UselessDoubleQuotesWarning < Laser::FileWarning
+  type :style
+  severity 1
+  short_desc 'Useless double quotes'
+  fixable true
+  setting_accessor :quoted_string, :uses_q_braces
+  desc do
+    if uses_q_braces
+    then "The string %q{#{quoted_string}} can be written with lowercase q for efficiency."
+    else "The string '#{quoted_string}' can be wrapped in single quotes for efficiency."
+    end
+  end
+  
+  def match?(body = self.body)
+    list = find_sexps(:string_content)
+    list.map do |sym, *parts|
+      next if parts.size != 1  # ignore multiparts as they're fine
+      inner_sym, text, pos = parts.first
+      # skip if the string has a backslash or an apostrophe in it.
+      next unless inner_sym == :@tstring_content && text !~ /(\\)|(')/
+      
+      previous_char = body.lines.to_a[pos[0] - 1][pos[1]-1,1]
+      uses_q_braces = (previous_char == '{' && body.lines.to_a[pos[0] - 1][pos[1]-3,2] == '%Q')
+      if previous_char == '"' || uses_q_braces
+        warning = Laser::UselessDoubleQuotesWarning.new(
+            file, body, quoted_string: text, uses_q_braces: uses_q_braces)
+        warning.line_number = pos[0]
+        warning
+      end
+    end.compact
+  end
+
+  def fix(body = self.body)
+    body.gsub("\"#{quoted_string}\"", "'#{quoted_string}'").
+         gsub("%Q{#{quoted_string}}", "%q{#{quoted_string}}")
+  end
+end

data/spec/analysis_specs/annotations_spec.rb

@@ -0,0 +1,47 @@
+require_relative 'spec_helper'
+
+describe BasicAnnotation do
+  before(:each) do
+    @global_annotations = Annotations.global_annotations.dup
+    Annotations.global_annotations = []
+    @class = Class.new(BasicAnnotation) do
+      def annotate!(node)
+        node[0] = (node[0].to_s + 'lolz').intern
+      end
+    end
+  end
+
+  after(:each) do
+    Annotations.global_annotations.replace @global_annotations
+  end
+
+  describe '#add_global_annotator' do
+    it 'adds the given argument to the list of global annotations' do
+      foo = Class.new
+      @class.add_global_annotator foo
+      Annotations.global_annotations.last.should be_a(foo)
+    end
+  end
+  
+  describe '#add_property' do
+    selectors = [:aaa, :aaa=, :bbb, :bbb=]
+    it 'adds accessors to Analysis::Sexp in a very intrusive manner' do
+      @class.add_property :aaa, :bbb
+      sexp = Sexp.new([:program, []])
+      selectors.each {|sel| sexp.should respond_to(sel)}
+    end
+    after do
+      selectors.each {|sel| Sexp.__send__(:undef_method, sel)}
+    end
+  end
+  
+  describe '#add_computed_property' do
+    it 'adds a no-arg method that computes a property' do
+      @class.add_computed_property(:childsize) { self.children.size }
+      @class.add_global_annotator(@class)
+      sexp = Sexp.new([:abc, :cde, :aaa, :bbb, [:hi, 1, 2]])
+      sexp.childsize.should == 4
+      sexp.children[3].childsize.should == 2
+    end
+  end
+end

data/spec/analysis_specs/annotations_specs/comment_attachment_spec.rb

@@ -0,0 +1,68 @@
+require_relative 'spec_helper'
+describe CommentAttachmentAnnotation do
+  extend AnalysisHelpers
+  clean_registry
+  
+  it_should_behave_like 'an annotator'
+  
+  it 'adds the #docstring method to Sexp' do
+    Sexp.instance_methods.should include(:comment)
+  end
+  
+  # [:program,
+  # [[:def,
+  #   [:@ident, "silly", [3, 4]],
+  #   [:paren,
+  #    [:params,
+  #     [[:@ident, "a", [3, 10]], [:@ident, "b", [3, 13]]],
+  #     nil,
+  #     nil,
+  #     nil,
+  #     nil]],
+  #   [:bodystmt, [[:void_stmt]], nil, nil, nil]],
+  #  [:class,
+  #   [:const_ref, [:@const, "A", [6, 7]]],
+  #   nil,
+  #   [:bodystmt, [[:void_stmt]], nil, nil, nil]]]]
+  it 'discovers the comments before a method and class declaration' do
+    input = "  # abc\n  #  def\ndef silly(a, b)\n end\n # a class\n class A990; end"
+    tree = annotate_all(input)
+    list = tree[1]
+    
+    defn = list[0]
+    defn.comment.body.should == " abc\n  def"
+    klass_defn = list[1]
+    klass_defn.comment.body.should == " a class"
+  end
+  
+  # [:program,
+  #  [[:def,
+  #    [:@ident, "some_method", [3, 6]],
+  #    [:paren, [:params, [[:@ident, "abc", [3, 18]]], nil, nil, nil, nil]],
+  #    [:bodystmt,
+  #     [[:assign,
+  #       [:var_field, [:@ident, "y", [5, 4]]],
+  #       [:binary,
+  #        [:var_ref, [:@ident, "abc", [5, 8]]],
+  #        :*,
+  #        [:@int, "2", [5, 14]]]]],
+  #     nil, nil, nil]]]]
+  
+  it 'discovers comments before introduction of a new local variable' do
+    input = <<-EOF
+  # some method
+  # abc: String
+  def some_method(abc)
+    # y: String
+    y = abc * 2
+  end
+EOF
+    tree = annotate_all(input)
+
+    list = tree[1]
+    defn = list[0]
+    defn.comment.body.should == " some method\n abc: String"
+    assignment = defn[3][1][0]
+    assignment.comment.body.should == " y: String"
+  end
+end

data/spec/analysis_specs/annotations_specs/node_pointers_annotation_spec.rb

@@ -0,0 +1,90 @@
+require_relative 'spec_helper'
+require 'set'
+describe NodePointersAnnotation do
+  it_should_behave_like 'an annotator'
+  
+  it 'adds the #parent method to Sexp' do
+    Sexp.instance_methods.should include(:parent)
+  end
+  
+  it 'adds parents to each node with a toy example' do
+    tree = Sexp.new([:abc, Sexp.new([:def, 1, 2]),
+                    Sexp.new([:zzz, Sexp.new([:return]),  "hi", Sexp.new([:silly, 4])])])
+    NodePointersAnnotation.new.annotate!(tree)
+    expectalot(parent: { nil => [tree], tree => [tree[1], tree[2]],
+                            tree[2] => [tree[2][1], tree[2][3]] } )
+  end
+  
+  # This will actually verify that every node in the tree has a
+  # proper parent set. It's a complex, but thorough test.
+  it 'adds parents to each node with a real-world parse result' do
+    tree = Sexp.new(Ripper.sexp('x = proc {|x, *rst, &blk| p x ** rst[0]; blk.call(rst[1..-1])}'))
+    NodePointersAnnotation.new.annotate!(tree)
+    expectalot(parent: { nil => [tree], tree => [tree.children.first] })
+    tree.all_subtrees.each do |node|
+      node.parent.children.should include(node)
+    end
+  end
+
+  it 'adds the #ancestors method to Sexp' do
+    Sexp.instance_methods.should include(:ancestors)
+  end
+  
+  it 'adds ancestors to each node with a toy example' do
+    tree = Sexp.new([:abc, Sexp.new([:def, 1, 2]),
+                    Sexp.new([:zzz, Sexp.new([:return]), 'hi', Sexp.new([:silly, 4])])])
+    NodePointersAnnotation.new.annotate!(tree)
+    expectalot(ancestors: { [] => [tree], [tree] => [tree[1], tree[2]],
+                            [tree, tree[2]] => [tree[2][1], tree[2][3]] } )
+  end
+  
+  it 'adds the #root method to Sexp' do
+    Sexp.instance_methods.should include(:root)
+  end
+  
+  it 'can compute the root from any node in the tree' do
+    tree = Sexp.new(Ripper.sexp('x = proc {|x, *rst, &blk| p x ** rst[0]; blk.call(rst[1..-1])}'))
+    NodePointersAnnotation.new.annotate!(tree)
+    tree.dfs { |node| node.root.should be tree }
+  end
+  
+  # This will actually verify that every node in the tree has a
+  # proper parent set. It's a complex, but thorough test.
+  it 'adds parents to each node with a real-world parse result' do
+    tree = Sexp.new(Ripper.sexp('x = proc {|x, *rst, &blk| p x ** rst[0]; blk.call(rst[1..-1])}'))
+    NodePointersAnnotation.new.annotate!(tree)
+    expectalot(parent: { nil => [tree], tree => [tree.children.first] })
+    tree.all_subtrees.each do |node|
+      if node.parent
+        node.ancestors.should include(node.parent)
+        (node.ancestors & node.parent.ancestors).should == node.parent.ancestors
+      end
+    end
+  end
+  
+  it 'adds the #next and #prev methods to Sexp' do
+    Sexp.instance_methods.should include(:next)
+    Sexp.instance_methods.should include(:prev)
+  end
+  
+  it 'adds next and prevs to each node with a toy example' do
+    tree = Sexp.new([:abc, Sexp.new([:def, 1, 2]),
+                    Sexp.new([:zzz, Sexp.new([:return]), "hi", Sexp.new([:silly, 4])])])
+    NodePointersAnnotation.new.annotate!(tree)
+    expectalot(prev: { nil => [tree[1], tree[2][1]], tree[1] => [tree[2]], tree[2][2] => [tree[2][3]] },
+               next: { nil => [tree[2], tree[2][3]], tree[2] => [tree[1]], tree[2][2] => [tree[2][1]] })
+  end
+  
+  # This will actually verify that every node in the tree has a
+  # proper parent set. It's a complex, but thorough test.
+  it 'adds next and prevs to each node with a real-world parse result' do
+    tree = Sexp.new(Ripper.sexp('x = proc {|x, *rst, &blk| p x ** rst[0]; blk.call(rst[1..-1])}'))
+    NodePointersAnnotation.new.annotate!(tree)
+    expectalot(next: { nil => [tree] }, prev: { nil => [tree] })
+    visited = Set.new
+    tree.all_subtrees.each do |node|
+      node.prev.next.should == node if node.is_sexp?(node.prev)
+      node.next.prev.should == node if node.is_sexp?(node.next)
+    end
+  end
+end

data/spec/analysis_specs/annotations_specs/runtime_annotation_spec.rb

@@ -0,0 +1,135 @@
+require_relative 'spec_helper'
+require 'set'
+describe RuntimeAnnotation do
+  it_should_behave_like 'an annotator'
+  
+  it 'adds the #runtime method to Sexp' do
+    Sexp.instance_methods.should include(:runtime)
+  end
+
+  # [:program,
+  #  [[:assign,
+  #    [:var_field, [:@ident, "abc", [1, 0]]],
+  #    [:var_ref, [:@const, "ABC", [1, 6]]]]]]
+  it 'handles nested module/class declarations' do
+    input = 'module A; module B; class C; end; class D < C; end; end; end'
+    tree = Sexp.new(Ripper.sexp(input))
+    RuntimeAnnotation.new.annotate_with_text(tree, input)
+    tree.all_subtrees.each { |subtree| subtree.runtime.should == :load }
+  end
+  
+  # [:program,
+  #  [[:module,
+  #    [:const_ref, [:@const, "A", [1, 7]]],
+  #    [:bodystmt,
+  #     [[:void_stmt],
+  #      [:module,
+  #       [:const_ref, [:@const, "B", [1, 17]]],
+  #       [:bodystmt,
+  #        [[:void_stmt],
+  #         [:def,
+  #          [:@ident, "abc", [1, 24]],
+  #          [:paren,
+  #           [:params,
+  #            [[:@ident, "xyz", [1, 28]]],
+  #            [[[:@ident, "jkl", [1, 33]],
+  #              [:binary,
+  #               [:var_ref, [:@ident, "xyz", [1, 37]]],
+  #               :*,
+  #               [:@int, "2", [1, 41]]]]],
+  #            nil, nil, nil]],
+  #          [:bodystmt,
+  #           [[:void_stmt],
+  #            [:command,
+  #             [:@ident, "p", [1, 45]],
+  #             [:args_add_block, [[:var_ref, [:@ident, "xyz", [1, 47]]]], false]],
+  #            [:def,
+  #             [:@ident, "another", [1, 56]],
+  #             [:params, nil, nil, nil, nil, nil],
+  #             [:bodystmt, [[:void_stmt]], nil, nil, nil]]],
+  #           nil, nil, nil]]],
+  #        nil, nil, nil]]],
+  #     nil, nil, nil]]]]
+  it 'handles regular method definitions' do
+    input = 'module A; module B; def abc(xyz, jkl=xyz*2); p xyz; def another; end; end; end; end'
+    tree = Sexp.new(Ripper.sexp(input))
+    RuntimeAnnotation.new.annotate_with_text(tree, input)
+    mod_a = tree[1][0]
+    mod_b = mod_a[2][1][1]
+    defn = mod_b[2][1][1]
+    expectalot(:runtime => {
+                 :load => [tree, tree[1], mod_a, mod_a[1], mod_a[2], mod_a[2][1],
+                          mod_a[2][1][0], mod_b, mod_b[1], mod_b[1][1], defn, defn[1]],
+                 :run => [*defn[2].all_subtrees, *defn[3].all_subtrees]
+               })
+  end
+  
+  # [:program,
+  #  [[:module,
+  #    [:const_ref, [:@const, "A", [1, 7]]],
+  #    [:bodystmt,
+  #     [[:void_stmt],
+  #      [:method_add_block,
+  #       [:call,
+  #        [[:@tstring_content, "a,", [1, 13]], [:@tstring_content, "b", [1, 16]]],
+  #        :".",
+  #        [:@ident, "each", [1, 19]]],
+  #       [:brace_block,
+  #        [:block_var,
+  #         [:params, [[:@ident, "x", [1, 26]]], nil, nil, nil, nil],
+  #         nil],
+  #        [[:method_add_block,
+  #          [:method_add_arg,
+  #           [:fcall, [:@ident, "define_method", [1, 29]]],
+  #           [:arg_paren,
+  #            [:args_add_block, [[:var_ref, [:@ident, "x", [1, 43]]]], false]]],
+  #          [:do_block,
+  #           nil,
+  #           [[:void_stmt], [:var_ref, [:@ident, "x", [1, 50]]]]]]]]]],
+  #     nil, nil, nil]]]]
+  
+  it 'gives up on blocks that are captured at load-time' do
+    # not unrealistic code! Sometime we need to know this executes at load-time!
+    input = 'module A; %w(a b).each {|x| define_method(x) do; x; end}; end'
+    tree = Sexp.new(Ripper.sexp(input))
+    RuntimeAnnotation.new.annotate_with_text(tree, input)
+    mod_a = tree[1][0]
+    mab_node = mod_a[2][1][1]
+    expectalot(:runtime => {
+                 :load => [tree, tree[1], mod_a, mod_a[1], mod_a[2], mod_a[2][1],
+                           mab_node, mab_node[1]],
+                 :unknown => mab_node[2].all_subtrees
+               })
+  end
+  
+  # [:program,
+  #  [[:def,
+  #    [:@ident, "k", [1, 4]],
+  #    [:params, nil, nil, nil, nil, nil],
+  #    [:bodystmt,
+  #     [[:method_add_block,
+  #       [:call,
+  #        [[:@tstring_content, "a", [1, 10]], [:@tstring_content, "b", [1, 12]]],
+  #        :".",
+  #        [:@ident, "each", [1, 15]]],
+  #       [:brace_block,
+  #        [:block_var,
+  #         [:params, [[:@ident, "x", [1, 22]]], nil, nil, nil, nil],
+  #         nil],
+  #        [[:method_add_block,
+  #          [:method_add_arg,
+  #           [:fcall, [:@ident, "define_method", [1, 25]]],
+  #           [:arg_paren,
+  #            [:args_add_block, [[:var_ref, [:@ident, "x", [1, 39]]]], false]]],
+  #          [:do_block,
+  #           nil,
+  #           [[:void_stmt], [:var_ref, [:@ident, "x", [1, 46]]]]]]]]]],
+  #     nil, nil, nil]]]]
+  it 'knows blocks captured at run-time retain run-time status' do
+    input = 'def k; %w(a b).each {|x| define_method(x) do; x; end}; end'
+    tree = Sexp.new(Ripper.sexp(input))
+    RuntimeAnnotation.new.annotate_with_text(tree, input)
+    defn = tree[1][0]
+    expectalot(:runtime => { :run => defn[3].all_subtrees })
+  end
+end