wool 0.5.1

data/lib/wool/warnings/semicolon.rb

@@ -0,0 +1,24 @@
+# Warning for using semicolons outside of class declarations.
+class Wool::SemicolonWarning < Wool::LineWarning
+  type :style
+  short_desc 'Semicolon for multiple statements'
+  desc 'The line uses a semicolon to separate multiple statements outside of a class declaration.'
+
+  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/wool/warnings/useless_double_quotes.rb

@@ -0,0 +1,37 @@
+  # Warning for using semicolons outside of class declarations.
+class Wool::UselessDoubleQuotesWarning < Wool::FileWarning
+  type :style
+  severity 1
+  short_desc 'Useless double quotes'
+  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 = Wool::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/advice_specs/advice_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Advice do
+  context '#before_advice' do
+    before do
+      @class = Class.new do
+        extend Advice
+        attr_accessor :closed_over
+        define_method :silly do
+          self.closed_over ||= 1
+          self.closed_over += 5
+        end
+        define_method :checkin do
+          self.closed_over ||= 1
+          self.closed_over *= 2
+        end
+        before_advice :silly, :checkin
+      end
+    end
+
+    it 'causes the advised method to run the suggested advice before running' do
+      @class.new.silly.should == 7
+    end
+  end
+
+  context '#after_advice' do
+    before do
+      @class = Class.new do
+        extend Advice
+        attr_accessor :closed_over
+        define_method :silly do
+          self.closed_over ||= 1
+          self.closed_over += 5
+        end
+        define_method :checkout do
+          self.closed_over ||= 1
+          self.closed_over *= 2
+        end
+        after_advice :silly, :checkout
+      end
+    end
+
+    it 'causes the advised method to run the suggested advice after running' do
+      object = @class.new
+      object.silly
+      object.closed_over.should == 12
+    end
+  end
+
+  context '#argument_advice' do
+    before do
+      @class = Class.new do
+        extend Advice
+        attr_accessor :closed_over
+        define_method :silly do |arg|
+          arg + 5
+        end
+        define_method :twiddle do |arg|
+          arg * 2
+        end
+        argument_advice :silly, :twiddle
+      end
+    end
+
+    it 'causes the advised method to run, rewriting the arguments' do
+      @class.new.silly(1).should == 7
+    end
+  end
+end

data/spec/advice_specs/comment_advice_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Advice::CommentAdvice do
+  before do
+    @class = Class.new(Warning) do
+      include Advice::CommentAdvice
+
+      def match?(body = self.body, settings={})
+        body
+      end
+      remove_comments
+    end
+  end
+
+  context '#remove_comments' do
+    it 'Returns the empty string unmodified' do
+      @class.new('(stdin)', '').match?('').should == ''
+    end
+
+    it 'Turns a comment into the empty string' do
+      @class.new('(stdin)', '# hello').match?('# hello').should == ''
+    end
+
+    it 'strips the comments from the end of a string of code' do
+      @class.new('(stdin)', 'a + b # adding').match?('a + b # adding').should == 'a + b'
+    end
+
+    SAMPLES = [['', ''], ['#hello', ''], [' # hello', ''],
+               [' a + b # hello', ' a + b'], ['(a + b) #', '(a + b)'],
+               ['"#" + number', '"#" + number'],
+               ['" hello \\"mam\\"" # comment', '" hello \\"mam\\""']]
+    SAMPLES.each do |input, output|
+      it "should turn #{input} into #{output}" do
+        @class.new('(stdin)', input).match?(input).should == output
+      end
+    end
+  end
+end

data/spec/advice_specs/spec_helper.rb

@@ -0,0 +1 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')

data/spec/analysis_specs/annotations_specs/next_prev_annotation_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'set'
+describe NextPrevAnnotation do
+  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])])])
+    NextPrevAnnotation::Annotator.new.annotate!(tree)
+    tree[1].prev.should == nil
+    tree[1].next.should == tree[2]
+    tree[2].prev.should == tree[1]
+    tree[2].next.should == nil
+    tree[2][1].prev.should == nil
+    tree[2][1].next.should == tree[2][2]
+    tree[2][3].prev.should == tree[2][2]
+    tree[2][3].next.should == nil
+  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])}'))
+    tree.next.should == nil
+    tree.prev.should == nil
+    visited = Set.new
+    to_visit = tree.children
+    while to_visit.any?
+      todo = to_visit.pop
+      next unless is_sexp?(todo)
+      
+      todo.prev.next.should == todo if is_sexp?(todo.prev)
+      todo.next.prev.should == todo if is_sexp?(todo.next)
+
+      visited << todo
+      case todo[0]
+      when Array
+        to_visit.concat todo
+      when Symbol
+        to_visit.concat todo.children
+      end
+    end
+  end
+end

