laser 0.7.0.pre1

data/spec/warning_specs/misaligned_unindentation_spec.rb

@@ -0,0 +1,35 @@
+require_relative 'spec_helper'
+
+describe MisalignedUnindentationWarning do
+  describe 'when fixing' do
+    it 'is a line-based warning' do
+      MisalignedUnindentationWarning.new('(stdin)', 'hello', 80).should be_a(LineWarning)
+    end
+
+    it 'matches nothing' do
+      MisalignedUnindentationWarning.should_not warn(' a + b', 2)
+    end
+
+    it 'fixes by removing more spaces than expected' do
+      MisalignedUnindentationWarning.should correct_to('   a + b', '  a + b', 2)
+    end
+
+    it 'fixes by adding a second space' do
+      MisalignedUnindentationWarning.should correct_to(' a + b', '  a + b', 2)
+    end
+
+    it 'fixes by adding indentation' do
+      MisalignedUnindentationWarning.should correct_to('a + b', '    a + b', 4)
+    end
+
+    it 'describes the incorrect indentation values' do
+      warning = MisalignedUnindentationWarning.new('(stdin)', '   a + b', 2)
+      other_warning = MisalignedUnindentationWarning.new('(stdin)', ' a + b', 2)
+      warning_3 = MisalignedUnindentationWarning.new('(stdin)', 'a + b', 4)
+      warning.desc.should =~ /Expected 2/
+      warning.desc.should =~ /found 3/
+      other_warning.desc.should =~ /Expected 2/
+      other_warning.desc.should =~ /found 1/
+    end
+  end
+end

data/spec/warning_specs/operator_spacing_spec.rb

@@ -0,0 +1,104 @@
+require_relative 'spec_helper'
+
+describe OperatorSpacing do
+  it 'is a line-based warning' do
+    OperatorSpacing.new('(stdin)', 'hello').should be_a(LineWarning)
+  end
+
+  it "doesn't match block declarations" do
+    OperatorSpacing.should_not warn('[1, 2].each { |x| p x }')
+    OperatorSpacing.should_not warn('[1, 2].each {| y | p x }')
+    OperatorSpacing.should_not warn("[1, 2].each do |x|\n p x\nend")
+    OperatorSpacing.should_not warn("[1, 2].each do|x|\n p x\nend")
+  end
+
+  it "doesn't match in a comment" do
+    OperatorSpacing.should_not warn('hello # a+b')
+  end
+
+  it "doesn't match a <<- heredoc" do
+    OperatorSpacing.should_not warn('@original = <<-EOF')
+  end
+
+  it "doesn't match a << heredoc" do
+    OperatorSpacing.should_not warn('@original = <<EOF')
+  end
+
+  it "doesn't match adjacent negative numbers" do
+    OperatorSpacing.should_not warn('  exit(-1)')
+  end
+
+  it "doesn't match *args in block parameters" do
+    OperatorSpacing.should_not warn('list.each do |*args|')
+    OperatorSpacing.should_not warn('list.each { |*args| }')
+  end
+
+  it "doesn't match splat arguments" do
+    OperatorSpacing.should_not warn('x.call(*args)')
+    OperatorSpacing.should_not warn('x.call(a, *args)')
+    OperatorSpacing.should_not warn('x.call(*args, b)')
+    OperatorSpacing.should_not warn('x.call(a, *args, b)')
+  end
+
+  it "does match multiplication in an argument list" do
+    OperatorSpacing.should warn('x.call(a *b)')
+    OperatorSpacing.should warn('x.call(x, a *b)')
+    OperatorSpacing.should warn('x.call(a *b, z)')
+  end
+
+  it "doesn't match block arguments" do
+    OperatorSpacing.should_not warn('x.call(&b)')
+    OperatorSpacing.should_not warn('x.call(a, &b)')
+    OperatorSpacing.should_not warn('x.call(&b, b)')
+    OperatorSpacing.should_not warn('x.call(a, &b, b)')
+    OperatorSpacing.should_not warn('@peek = wrapped_stream.move_forward_until(&@filter) or return true')
+    OperatorSpacing.should_not warn('wrapped_stream.move_forward_until(&@filter)')
+    OperatorSpacing.should_not warn('wrapped_stream.move_backward_until(&@filter) or self')
+  end
+
+  it "doesn't match the [*item] idiom" do
+    OperatorSpacing.should_not warn('[*args]')
+  end
+
+  it 'has a reasonable description' do
+    OperatorSpacing.new('(stdin)', 'a+ b').desc.should =~ /spacing/
+  end
+
+  OperatorSpacing::OPERATORS.each do |operator|
+    describe "with #{operator}" do
+      it "matches when there is no space on the left side" do
+        OperatorSpacing.should warn("a#{operator} b")
+      end
+
+      it "matches when there is no space on the right side" do
+        OperatorSpacing.should warn("a #{operator}b")
+      end unless operator == '/'  # This confuses the shit out of the lexer
+
+      it "matches when there is no space on both sides" do
+        OperatorSpacing.should warn("a#{operator}b")
+      end
+
+      it "doesn't match when there is exactly one space on both sides" do
+        OperatorSpacing.should_not warn("a #{operator} b")
+      end
+
+      describe 'when fixing' do
+        it 'changes nothing when there is one space on both sides' do
+          OperatorSpacing.should correct_to("a #{operator} b", "a #{operator} b")
+        end
+
+        it 'fixes by inserting an extra space on the left' do
+          OperatorSpacing.should correct_to("a#{operator} b", "a #{operator} b")
+        end
+
+        it 'fixes by inserting an extra space on the right' do
+          OperatorSpacing.should correct_to("a #{operator}b", "a #{operator} b")
+        end unless operator == '/'  # This confuses the shit out of the lexer
+
+        it 'fixes by inserting an extra space on both sides' do
+          OperatorSpacing.should correct_to("a#{operator}b", "a #{operator} b")
+        end
+      end
+    end
+  end
+end

