tailor 1.2.1 → 1.3.0

data/spec/unit/tailor/configuration_spec.rb

@@ -1,4 +1,4 @@
-require_relative '../../spec_helper'
+require 'spec_helper'
 require 'tailor/configuration'
 require 'tailor/cli'
 
@@ -9,28 +9,28 @@ describe Tailor::Configuration do
     Tailor::Configuration.new('.')
   end
 
-  describe "#formatters" do
-    context "param is nil" do
-      it "returns the pre-exisiting @formatters" do
+  describe '#formatters' do
+    context 'param is nil' do
+      it 'returns the pre-exisiting @formatters' do
         subject.instance_variable_set(:@formatters, [:blah])
         subject.formatters.should == [:blah]
       end
     end
 
-    context "param is some value" do
-      it "sets @formatters to that value" do
-        subject.formatters "blah"
-        subject.instance_variable_get(:@formatters).should == ["blah"]
+    context 'param is some value' do
+      it 'sets @formatters to that value' do
+        subject.formatters 'blah'
+        subject.instance_variable_get(:@formatters).should == ['blah']
       end
     end
   end
 
-  describe "#file_set" do
+  describe '#file_set' do
     before do
       subject.instance_variable_set(:@file_sets, {})
     end
 
-    it "adds the set of stuff to @file_sets" do
+    it 'adds the set of stuff to @file_sets' do
       subject.file_set('some_files', :bobo) do |style|
         style.trailing_newlines 2
       end
@@ -49,6 +49,7 @@ describe Tailor::Configuration do
             max_code_lines_in_method: [30, { level: :error }],
             max_line_length: [80, { level: :error }],
             spaces_after_comma: [1, { level: :error }],
+            spaces_after_conditional: [1, { :level=>:error }],
             spaces_after_lbrace: [1, { level: :error }],
             spaces_after_lbracket: [0, { level: :error }],
             spaces_after_lparen: [0, { level: :error }],
@@ -64,25 +65,25 @@ describe Tailor::Configuration do
       }
     end
 
-    context "first param is nil" do
-      it "uses :default as the label" do
+    context 'first param is nil' do
+      it 'uses :default as the label' do
         subject.file_set
         subject.instance_variable_get(:@file_sets).should include(:default)
       end
     end
   end
 
-  describe "#confg_file" do
-    context "@config_file is already set" do
-      it "returns @config_file" do
+  describe '#confg_file' do
+    context '@config_file is already set' do
+      it 'returns @config_file' do
         subject.instance_variable_set(:@config_file, 'pants')
         subject.config_file
         subject.instance_variable_get(:@config_file).should == 'pants'
       end
     end
 
-    context "@config_file is nil" do
-      context "DEFAULT_PROJECT_CONFIG exists" do
+    context '@config_file is nil' do
+      context 'DEFAULT_PROJECT_CONFIG exists' do
         before do
           File.should_receive(:exists?).with(/\.tailor/).and_return true
         end
@@ -92,13 +93,13 @@ describe Tailor::Configuration do
         end
       end
 
-      context "DEFAULT_PROJECT_CONFIG does not exist" do
+      context 'DEFAULT_PROJECT_CONFIG does not exist' do
         before do
           File.should_receive(:exists?).with(/\.tailor/).and_return false
           File.should_receive(:exists?).with(/\.tailorrc/).and_return true
         end
 
-        it "returns DEFAULT_RC_FILE" do
+        it 'returns DEFAULT_RC_FILE' do
           subject.config_file
           subject.instance_variable_get(:@config_file).should ==
             Tailor::Configuration::DEFAULT_RC_FILE
@@ -107,8 +108,22 @@ describe Tailor::Configuration do
     end
   end
 
-  describe "output file" do
-    context "defined" do
+  describe '#recursive_file_set' do
+    before do
+      subject.instance_variable_set(:@file_sets, {})
+    end
+    it 'yields if a block is provided' do
+      expect do |config|
+        subject.recursive_file_set('*.rb', &config)
+      end.to yield_control
+    end
+    it 'does not raise if a block is not provided' do
+      expect { subject.recursive_file_set('*.rb') }.not_to raise_error
+    end
+  end
+
+  describe 'output file' do
+    context 'defined' do
       subject do
         parser = Tailor::CLI::Options
         args = %w(--output-file=tailor-result.yaml)
@@ -116,11 +131,11 @@ describe Tailor::Configuration do
       end
 
       before { subject.load! }
-      its(:output_file) { should eq "tailor-result.yaml" }
+      its(:output_file) { should eq 'tailor-result.yaml' }
     end
 
-    context "not defined" do
-      its(:output_file) { should eq "" }
+    context 'not defined' do
+      its(:output_file) { should eq '' }
     end
   end
 end

data/spec/unit/tailor/critic_spec.rb

@@ -1,20 +1,21 @@
-require_relative '../../spec_helper'
+require 'spec_helper'
 require 'tailor/critic'
 
+
 describe Tailor::Critic do
   before { Tailor::Logger.stub(:log) }
 
-  describe "#check_file" do
-    let(:lexer) { double "Lexer" }
-    let(:ruler) { double "Ruler" }
-    let(:style) { double "Style", each: nil }
-    let(:file_name) { "this_file.rb" }
+  describe '#check_file' do
+    let(:lexer) { double 'Lexer' }
+    let(:ruler) { double 'Ruler' }
+    let(:style) { double 'Style', each: nil }
+    let(:file_name) { 'this_file.rb' }
 
     before do
       subject.stub(:init_rulers)
     end
 