data/spec/analysis_specs/annotations_specs/parent_annotation_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require 'set'
+describe ParentAnnotation do
+  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])])])
+    ParentAnnotation::Annotator.new.annotate!(tree)
+    tree.parent.should == nil
+    tree[1].parent.should == tree
+    tree[2].parent.should == tree
+    tree[2][1].parent.should == tree[2]
+    tree[2][3].parent.should == tree[2]
+  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])}'))
+    tree.parent.should == nil
+    tree.children[0].parent.should == tree
+    visited = Set.new
+    to_visit = tree.children
+    while to_visit.any?
+      todo = to_visit.pop
+      next unless Sexp === todo
+      todo.parent.children.should include(todo) 
+      visited << todo
+      
+      case todo[0]
+      when Array
+        to_visit.concat todo
+      when Symbol
+        to_visit.concat todo.children
+      end
+    end
+  end
+end

data/spec/analysis_specs/annotations_specs/spec_helper.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+def is_sexp?(sexp)
+  SexpAnalysis::Sexp === sexp
+end

data/spec/analysis_specs/lexical_analysis_spec.rb

@@ -0,0 +1,179 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe LexicalAnalysis do
+  before do
+    @class = Class.new do
+      include LexicalAnalysis
+      attr_accessor :body
+      def initialize(body)
+        self.body = body
+      end
+    end
+  end
+
+  context '#lex' do
+    it 'lexes its body' do
+      @class.new('a').lex.should == [LexicalAnalysis::Token.new([[1,0], :on_ident, 'a'])]
+    end
+  end
+
+  context '#text_between_token_positions' do
+    it 'finds the exclusive text between two simple tokens from a body text' do
+      body = "def initialize(body)\n    self.body = body\nend"
+      left = LexicalAnalysis::Token.new([[2, 4], :on_kw, "self"])
+      right = LexicalAnalysis::Token.new([[2, 20], :on_nl, "\n"])
+      @class.new('').text_between_token_positions(body, left, right).should ==
+          '.body = body'
+    end
+    
+    it 'allows including the left token with the inclusive :left hash option' do
+      body = "def initialize(body)\n    self.body = body\nend"
+      left = LexicalAnalysis::Token.new([[2, 4], :on_kw, "self"])
+      right = LexicalAnalysis::Token.new([[2, 20], :on_nl, "\n"])
+      @class.new('').text_between_token_positions(body, left, right, :left).should ==
+          'self.body = body'
+    end
+    
+    it 'allows including the right token with the inclusive :right hash option' do
+      body = "def initialize(body)\n    self.body = body\nend"
+      left = LexicalAnalysis::Token.new([[2, 4], :on_kw, "self"])
+      right = LexicalAnalysis::Token.new([[2, 20], :on_nl, "\n"])
+      @class.new('').text_between_token_positions(body, left, right, :right).should ==
+          ".body = body\n"
+    end
+    
+    it 'allows including both tokens with the inclusive :both hash option' do
+      body = "def initialize(body)\n    self.body = body\nend"
+      left = LexicalAnalysis::Token.new([[2, 4], :on_kw, "self"])
+      right = LexicalAnalysis::Token.new([[2, 20], :on_nl, "\n"])
+      @class.new('').text_between_token_positions(body, left, right, :both).should ==
+          "self.body = body\n"
+    end
+        
+    it 'allows explicitly to exclude the tokens with the inclusive :none option' do
+      body = "def initialize(body)\n    self.body = body\nend"
+      left = LexicalAnalysis::Token.new([[2, 4], :on_kw, "self"])
+      right = LexicalAnalysis::Token.new([[2, 20], :on_nl, "\n"])
+      @class.new('').text_between_token_positions(body, left, right, :none).should ==
+          '.body = body'
+    end
+    
+    context 'spanning multiple lines' do
+      it 'allows including the left token with the inclusive :left hash option' do
+        body = "def initialize(body)\n    self.body = body\nend # a * b"
+        left = LexicalAnalysis::Token.new([[1, 14], :on_lparen, "("])
+        right = LexicalAnalysis::Token.new([[3, 3], :on_sp, " "])
+        @class.new('').text_between_token_positions(body, left, right, :left).should ==
+            "(body)\n    self.body = body\nend"
+      end
+          
+      it 'allows including the right token with the inclusive :right hash option' do
+        body = "def initialize(body)\n    self.body = body\nend # a * b"
+        left = LexicalAnalysis::Token.new([[1, 14], :on_lparen, "("])
+        right = LexicalAnalysis::Token.new([[3, 3], :on_sp, " "])
+        @class.new('').text_between_token_positions(body, left, right, :right).should ==
+            "body)\n    self.body = body\nend "
+      end
+          
+      it 'allows including both tokens with the inclusive :both hash option' do
+        body = "def initialize(body)\n    self.body = body\nend # a * b"
+        left = LexicalAnalysis::Token.new([[1, 14], :on_lparen, "("])
+        right = LexicalAnalysis::Token.new([[3, 3], :on_sp, " "])
+        @class.new('').text_between_token_positions(body, left, right, :both).should ==
+            "(body)\n    self.body = body\nend "
+      end
+          
+      it 'allows explicitly to exclude the tokens with the inclusive :none option' do
+        body = "def initialize(body)\n    self.body = body\nend # a * b"
+        left = LexicalAnalysis::Token.new([[1, 14], :on_lparen, "("])
+        right = LexicalAnalysis::Token.new([[3, 3], :on_sp, " "])
+        @class.new('').text_between_token_positions(body, left, right, :none).should ==
+            "body)\n    self.body = body\nend"
+      end
+    end
+  end
+    
+  context '#find_token' do
+    it 'lexes its body' do
+      @class.new('a + b').find_token(:on_op).should be_true
+    end
+
+    it 'returns falsy if token not found' do
+      @class.new('a + b').find_token(:on_kw).should be_false
+    end
+
+    it 'works with multiple token options' do
+      result = @class.new('a + b # hello').find_token(:on_op, :on_comment)
+      result.type.should == :on_op
+    end
+    
+    it 'is not triggered by symbols' do
+      @class.new(':+').find_token(:on_op).should be_false
+    end
+  end
+
+  context '#find_keyword' do
+    it 'lexes its body' do
+      @class.new('class A < B').find_keyword(:class).should be_true
+    end
+
+    it 'returns falsy if token not found' do
+      @class.new('class A < B').find_keyword(:end).should be_false
+    end
+
+    it 'returns the actual token if it is found' do
+      @class.new('class A < B').find_keyword(:class).should ==
+          LexicalAnalysis::Token.new([[1,0], :on_kw, 'class'])
+    end
+
+    it 'works with multiple keyword options' do
+      result = @class.new('class A < B; end').find_keyword(:class, :end)
+      result.body.should == 'class'
+    end
+
+    it 'is not triggered by symbols' do
+      @class.new(':unless').find_keyword(:unless).should be_false
+    end
+  end
+
+  context '#split_on_token' do
+    it 'splits the input into two parts based on the token searched' do
+      left, right = @class.new('a + b; c + d').split_on_token(:on_semicolon)
+      left.should == 'a + b'
+      right.should == '; c + d'
+    end
+
+    it 'works with multiple searched tokens' do
+      left, right = @class.new('a + b; c + d').split_on_token(:on_semicolon, :on_op)
+      left.should == 'a '
+      right.should == '+ b; c + d'
+    end
+
+    it 'matches its own documentation' do
+      left, right = @class.new('').split_on_token('x = 5 unless y == 2', :on_kw)
+      left.should == 'x = 5 '
+      right.should == 'unless y == 2'
+    end
+  end
+
+
+  context '#split_on_keyword' do
+    it 'splits the input into two parts based on the token searched' do
+      left, right = @class.new('rescue x if y').split_on_keyword(:if)
+      left.should == 'rescue x '
+      right.should == 'if y'
+    end
+
+    it 'works with multiple searched tokens' do
+      left, right = @class.new('rescue x if y').split_on_keyword(:if, :rescue)
+      left.should == ''
+      right.should == 'rescue x if y'
+    end
+
+    it 'matches its own documentation' do
+      left, right = @class.new('').split_on_keyword('x = 5 unless y == 2', :unless)
+      left.should == 'x = 5 '
+      right.should == 'unless y == 2'
+    end
+  end
+end