data/spec/warning_specs/parens_on_declaration_spec.rb

@@ -0,0 +1,57 @@
+require_relative 'spec_helper'
+
+describe ParensOnDeclarationWarning do
+  it 'is a file-based warning' do
+    ParensOnDeclarationWarning.new('(stdin)', 'hello').should be_a(FileWarning)
+  end
+
+  context 'with a normal method definition' do
+    it 'matches when a method has arguments with no parens around them' do
+      ParensOnDeclarationWarning.should warn('def abc arg; end')
+    end
+  
+    it 'matches when a method with no arguments is declared with parentheses' do
+      ParensOnDeclarationWarning.should warn('def abc(); end')
+    end
+
+    it 'does not match when arguments are surrounded by parentheses' do
+      ParensOnDeclarationWarning.should_not warn('def abc(arg); end')
+    end
+  
+    it 'does not match when there are no arguments' do
+      ParensOnDeclarationWarning.should_not warn('def abc; end')
+    end
+
+    describe '#desc' do
+      it 'includes the name of the offending method' do
+        matches = ParensOnDeclarationWarning.new('(stdin)', 'def silly_monkey arg1, *rest; end').match?
+        matches[0].desc.should =~ /silly_monkey/
+      end
+    end
+  end
+  
+  context 'with a singleton definition' do
+    it 'matches when a method has arguments with no parens around them' do
+      ParensOnDeclarationWarning.should warn('def self.abc arg; end')
+    end
+
+    it 'matches when a method with no arguments is declared with parentheses' do
+      ParensOnDeclarationWarning.should warn('def self.abc(); end')
+    end
+
+    it 'does not match when arguments are surrounded by parentheses' do
+      ParensOnDeclarationWarning.should_not warn('def self.abc(arg); end')
+    end
+
+    it 'does not match when there are no arguments' do
+      ParensOnDeclarationWarning.should_not warn('def self.abc; end')
+    end
+
+    describe '#desc' do
+      it 'includes the name of the offending method' do
+        matches = ParensOnDeclarationWarning.new('(stdin)', 'def self.silly_monkey arg1, *rest; end').match?
+        matches[0].desc.should =~ /silly_monkey/
+      end
+    end
+  end
+end

data/spec/warning_specs/rescue_exception_spec.rb