-    it "lexes the file" do
+    it 'lexes the file' do
       lexer.should_receive(:lex)
       lexer.stub(:check_added_newline)
       Tailor::Lexer.should_receive(:new).with(file_name).and_return lexer
@@ -24,7 +25,7 @@ describe Tailor::Critic do
       subject.check_file(file_name, style)
     end
 
-    it "adds problems for the file to the main list of problems" do
+    it 'adds problems for the file to the main list of problems' do
       lexer.stub(:lex)
       lexer.stub(:check_added_newline)
       Tailor::Lexer.stub(:new).and_return lexer
@@ -34,25 +35,25 @@ describe Tailor::Critic do
     end
   end
 
-  describe "#problems" do
+  describe '#problems' do
     specify { subject.problems.should be_a Hash }
     specify { subject.problems.should be_empty }
   end
 
-  describe "#problem_count" do
-    context "#problems is empty" do
-      it "returns 0" do
+  describe '#problem_count' do
+    context '#problems is empty' do
+      it 'returns 0' do
         subject.instance_variable_set(:@problems, {})
         subject.problem_count.should == 0
       end
     end
 
-    context "#problems contains valid values" do
-      it "adds the number of each problem together" do
+    context '#problems contains valid values' do
+      it 'adds the number of each problem together' do
         probs = {
-          one: { type: :indentation, line: 1, message: "" },
-          two: { type: :indentation, line: 2, message: "" },
-          thre: { type: :indentation, line: 27, message: "" }
+          one: { type: :indentation, line: 1, message: '' },
+          two: { type: :indentation, line: 2, message: '' },
+          thre: { type: :indentation, line: 27, message: '' }
         }
         subject.instance_variable_set(:@problems, probs)
         subject.problem_count.should == 3

data/spec/unit/tailor/formatter_spec.rb

@@ -1,16 +1,16 @@
-require_relative '../../spec_helper'
+require 'spec_helper'
 require 'tailor/formatter'
 
 describe Tailor::Formatter do
-  describe "#problems_at_level" do
+  describe '#problems_at_level' do
     let(:problems) do
-      msg = "File contains invalid Ruby; "
-      msg << "run `ruby -c [your_file.rb]` for more details."
+      msg = 'File contains invalid Ruby; '
+      msg << 'run `ruby -c [your_file.rb]` for more details.'
 
       {
-        "some_file.rb" => [
+        'some_file.rb' => [
           {
-            :type => "allow_invalid_ruby",
+            :type => 'allow_invalid_ruby',
             :line => 0,
             :column => 0,
             :message => msg,
@@ -20,20 +20,20 @@ describe Tailor::Formatter do
       }
     end
 
-    context "problems are empty" do
-      it "returns an empty Array" do
+    context 'problems are empty' do
+      it 'returns an empty Array' do
         subject.problems_at_level({}, :error).should == []
       end
     end
 
-    context "the level asked for exists in the problems" do
-      it "returns the problem" do
-        msg = "File contains invalid Ruby; "
-        msg << "run `ruby -c [your_file.rb]` for more details."
+    context 'the level asked for exists in the problems' do
+      it 'returns the problem' do
+        msg = 'File contains invalid Ruby; '
+        msg << 'run `ruby -c [your_file.rb]` for more details.'
 
         subject.problems_at_level(problems, :warn).should == [
           {
-            :type => "allow_invalid_ruby",
+            :type => 'allow_invalid_ruby',
             :line => 0,
             :column => 0,
             :message => msg,
@@ -43,8 +43,8 @@ describe Tailor::Formatter do
       end
     end
 
-    context "the level asked for does not exist in the problems" do
-      it "returns an empty Array" do
+    context 'the level asked for does not exist in the problems' do
+      it 'returns an empty Array' do
         subject.problems_at_level(problems, :error).should == []
       end
     end

data/spec/unit/tailor/formatters/yaml_spec.rb

@@ -1,4 +1,4 @@
-require_relative '../../../spec_helper'
+require 'spec_helper'
 require 'tailor/formatters/yaml'
 require 'yaml'
 

data/spec/unit/tailor/lexed_line_spec.rb

@@ -1,4 +1,4 @@
-require_relative '../../spec_helper'
+require 'spec_helper'
 require 'tailor/lexed_line'
 
 describe Tailor::LexedLine do
@@ -8,43 +8,43 @@ describe Tailor::LexedLine do
 
   subject { Tailor::LexedLine.new(lexed_output, 1) }
 
-  describe "#initialize" do
+  describe '#initialize' do
     let(:lexed_output) do
       [
-        [[1, 0], :on_ident, "require"],
-        [[1, 7], :on_sp, " "],
+        [[1, 0], :on_ident, 'require'],
+        [[1, 7], :on_sp, ' '],
         [[1, 8], :on_tstring_beg, "'"],
-        [[1, 9], :on_tstring_content, "log_switch"],
+        [[1, 9], :on_tstring_content, 'log_switch'],
         [[1, 19], :on_tstring_end, "'"],
         [[1, 20], :on_nl, "\n"],
-        [[2, 0], :on_ident, "require_relative"],
-        [[2, 16], :on_sp, " "],
+        [[2, 0], :on_ident, 'require_relative'],
+        [[2, 16], :on_sp, ' '],
         [[2, 17], :on_tstring_beg, "'"],
-        [[2, 18], :on_tstring_content, "tailor/runtime_error"],
+        [[2, 18], :on_tstring_content, 'tailor/runtime_error'],
         [[2, 38], :on_tstring_end, "'"],
         [[2, 39], :on_nl, "\n"]
       ]
     end
 
-    it "returns all lexed output from line 1 when self.lineno is 1" do
+    it 'returns all lexed output from line 1 when self.lineno is 1' do
       line = Tailor::LexedLine.new(lexed_output, 1)
 
       line.should == [
-        [[1, 0], :on_ident, "require"],
-        [[1, 7], :on_sp, " "],
+        [[1, 0], :on_ident, 'require'],
+        [[1, 7], :on_sp, ' '],
         [[1, 8], :on_tstring_beg, "'"],
-        [[1, 9], :on_tstring_content, "log_switch"],
+        [[1, 9], :on_tstring_content, 'log_switch'],
         [[1, 19], :on_tstring_end, "'"],
         [[1, 20], :on_nl, "\n"]
       ]
     end
   end
 
-  describe "#only_spaces?" do
+  describe '#only_spaces?' do
     context '0 length line, no \n ending' do
-      let(:lexed_output) { [[[1, 0], :on_sp, "  "]] }
+      let(:lexed_output) { [[[1, 0], :on_sp, '  ']] }
 
-      it "should return true" do
+      it 'should return true' do
         subject.only_spaces?.should be_true
       end
     end
@@ -52,15 +52,15 @@ describe Tailor::LexedLine do
     context '0 length line, with \n ending' do
       let(:lexed_output) { [[[1, 0], :on_nl, "\n"]] }
 
-      it "should return true" do
+      it 'should return true' do
         subject.only_spaces?.should be_true
       end
     end
 
     context 'comment line, starting at column 0' do
-      let(:lexed_output) { [[[1, 0], :on_comment, "# comment"]] }
+      let(:lexed_output) { [[[1, 0], :on_comment, '# comment']] }
 
-      it "should return false" do
+      it 'should return false' do
         subject.only_spaces?.should be_false
       end
     end
@@ -68,12 +68,12 @@ describe Tailor::LexedLine do
     context 'comment line, starting at column 2' do
       let(:lexed_output) do
         [
-          [[1, 0], :on_sp, "  "],
-          [[1, 2], :on_comment, "# comment"]
+          [[1, 0], :on_sp, '  '],
+          [[1, 2], :on_comment, '# comment']
         ]
       end
 
-      it "should return false" do
+      it 'should return false' do
         subject.only_spaces?.should be_false
       end
     end
@@ -81,97 +81,97 @@ describe Tailor::LexedLine do
     context 'code line, starting at column 2' do
       let(:lexed_output) do
         [
-          [[1, 0], :on_ident, "puts"],
-          [[1, 4], :on_sp, " "],
+          [[1, 0], :on_ident, 'puts'],
+          [[1, 4], :on_sp, ' '],
           [[1, 5], :on_tstring_beg, "'"],
-          [[1, 6], :on_tstring_content, "thing"],
+          [[1, 6], :on_tstring_content, 'thing'],
           [[1, 11], :on_tstring_end, "'"],
           [[1, 12], :on_nl, "\n"]
         ]
       end
 
-      it "should return false" do
+      it 'should return false' do
         subject.only_spaces?.should be_false
       end
     end
   end
 
-  describe "#ends_with_op?" do
-    context "line ends with a +, then \\n" do
+  describe '#ends_with_op?' do
+    context 'line ends with a +, then \\n' do
       let(:lexed_output) do
         [
-          [[1, 0], :on_ident, "thing"],
-          [[1, 5], :on_sp, " "],
-          [[1, 6], :on_op, "="],
-          [[1, 7], :on_sp, " "],
-          [[1, 8], :on_int, "1"],
-          [[1, 9], :on_sp, " "],
-          [[1, 10], :on_op, "+"],
+          [[1, 0], :on_ident, 'thing'],
+          [[1, 5], :on_sp, ' '],
+          [[1, 6], :on_op, '='],
+          [[1, 7], :on_sp, ' '],
+          [[1, 8], :on_int, '1'],
+          [[1, 9], :on_sp, ' '],
+          [[1, 10], :on_op, '+'],
           [[1, 11], :on_ignored_nl, "\n"],
           [[1, 11], :on_ignored_nl, "\n"]
         ]
       end
 
-      it "returns true" do
+      it 'returns true' do
         subject.ends_with_op?.should be_true
       end
     end
 
-    context "line ends with not an operator, then \\n" do
+    context 'line ends with not an operator, then \\n' do
       let(:lexed_output) do
         [
-          [[1, 0], :on_ident, "thing"],
-          [[1, 5], :on_sp, " "],
-          [[1, 6], :on_op, "="],
-          [[1, 7], :on_sp, " "],
-          [[1, 8], :on_int, "1"],
+          [[1, 0], :on_ident, 'thing'],
+          [[1, 5], :on_sp, ' '],
+          [[1, 6], :on_op, '='],
+          [[1, 7], :on_sp, ' '],
+          [[1, 8], :on_int, '1'],
           [[1, 11], :on_nl, "\n"]
         ]
       end
 
-      it "returns false" do
+      it 'returns false' do
         subject.ends_with_op?.should be_false
       end
     end
   end
 
-  describe "#ends_with_modifier_kw?" do
-    context "ends_with_kw? is false" do
+  describe '#ends_with_modifier_kw?' do
+    context 'ends_with_kw? is false' do
       let(:lexed_output) do
         [
-          [[1, 0], :on_ident, "thing"],
-          [[1, 5], :on_sp, " "],
-          [[1, 6], :on_op, "="],
-          [[1, 7], :on_sp, " "],
-          [[1, 8], :on_int, "1"],
+          [[1, 0], :on_ident, 'thing'],
+          [[1, 5], :on_sp, ' '],
+          [[1, 6], :on_op, '='],
+          [[1, 7], :on_sp, ' '],
+          [[1, 8], :on_int, '1'],
           [[1, 9], :on_ignored_nl, "\n"]
         ]
       end
 
       before { subject.stub(:ends_with_kw?).and_return true }
 
-      it "returns false" do
+      it 'returns false' do
         subject.ends_with_modifier_kw?.should be_false
       end
     end
 
-    context "#ends_with_kw? is true" do
+    context '#ends_with_kw? is true' do
       let(:lexed_output) do
         [
-          [[1, 0], :on_ident, "thing"],
-          [[1, 5], :on_sp, " "],
-          [[1, 6], :on_op, "="],
-          [[1, 7], :on_sp, " "],
-          [[1, 8], :on_int, "1"],
-          [[1, 9], :on_sp, " "],
-          [[1, 10], :on_kw, "if"],
+          [[1, 0], :on_ident, 'thing'],
+          [[1, 5], :on_sp, ' '],
+          [[1, 6], :on_op, '='],
+          [[1, 7], :on_sp, ' '],
+          [[1, 8], :on_int, '1'],
+          [[1, 9], :on_sp, ' '],
+          [[1, 10], :on_kw, 'if'],
           [[1, 12], :on_ignored_nl, "\n"]
         ]
       end
 
-      let(:token) { double "Token" }
+      let(:token) { double 'Token' }
 
-      context "the keyword is a modifier" do
+      context 'the keyword is a modifier' do
         before do
           token.stub(:modifier_keyword?).and_return true
           Tailor::Lexer::Token.stub(:new).and_return token
@@ -180,12 +180,12 @@ describe Tailor::LexedLine do
 
         after { Tailor::Lexer::Token.unstub(:new) }
 
-        it "returns true" do
+        it 'returns true' do
           subject.ends_with_modifier_kw?.should be_true
         end
       end
 
-      context "the keyword is not a modifier" do
+      context 'the keyword is not a modifier' do
         before do
           token.stub(:modifier_keyword?).and_return false
           Tailor::Lexer::Token.stub(:new).and_return token
@@ -194,84 +194,84 @@ describe Tailor::LexedLine do
 
         after { Tailor::Lexer::Token.unstub(:new) }
 
-        it "returns true" do
+        it 'returns true' do
           subject.ends_with_modifier_kw?.should be_false
         end
       end
     end
   end
 
-  describe "#does_line_end_with" do
+  describe '#does_line_end_with' do
     let(:lexed_output) do
       [
-        [[1, 0], :on_kw, "def"],
-        [[1, 3], :on_sp, " "],
-        [[1, 4], :on_ident, "thing"],
-        [[1, 9], :on_sp, " "],
+        [[1, 0], :on_kw, 'def'],
+        [[1, 3], :on_sp, ' '],
+        [[1, 4], :on_ident, 'thing'],
+        [[1, 9], :on_sp, ' '],
         [[1, 10], :on_nl, "\n"]
       ]
     end
 
-    context "line ends with the event" do
-      it "returns true" do
+    context 'line ends with the event' do
+      it 'returns true' do
         subject.does_line_end_with(:on_sp).should be_true
       end
     end
 
-    context "line does not even with event" do
-      it "returns false" do
+    context 'line does not even with event' do
+      it 'returns false' do
         subject.does_line_end_with(:on_kw).should be_false
       end
     end
   end
 
-  describe "#last_non_line_feed_event" do
-    context "line ends with a space" do
+  describe '#last_non_line_feed_event' do
+    context 'line ends with a space' do
       let(:lexed_output) do
         [
-          [[1, 0], :on_kw, "def"],
-          [[1, 3], :on_sp, " "],
-          [[1, 4], :on_ident, "thing"],
-          [[1, 9], :on_sp, " "],
+          [[1, 0], :on_kw, 'def'],
+          [[1, 3], :on_sp, ' '],
+          [[1, 4], :on_ident, 'thing'],
+          [[1, 9], :on_sp, ' '],
           [[1, 10], :on_nl, "\n"]
         ]
       end
 
-      it "returns the space" do
-        subject.last_non_line_feed_event.should == [[1, 9], :on_sp, " "]
+      it 'returns the space' do
+        subject.last_non_line_feed_event.should == [[1, 9], :on_sp, ' ']
       end
     end
 
-    context "line ends with a backslash" do
+    context 'line ends with a backslash' do
       let(:lexed_output) do
         [
-          [[1, 0], :on_kw, "def"],
-          [[1, 3], :on_sp, " "],
-          [[1, 4], :on_ident, "thing"],
+          [[1, 0], :on_kw, 'def'],
+          [[1, 3], :on_sp, ' '],
+          [[1, 4], :on_ident, 'thing'],
           [[1, 9], :on_sp, "\\\n"]
         ]
       end
 
-      it "returns the event before it" do
-        subject.last_non_line_feed_event.should == [[1, 4], :on_ident, "thing"]
+      it 'returns the event before it' do
+        subject.last_non_line_feed_event.should == [[1, 4], :on_ident, 'thing']
       end
     end
   end
 
-  describe "#loop_with_do?" do
+  describe '#loop_with_do?' do
     context "line is 'while true do\\n'" do
       let(:lexed_output) do
         [
-          [[1, 0], :on_kw, "while"],
-          [[1, 5], :on_sp, " "],
-          [[1, 6], :on_kw, "true"],
-          [[1, 10], :on_sp, " "],
-          [[1, 11], :on_kw, "do"],
+          [[1, 0], :on_kw, 'while'],
+          [[1, 5], :on_sp, ' '],
+          [[1, 6], :on_kw, 'true'],
+          [[1, 10], :on_sp, ' '],
+          [[1, 11], :on_kw, 'do'],
           [[1, 13], :on_ignored_nl, "\n"]
         ]
       end
 
-      it "returns true" do
+      it 'returns true' do
         subject.loop_with_do?.should be_true
       end
     end
@@ -279,15 +279,15 @@ describe Tailor::LexedLine do
     context "line is 'while true\\n'" do
       let(:lexed_output) do
         [
-          [[1, 0], :on_kw, "while"],
-          [[1, 5], :on_sp, " "],
-          [[1, 6], :on_kw, "true"],
-          [[1, 10], :on_sp, " "],
+          [[1, 0], :on_kw, 'while'],
+          [[1, 5], :on_sp, ' '],
+          [[1, 6], :on_kw, 'true'],
+          [[1, 10], :on_sp, ' '],
           [[1, 11], :on_ignored_nl, "\n"]
         ]
       end
 
-      it "returns false" do
+      it 'returns false' do
         subject.loop_with_do?.should be_false
       end
     end
@@ -295,16 +295,16 @@ describe Tailor::LexedLine do
     context "line is 'until true do\\n'" do
       let(:lexed_output) do
         [
-          [[1, 0], :on_kw, "until"],
-          [[1, 5], :on_sp, " "],
-          [[1, 6], :on_kw, "true"],
-          [[1, 10], :on_sp, " "],
-          [[1, 11], :on_kw, "do"],
+          [[1, 0], :on_kw, 'until'],
+          [[1, 5], :on_sp, ' '],
+          [[1, 6], :on_kw, 'true'],
+          [[1, 10], :on_sp, ' '],
+          [[1, 11], :on_kw, 'do'],
           [[1, 13], :on_ignored_nl, "\n"]
         ]
       end
 
-      it "returns true" do
+      it 'returns true' do
         subject.loop_with_do?.should be_true
       end
     end
@@ -312,15 +312,15 @@ describe Tailor::LexedLine do
     context "line is 'until true\\n'" do
       let(:lexed_output) do
         [
-          [[1, 0], :on_kw, "until"],
-          [[1, 5], :on_sp, " "],
-          [[1, 6], :on_kw, "true"],
-          [[1, 10], :on_sp, " "],
+          [[1, 0], :on_kw, 'until'],
+          [[1, 5], :on_sp, ' '],
+          [[1, 6], :on_kw, 'true'],
+          [[1, 10], :on_sp, ' '],
           [[1, 11], :on_ignored_nl, "\n"]
         ]
       end
 
-      it "returns false" do
+      it 'returns false' do
         subject.loop_with_do?.should be_false
       end
     end
@@ -328,22 +328,22 @@ describe Tailor::LexedLine do
     context "line is 'for i in 1..5 do\\n'" do
       let(:lexed_output) do
         [
-          [[1, 0], :on_kw, "for"],
-          [[1, 3], :on_sp, " "],
-          [[1, 4], :on_ident, "i"],
-          [[1, 5], :on_sp, " "],
-          [[1, 6], :on_kw, "in"],
-          [[1, 8], :on_sp, " "],
-          [[1, 9], :on_int, "1"],
-          [[1, 10], :on_op, ".."],
-          [[1, 12], :on_int, "5"],
-          [[1, 13], :on_sp, " "],
-          [[1, 14], :on_kw, "do"],
+          [[1, 0], :on_kw, 'for'],
+          [[1, 3], :on_sp, ' '],
+          [[1, 4], :on_ident, 'i'],
+          [[1, 5], :on_sp, ' '],
+          [[1, 6], :on_kw, 'in'],
+          [[1, 8], :on_sp, ' '],
+          [[1, 9], :on_int, '1'],
+          [[1, 10], :on_op, '..'],
+          [[1, 12], :on_int, '5'],
+          [[1, 13], :on_sp, ' '],
+          [[1, 14], :on_kw, 'do'],
           [[1, 16], :on_ignored_nl, "\n"]
         ]
       end
 
-      it "returns true" do
+      it 'returns true' do
         subject.loop_with_do?.should be_true
       end
     end
@@ -351,31 +351,31 @@ describe Tailor::LexedLine do
     context "line is 'for i in 1..5\\n'" do
       let(:lexed_output) do
         [
-          [[1, 0], :on_kw, "for"],
-          [[1, 3], :on_sp, " "],
-          [[1, 4], :on_ident, "i"],
-          [[1, 5], :on_sp, " "],
-          [[1, 6], :on_kw, "in"],
-          [[1, 8], :on_sp, " "],
-          [[1, 9], :on_int, "1"],
-          [[1, 10], :on_op, ".."],
-          [[1, 12], :on_int, "5"],
-          [[1, 13], :on_sp, " "],
+          [[1, 0], :on_kw, 'for'],
+          [[1, 3], :on_sp, ' '],
+          [[1, 4], :on_ident, 'i'],
+          [[1, 5], :on_sp, ' '],
+          [[1, 6], :on_kw, 'in'],
+          [[1, 8], :on_sp, ' '],
+          [[1, 9], :on_int, '1'],
+          [[1, 10], :on_op, '..'],
+          [[1, 12], :on_int, '5'],
+          [[1, 13], :on_sp, ' '],
           [[1, 14], :on_ignored_nl, "\n"]
         ]
       end
 
-      it "returns false" do
+      it 'returns false' do
         subject.loop_with_do?.should be_false
       end
     end
   end
 
-  describe "#first_non_space_element" do
-    context "lexed line contains only spaces" do
-      let(:lexed_output) { [[[1, 0], :on_sp, "     "]] }
+  describe '#first_non_space_element' do
+    context 'lexed line contains only spaces' do
+      let(:lexed_output) { [[[1, 0], :on_sp, '     ']] }
 
-      it "returns nil" do
+      it 'returns nil' do
         subject.first_non_space_element.should be_nil
       end
     end
@@ -383,7 +383,7 @@ describe Tailor::LexedLine do
     context "lexed line contains only \\n" do
       let(:lexed_output) { [[[1, 0], :on_ignored_nl, "\n"]] }
 
-      it "returns nil" do
+      it 'returns nil' do
         subject.first_non_space_element.should be_nil
       end
     end
@@ -391,56 +391,56 @@ describe Tailor::LexedLine do
     context "lexed line contains '  }\\n'" do
       let(:lexed_output) do
         [
-          [[1, 0], :on_sp, "  "],
-          [[1, 2], :on_rbrace, "}"],
+          [[1, 0], :on_sp, '  '],
+          [[1, 2], :on_rbrace, '}'],
           [[1, 3], :on_nl, "\n"]
         ]
       end
 
-      it "returns nil" do
-        subject.first_non_space_element.should == [[1, 2], :on_rbrace, "}"]
+      it 'returns nil' do
+        subject.first_non_space_element.should == [[1, 2], :on_rbrace, '}']
       end
     end
   end
 
-  describe "#event_at" do
-    let(:lexed_output) { [[[1, 0], :on_sp, "     "]] }
+  describe '#event_at' do
+    let(:lexed_output) { [[[1, 0], :on_sp, '     ']] }
 
-    context "self contains an event at the given column" do
-      it "returns that event" do
+    context 'self contains an event at the given column' do
+      it 'returns that event' do
         subject.event_at(0).should == lexed_output.first
       end
     end
 
-    context "self does not contain an event at the given column" do
-      it "returns nil" do
+    context 'self does not contain an event at the given column' do
+      it 'returns nil' do
         subject.event_at(1234).should be_nil
       end
     end
   end
 
-  describe "#event_index" do
-    let(:lexed_output) { [[[1, 0], :on_sp, "     "]] }
+  describe '#event_index' do
+    let(:lexed_output) { [[[1, 0], :on_sp, '     ']] }
 
-    context "#event_at returns nil" do
+    context '#event_at returns nil' do
       before { subject.stub(:event_at).and_return nil }
       specify { subject.event_index(1234).should be_nil }
     end
 
-    context "#event_at returns a valid column" do
-      it "returns the event" do
+    context '#event_at returns a valid column' do
+      it 'returns the event' do
         subject.event_index(0).should be_zero
       end
     end
   end
 
-  describe "#to_s" do
+  describe '#to_s' do
     let(:lexed_output) do
       [
-        [[1, 0], :on_kw, "def"],
-        [[1, 3], :on_sp, " "],
-        [[1, 4], :on_ident, "thing"],
-        [[1, 9], :on_sp, " "],
+        [[1, 0], :on_kw, 'def'],
+        [[1, 3], :on_sp, ' '],
+        [[1, 4], :on_ident, 'thing'],
+        [[1, 9], :on_sp, ' '],
         [[1, 10], :on_nl, "\n"]
       ]
     end
@@ -450,18 +450,18 @@ describe Tailor::LexedLine do
     end
   end
 
-  describe "#remove_comment_at" do
-    context "stuff before comment is an incomplete statement" do
-      context "spaces before comment" do
+  describe '#remove_comment_at' do
+    context 'stuff before comment is an incomplete statement' do
+      context 'spaces before comment' do
         let(:lexed_output) do
           [
-            [[1, 0], :on_kw, "def"],
-            [[1, 3], :on_sp, " "],
-            [[1, 4], :on_ident, "thing"],
-            [[1, 9], :on_sp, " "],
-            [[1, 10], :on_ident, "one"],
-            [[1, 13], :on_comma, ","],
-            [[1, 14], :on_sp, "  "],
+            [[1, 0], :on_kw, 'def'],
+            [[1, 3], :on_sp, ' '],
+            [[1, 4], :on_ident, 'thing'],
+            [[1, 9], :on_sp, ' '],
+            [[1, 10], :on_ident, 'one'],
+            [[1, 13], :on_comma, ','],
+            [[1, 14], :on_sp, '  '],
             [[1, 16], :on_comment, "# comment\n"]
           ]
         end
@@ -470,28 +470,28 @@ describe Tailor::LexedLine do
           "def thing one,  # comment\n  two\nend\n"
         end
 
-        it "replaces the comment with an :on_ignored_nl" do
+        it 'replaces the comment with an :on_ignored_nl' do
           subject.remove_trailing_comment(file_text).should == [
-            [[1, 0], :on_kw, "def"],
-            [[1, 3], :on_sp, " "],
-            [[1, 4], :on_ident, "thing"],
-            [[1, 9], :on_sp, " "],
-            [[1, 10], :on_ident, "one"],
-            [[1, 13], :on_comma, ","],
+            [[1, 0], :on_kw, 'def'],
+            [[1, 3], :on_sp, ' '],
+            [[1, 4], :on_ident, 'thing'],
+            [[1, 9], :on_sp, ' '],
+            [[1, 10], :on_ident, 'one'],
+            [[1, 13], :on_comma, ','],
             [[1, 14], :on_ignored_nl, "\n"]
           ]
         end
       end
 
-      context "no spaces before comment" do
+      context 'no spaces before comment' do
         let(:lexed_output) do
           [
-            [[1, 0], :on_kw, "def"],
-            [[1, 3], :on_sp, " "],
-            [[1, 4], :on_ident, "thing"],
-            [[1, 9], :on_sp, " "],
-            [[1, 10], :on_ident, "one"],
-            [[1, 13], :on_comma, ","],
+            [[1, 0], :on_kw, 'def'],
+            [[1, 3], :on_sp, ' '],
+            [[1, 4], :on_ident, 'thing'],
+            [[1, 9], :on_sp, ' '],
+            [[1, 10], :on_ident, 'one'],
+            [[1, 13], :on_comma, ','],
             [[1, 14], :on_comment, "# comment\n"]
           ]
         end
@@ -500,30 +500,30 @@ describe Tailor::LexedLine do
           "def thing one,# comment\n  two\nend\n"
         end
 
-        it "replaces the comment with an :on_ignored_nl" do
+        it 'replaces the comment with an :on_ignored_nl' do
           subject.remove_trailing_comment(file_text).should == [
-            [[1, 0], :on_kw, "def"],
-            [[1, 3], :on_sp, " "],
-            [[1, 4], :on_ident, "thing"],
-            [[1, 9], :on_sp, " "],
-            [[1, 10], :on_ident, "one"],
-            [[1, 13], :on_comma, ","],
+            [[1, 0], :on_kw, 'def'],
+            [[1, 3], :on_sp, ' '],
+            [[1, 4], :on_ident, 'thing'],
+            [[1, 9], :on_sp, ' '],
+            [[1, 10], :on_ident, 'one'],
+            [[1, 13], :on_comma, ','],
             [[1, 14], :on_ignored_nl, "\n"]
           ]
         end
       end
     end
 
-    context "stuff before comment is a complete statement" do
-      context "spaces before comment" do
+    context 'stuff before comment is a complete statement' do
+      context 'spaces before comment' do
         let(:lexed_output) do
           [
-            [[1, 0], :on_kw, "def"],
-            [[1, 3], :on_sp, " "],
-            [[1, 4], :on_ident, "thing"],
-            [[1, 9], :on_sp, " "],
-            [[1, 10], :on_ident, "one"],
-            [[1, 13], :on_sp, "  "],
+            [[1, 0], :on_kw, 'def'],
+            [[1, 3], :on_sp, ' '],
+            [[1, 4], :on_ident, 'thing'],
+            [[1, 9], :on_sp, ' '],
+            [[1, 10], :on_ident, 'one'],
+            [[1, 13], :on_sp, '  '],
             [[1, 15], :on_comment, "# comment\n"]
           ]
         end
@@ -532,26 +532,26 @@ describe Tailor::LexedLine do
           "def thing one  # comment\n\nend\n"
         end
 
-        it "replaces the comment with an :on_nl" do
+        it 'replaces the comment with an :on_nl' do
           subject.remove_trailing_comment(file_text).should == [
-            [[1, 0], :on_kw, "def"],
-            [[1, 3], :on_sp, " "],
-            [[1, 4], :on_ident, "thing"],
-            [[1, 9], :on_sp, " "],
-            [[1, 10], :on_ident, "one"],
+            [[1, 0], :on_kw, 'def'],
+            [[1, 3], :on_sp, ' '],
+            [[1, 4], :on_ident, 'thing'],
+            [[1, 9], :on_sp, ' '],
+            [[1, 10], :on_ident, 'one'],
             [[1, 13], :on_nl, "\n"]
           ]
         end
       end
 
-      context "no spaces before comment" do
+      context 'no spaces before comment' do
         let(:lexed_output) do
           [
-            [[1, 0], :on_kw, "def"],
-            [[1, 3], :on_sp, " "],
-            [[1, 4], :on_ident, "thing"],
-            [[1, 9], :on_sp, " "],
-            [[1, 10], :on_ident, "one"],
+            [[1, 0], :on_kw, 'def'],
+            [[1, 3], :on_sp, ' '],
+            [[1, 4], :on_ident, 'thing'],
+            [[1, 9], :on_sp, ' '],
+            [[1, 10], :on_ident, 'one'],
             [[1, 13], :on_comment, "# comment\n"]
           ]
         end
@@ -560,18 +560,18 @@ describe Tailor::LexedLine do
           "def thing one# comment\n  \nend\n"
         end
 
-        it "replaces the comment with an :on_nl" do
+        it 'replaces the comment with an :on_nl' do
           subject.remove_trailing_comment(file_text).should == [
-            [[1, 0], :on_kw, "def"],
-            [[1, 3], :on_sp, " "],
-            [[1, 4], :on_ident, "thing"],
-            [[1, 9], :on_sp, " "],
-            [[1, 10], :on_ident, "one"],
+            [[1, 0], :on_kw, 'def'],
+            [[1, 3], :on_sp, ' '],
+            [[1, 4], :on_ident, 'thing'],
+            [[1, 9], :on_sp, ' '],
+            [[1, 10], :on_ident, 'one'],
             [[1, 13], :on_nl, "\n"]
           ]
         end
 
-        it "returns a LexedLine" do
+        it 'returns a LexedLine' do
           subject.remove_trailing_comment(file_text).
             should be_a Tailor::LexedLine
         end
@@ -579,50 +579,50 @@ describe Tailor::LexedLine do
     end
   end
 
-  describe "#end_of_multi-line_string?" do
-    context "lexed output is from the end of a multi-line % statement" do
+  describe '#end_of_multi-line_string?' do
+    context 'lexed output is from the end of a multi-line % statement' do
       let(:lexed_output) do
-        [[[1, 11], :on_tstring_end, "}"], [[1, 12], :on_nl, "\n"]]
+        [[[1, 11], :on_tstring_end, '}'], [[1, 12], :on_nl, "\n"]]
       end
 
-      it "returns true" do
+      it 'returns true' do
         subject.end_of_multi_line_string?.should be_true
       end
     end
 
-    context "lexed output is not from the end of a multi-line % statement" do
+    context 'lexed output is not from the end of a multi-line % statement' do
       let(:lexed_output) do
-        [[[1, 11], :on_comma, ","], [[1, 12], :on_nl, "\n"]]
+        [[[1, 11], :on_comma, ','], [[1, 12], :on_nl, "\n"]]
       end
 
-      it "returns true" do
+      it 'returns true' do
         subject.end_of_multi_line_string?.should be_false
       end
     end
 
-    context "lexed output contains start AND end of a multi-line % statement" do
+    context 'lexed output contains start AND end of a multi-line % statement' do
       let(:lexed_output) do
         [
-          [[1, 0], :on_tstring_beg, "%Q{"],
-          [[1, 3], :on_tstring_content, "this is a t string! suckaaaaaa!"],
-          [[1, 32], :on_tstring_end, "}"]
+          [[1, 0], :on_tstring_beg, '%Q{'],
+          [[1, 3], :on_tstring_content, 'this is a t string! suckaaaaaa!'],
+          [[1, 32], :on_tstring_end, '}']
         ]
       end
 
-      it "returns true" do
+      it 'returns true' do
         subject.end_of_multi_line_string?.should be_false
       end
     end
   end
 
-  describe "#is_line_only_a" do
+  describe '#is_line_only_a' do
     let(:lexed_output) do
-      [[[1, 11], :on_comma, ","], [[1, 12], :on_nl, "\n"]]
+      [[[1, 11], :on_comma, ','], [[1, 12], :on_nl, "\n"]]
     end
 
-    context "last event is not the event passed in" do
+    context 'last event is not the event passed in' do
       let(:last_event) do
-        [[[1, 11], :on_comma, ","]]
+        [[[1, 11], :on_comma, ',']]
       end
 
       before do
@@ -632,24 +632,24 @@ describe Tailor::LexedLine do
       specify { subject.is_line_only_a(:on_period).should be_false }
     end
 
-    context "last event is the last event passed in" do
-      context "there is only space before the last event" do
+    context 'last event is the last event passed in' do
+      context 'there is only space before the last event' do
         let(:lexed_output) do
           [
             [[1, 0], :on_sp, '          '],
-            [[1, 11], :on_comma, ","],
+            [[1, 11], :on_comma, ','],
             [[1, 12], :on_nl, "\n"]]
         end
 
         specify { subject.is_line_only_a(:on_comma).should be_true }
       end
 
-      context "there is non-spaces before the last event" do
+      context 'there is non-spaces before the last event' do
         let(:lexed_output) do
           [
-            [[1, 0], :on_sp, "        "],
-            [[1, 8], :on_ident, "one"],
-            [[1, 11], :on_comma, ","],
+            [[1, 0], :on_sp, '        '],
+            [[1, 8], :on_ident, 'one'],
+            [[1, 11], :on_comma, ','],
             [[1, 12], :on_nl, "\n"]]
         end
 
@@ -658,57 +658,57 @@ describe Tailor::LexedLine do
     end
   end
 
-  describe "#keyword_is_symbol?" do
-    context "last event in line is not a keyword" do
+  describe '#keyword_is_symbol?' do
+    context 'last event in line is not a keyword' do
       let(:lexed_output) do
         [
-          [[1, 0], :on_sp, "        "],
-          [[1, 8], :on_ident, "one"],
-          [[1, 11], :on_comma, ","],
+          [[1, 0], :on_sp, '        '],
+          [[1, 8], :on_ident, 'one'],
+          [[1, 11], :on_comma, ','],
           [[1, 12], :on_nl, "\n"]]
       end
 
-      it "returns false" do
+      it 'returns false' do
         subject.keyword_is_symbol?.should be_false
       end
     end
 
-    context "last event in line is a keyword" do
-      context "previous event is nil" do
+    context 'last event in line is a keyword' do
+      context 'previous event is nil' do
         let(:lexed_output) do
           [
-            [[1, 0], :on_kw, "class"]
+            [[1, 0], :on_kw, 'class']
           ]
         end
 
-        it "returns false" do
+        it 'returns false' do
           subject.keyword_is_symbol?.should be_false
         end
       end
 
-      context "previous event is not :on_symbeg" do
+      context 'previous event is not :on_symbeg' do
         let(:lexed_output) do
           [
-            [[1, 0], :on_sp, "  "],
-            [[1, 2], :on_kw, "class"]
+            [[1, 0], :on_sp, '  '],
+            [[1, 2], :on_kw, 'class']
           ]
         end
 
-        it "returns false" do
+        it 'returns false' do
           subject.keyword_is_symbol?.should be_false
         end
       end
 
-      context "previous event is :on_symbeg" do
+      context 'previous event is :on_symbeg' do
         let(:lexed_output) do
           [
-            [[1, 0], :on_const, "INDENT_OK"],
-            [[1, 9], :on_lbracket, "["],
-            [[1, 10], :on_symbeg, ":"],
-            [[1, 11], :on_kw, "class"]]
+            [[1, 0], :on_const, 'INDENT_OK'],
+            [[1, 9], :on_lbracket, '['],
+            [[1, 10], :on_symbeg, ':'],
+            [[1, 11], :on_kw, 'class']]
         end
 
-        it "returns true" do
+        it 'returns true' do
           subject.keyword_is_symbol?.should be_true
         end
       end