@@ -0,0 +1,105 @@
+require_relative 'spec_helper'
+
+describe RescueExceptionWarning do
+  it 'is a file-based warning' do
+    RescueExceptionWarning.new('(stdin)', 'hello').should be_a(FileWarning)
+  end
+
+  it 'matches against a rescue of Exception as the only type' do
+    RescueExceptionWarning.should warn('begin; puts x; rescue Exception; end')
+  end
+  
+  it 'does not match when a rescue of StandardError is used' do
+    RescueExceptionWarning.should_not warn('begin; puts x; rescue StandardError; end')
+  end
+  
+  it 'matches against a rescue of Exception with an additional identifier' do
+    RescueExceptionWarning.should warn('begin; puts x; rescue Exception => e; end')
+  end
+  
+  it 'does not match when a rescue of StandardError is used with an additional identifier' do
+    RescueExceptionWarning.should_not warn('begin; puts x; rescue StandardError => e; end')
+  end
+  
+  it 'matches against a rescue of Exception that is specified second' do
+    RescueExceptionWarning.should warn('begin; puts x; rescue StandardError, Exception; end')
+  end
+  
+  it 'does not match when a rescue of StandardError is specified second' do
+    RescueExceptionWarning.should_not warn('begin; puts x; rescue StandardError, StandardError; end')
+  end
+  
+  it 'matches against a rescue of Exception that is specified second w/ addl identifier' do
+    RescueExceptionWarning.should warn('begin; puts x; rescue StandardError, Exception => err; end')
+  end
+  
+  it 'does not match when a rescue of StandardError is specified second w/ addl identifier' do
+    RescueExceptionWarning.should_not warn('begin; puts x; rescue StandardError, StandardError => err; end')
+  end
+
+  describe '#fix' do
+    it 'fixes a rescue of Exception as the only type' do
+      input = <<-EOF
+begin
+  puts x
+rescue Exception  # bad
+end
+EOF
+      output = <<-EOF
+begin
+  puts x
+rescue StandardError  # bad
+end
+EOF
+      RescueExceptionWarning.new('(stdin)', input).match?(input).first.fix.should == output
+    end
+    
+    it 'fixes a rescue of Exception with an additional identifier' do
+      input = <<-EOF
+begin
+  puts x
+rescue Exception => e  # bad
+end
+EOF
+      output = <<-EOF
+begin
+  puts x
+rescue StandardError => e  # bad
+end
+EOF
+      RescueExceptionWarning.new('(stdin)', input).match?(input).first.fix.should == output
+    end
+    
+    it 'fixes a rescue of Exception that is specified second' do
+      input = <<-EOF
+begin
+  puts x
+rescue StandardError, Exception  # bad
+end
+EOF
+      output = <<-EOF
+begin
+  puts x
+rescue StandardError, StandardError  # bad
+end
+EOF
+      RescueExceptionWarning.new('(stdin)', input).match?(input).first.fix.should == output
+    end
+    
+    it 'fixes a rescue of Exception that is specified second w/ addl identifier' do
+      input = <<-EOF
+begin
+  puts x
+rescue StandardError, Exception => e  # bad
+end
+EOF
+      output = <<-EOF
+begin
+  puts x
+rescue StandardError, StandardError => e  # bad
+end
+EOF
+      RescueExceptionWarning.new('(stdin)', input).match?(input).first.fix.should == output
+    end
+  end
+end

data/spec/warning_specs/semicolon_spec.rb

@@ -0,0 +1,58 @@
+require_relative 'spec_helper'
+
+describe SemicolonWarning do
+  it 'is a line-based warning' do
+    SemicolonWarning.new('(stdin)', 'hello').should be_a(LineWarning)
+  end
+
+  it 'matches when a semicolon splits two expressions' do
+    SemicolonWarning.should warn('puts x; puts y')
+  end
+
+  it 'matches when a semicolon splits two expressions that have strings' do
+    SemicolonWarning.should warn('puts "x"; puts "y"')
+  end
+
+  it "doesn't match when a semicolon is in a string" do
+    SemicolonWarning.should_not warn('puts "x;y"')
+  end
+
+  it "doesn't match when a semicolon is in a single-quoted string" do
+    SemicolonWarning.should_not warn("puts 'x;y'")
+  end
+
+  it "doesn't match when a semicolon is used in an Exception definition" do
+    SemicolonWarning.should_not warn('class AError < BError; end"')
+  end
+
+  it 'has a lower severity when quotes are involved due to unsure-ness' do
+    SemicolonWarning.new('(stdin)', "hello' world' ; there").severity.should <
+    SemicolonWarning.new('(stdin)', 'hello world ; there').severity
+  end
+
+  it 'has a remotely descriptive description' do
+    SemicolonWarning.new('(stdin)', 'hello ; world').desc.should =~ /semicolon/
+  end
+
+  it "doesn't match when a semicolon is in a comment" do
+    SemicolonWarning.should_not warn("hello # indeed; i agree")
+  end
+
+  describe '#fix' do
+    it 'converts the simplest semicolon use to two lines' do
+      SemicolonWarning.should correct_to('a;b', "a\nb")
+    end
+
+    it 'converts the simplest triple semicolon use to two lines' do
+      SemicolonWarning.should correct_to('a;b;c', "a\nb\nc")
+    end
+
+    it 'maintains indentation on new lines' do
+      SemicolonWarning.should correct_to('  a;b', "  a\n  b")
+    end
+
+    it 'maintains indentation on all new lines' do
+      SemicolonWarning.should correct_to('  a;b;c', "  a\n  b\n  c")
+    end
+  end
+end

data/spec/warning_specs/spec_helper.rb

@@ -0,0 +1 @@
+require_relative '../spec_helper'

data/spec/warning_specs/useless_double_quotes_spec.rb

@@ -0,0 +1,74 @@
+require_relative 'spec_helper'
+
+describe UselessDoubleQuotesWarning do
+  it 'is a file-based warning' do
+    UselessDoubleQuotesWarning.new('(stdin)', 'hello').should be_a(FileWarning)
+  end
+
+  it 'matches when a simple string is in double quotes unnecessarily' do
+    UselessDoubleQuotesWarning.should warn('simple "example, okay?"')
+  end
+  
+  it 'matches when a simple string is in %Q{} unnecessarily' do
+    UselessDoubleQuotesWarning.should warn('simple %Q{example, okay?}')
+  end
+  
+  it 'does not match when an escape sequence is used' do
+    UselessDoubleQuotesWarning.should_not warn('simple "example\n okay?"')
+  end
+  
+  it 'does not match when an apostrophe is present' do
+    UselessDoubleQuotesWarning.should_not warn('simple "example\' okay?"')
+  end
+  
+  it 'does not match when text interpolation is used' do
+    UselessDoubleQuotesWarning.should_not warn('simple "exaple\n #{h stuff} okay?"')
+  end
+  
+  it 'does match when a useless double-quoted string is used inside text interpolation' do
+    UselessDoubleQuotesWarning.should warn('simple "example, #{h "guy"} okay?"')
+  end
+  
+  it 'does not warn about single quotes that are nice and simple' do
+    UselessDoubleQuotesWarning.should_not warn("simple 'string is okay'")
+  end
+  
+  it 'does not warn about %q syntax that are simple' do
+    UselessDoubleQuotesWarning.should_not warn("simple %q{string is okay}")
+  end
+
+  describe '#desc' do
+    it 'properly quotes the improperly quoted text' do
+      matches = UselessDoubleQuotesWarning.new('(stdin)', 'simple "example, #{h "guy"} okay?"').match?
+      matches[0].desc.should =~ /'guy'/
+    end
+
+    it 'properly quotes the improperly quoted text with %Q{}' do
+      matches = UselessDoubleQuotesWarning.new('(stdin)', 'simple "example, #{h %Q{guy}} okay?"').match?
+      matches[0].desc.should =~ /%q{guy}/
+    end
+  end
+
+  describe '#fix' do
+    it 'fixes a simple string using double quotes unnecessarily' do
+      checker = UselessDoubleQuotesWarning.new('(stdin)', 'simple "example, okay?"')
+      warnings = checker.match?
+      warnings.size.should == 1
+      warnings.first.fix('simple "example, okay?"').should == "simple 'example, okay?'"
+    end
+    
+    it 'fixes a simple string using %Q{} unnecessarily' do
+      checker = UselessDoubleQuotesWarning.new('(stdin)', 'simple %Q{example, okay?}')
+      warnings = checker.match?
+      warnings.size.should == 1
+      warnings.first.fix('simple %Q{example, okay?}').should == "simple %q{example, okay?}"
+    end
+        
+    it 'fixes a simple string inside a complex one' do
+      checker = UselessDoubleQuotesWarning.new('(stdin)', 'simple "example, #{h "guy"} okay?"')
+      warnings = checker.match?
+      warnings.size.should == 1
+      warnings.first.fix('simple "example, #{h "guy"} okay?"').should == 'simple "example, #{h \'guy\'} okay?"'
+    end
+  end
+end

data/status_reports/2010/12/2010-12-14.md

@@ -0,0 +1,163 @@
+Today, I've pushed significant work on Laser. It's still very rough around the edges, but I've got it doing the following new, cool, and somewhat-advanced analyses:
+
+## Using a semicolon to separate statements
+
+If you'd like to warn against using a semicolon to separate statements on a single line, you can turn this warning on. However, due to personal preference, if you do this:
+
+    class MyError < StandardError; end
+
+it won't complain. This, though:
+
+    puts x; puts y
+
+will be an error. Laser is capable of fixing this error while maintaining indentation levels, up to arbitrary number of violating semicolons:
+
+    # some comment
+      p x; p y; p z; p 10
+
+becomes
+
+    # some comment
+      p x
+      p y
+      p z
+      p 10
+
+Cool, eh? I think I have this one nailed down to 100% accuracy, too.
+
+## Whitespace Tomfoolery
+
+Two separate ones here, extra blank lines and trailing whitespace. Both of these are significant mainly because when you violate them, you hurt signal-to-noise in VCS diffs. Committing 2 rows deleted and added with just trailing whitespace differences is just a shame.
+
+### Extra Blank Lines
+
+Ever leave blank lines at the end of your file? This warning tells you how many lines you left at the end, and fixes them if you wish.
+
+### Trailing Whitespace
+
+Extra spaces and tabs at the end of a line fall in this category, and can be fixed without disturbing the source code.
+
+## Operator Spacing
+
+This one is a bit dicy, but it tries to enforce spacing between operators. This gets tough because of lines with block declarations (where `|`s form the variable declaration area in a block, and do not act as a binary or operator), array splatting, block argument declarations, and so on. That's mainly a problem if you use regexes, which the current implementation does use. The parser will be employed shortly to remedy this situation.
+
+## Misaligned Indentation
+
+This is another one that needs a bit of an overhaul, but it works pretty well so far. This warning checks how well you indent, namely, that you indent at consistent multiples, and that you unindent evenly. However, it doesn't yet take into account line continuation, where you should then indent relevant to the previous line (and not via the multiplication pattern). So it can detect and correct these mistakes:
+
+    if x
+      if y
+          if z
+            p x
+          end
+        end
+        end
+
+becoming
+
+    if x
+      if y
+        if z
+          p x
+        end
+      end
+    end
+
+Cool eh? It does make some mistakes though, and there are definite examples in the laser code itself that this will mess up on.
+
+## Line Length
+
+Line Length is a fun one!
+
+The line length warnings let you specify multiple levels of severity for different violations, such as a level 2 warning for being between 80-89 chars and a 4 for 90+. Detecting this is extremely simple. Also, it considers whitespace stripping when calculating a line's minimum possible length.
+
+The really fun part is *fixing* it. Because Ruby code is sensitive to newlines, we can't just break it up into neat 80-char lines on the whitespace. So there's a few quick heuristics currently in play that I think are significant to brag about.
+
+### Comment Rearranging
+
+If a line is over the limit, but it has a comment at the end of it, we know we can take the comment and put it on the line above. It really belongs there anyway if it's going off the edge – the line it's describing is long enough to go near the edge, so it's probably quite complex. Its comment should have its own line.
+
+This heuristic however could create a *new* line that's over the limit, if the comment is comically long. So we also break the comment into correctly-sized lines, all indented to match the original line.
+
+An example, if the max line length is 20:
+
+    puts x * y * z / a # this computes a significant equation involving math
+
+you'll get back:
+
+    # this computes a
+    # significant
+    # equation involving
+    # math
+    # puts x * y * z / a
+
+which still has no line length violations! It naturally smooths out at longer line lengths.
+
+### Guard rearranging
+
+Here's one that bugs me. When I write a conditional Exception raise, I think of it this way:
+
+    raise FooBarError.new('Steve forgot to write the Foo bar library') unless steve.finished?
+
+but that's usually way over the line length limit. In truth, I should check it in like this:
+
+    unless steve.finished?
+      raise FooBarError.new('Steve forgot to write the Foo bar library')
+    end
+
+And if you use Laser now, you can leave code in the first form and it will transform to the second form! In fact, it works for multiple guards, too:
+
+    raise FooBarError.new('Steve forgot to write the Foo bar library') unless steve.finished?(schedule) if foo_bar.missing?(search_results) unless working?(test_data, &test_proc)
+
+laser magically transforms into:
+
+    unless working?(test_data, &test_proc)
+      if foo_bar.missing?(search_results)
+        unless steve.finished?(schedule)
+          raise FooBarError.new('Steve forgot to write the Foo bar library')
+        end
+      end
+    end
+
+Which is clean and better. It actually picks up on-the-line cases I missed on a somewhat regular basis!
+
+That's all for line length shortening. I know there's a lot more to do with continued lines (ending a line with a `+` token before the line-length cutoff, for example, means you know you can break the line into a new one at that point, resulting in a smaller problem and 1 valid line. Repeating this with all the safe tokens should result in a *lot* of progress.
+
+## Inline comment spacing
+
+My style guide (derived mainly from the Google style guide, with a few exceptions that everyone takes because it's a wee bit off) says that inline comments must have exactly 2 spaces between the last non-whitespace character and the hash mark beginning the comment. This is easily detected, enforced, and corrected. So Laser does!
+
+## Unnecessary Double Quotes
+
+When you use double quotes, the parser has to go and check for string interpolation and escape sequences. This is also true when you use the `%Q{}` syntax. Thus it is slower to use double quotes or `%Q{}` when you don't need those features. Laser detects this and corrects double-quotes to single quotes (unless there is an escape sequence in the text or an apostrophe) and `%Q{}` to `%q{}`. It uses the raw AST, so it isn't error-prone like the regex-based passes.
+
+## `rescue Exception`
+
+is bad! If you're rescuing Exception, you're rescuing a *lot* of things. You're covering up syntax errors. Just about the only thing you don't rescue is `SystemExit`. Almost always, you should be `rescue`ing `StandardError`. Laser currently can detect this based on the AST in all cases, but it cannot auto-correct them yet.
+
+# Up Next: Immediate
+
+Next, I'm going to start defining the API for constant-ness, with a tag on the AST that I'll make a pass to infer. I'll also be adding
+
+    default_attr_accessor :pure, false
+
+to Method and Proc, so methods can be annotated as Pure. Thus, a method call on a constant object with constant arguments (if any) and a constant proc for a block (because it contains only pure calls...) is itself a constant expression. All these rules can be enumerated and inferred, and once the standard library batch of annotations is underway a lot of cool examples of success are going to come out of this. For example, [Rubinius](http://rubini.us) could use our constant-ness evaluator to (with a flag of course, not by default) allow constant assignment in methods to constant expressions:
+
+    def enable_global_settings
+      LOGGER = DEBUG_MODE ? StdoutLogger.new : nil
+    end
+
+# Down The Line
+
+Here's a quick brain dump of down-the-line ideas:
+
+* Next large goal: Load in class and method defs in the main, simple cases, and hammer out an annotation system and a LALR(1) parser for it. Use racc to implement parser.
+* I could discuss getting the annotations contributed to RubySpec. That's a bit boastful but hey, if they're accurate, they could be helpful.
+* I'll be starting with the assumption that type annotations are available. That is because, in the spirit of [Gilad's pluggable types](http://bracha.org/pluggableTypesPosition.pdf) inference can be provided as tooling, but is not necessary to develop the rich type system you wish to describe.
+* Rubinius could use an annotated method to improve code paths.
+* I could dump the basic flow data I collect, including types of blocks and return types, variables, etc. to a database or YAML or something. I'll be getting a lot. That YAML could be integrated into an editor to provide hover-over type information. Smart autocomplete could be within reach, not that RubyMine is that bad.
+* A few more syntax things should get done, and I need to overhaul how tokens come out of the lexer process, as right now I'm just handling them raw, which makes for horrible-to-maintain code.
+* Coverage is near-100% in my eyes. The specs are just wonderful. There are a couple known bugs and those are in my sights.
+* I tried integrating with Redcar to get an automatic "fix unnecessary double quotes" plugin going, but I ran into huge trouble. Laser needs Ruby 1.9.2, and Redcar uses JRuby, but for some reason when I ran redcar with `rvm use 1.9.2-head`, it blows up on startup. If I run redcar with `rvm use system`, it runs just as dandily as always, but now Laser won't run because it needs 1.9.2. Probably some loader magic to do to find a 1.9 ruby executable, potentially having to interact with `rvm` to infer it.
+
+Stay tuned, as always, for more.