wegolint 0.0.1 → 0.0.3

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format progress
+--debug

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    wegolint (0.0.1)
+    wegolint (0.0.3)
 
 GEM
   remote: http://rubygems.org/

data/Rakefile

@@ -0,0 +1,6 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/bin/wegolint

@@ -2,6 +2,12 @@
 
 require 'wegolint'
 
+unless ARGV[0]
+  puts "USAGE: wegolint <file>"
+  exit
+end
+
 linter = WegoLint::WegoLinter.new(ARGV[0])
+linter.load_rules
 linter.lint!
 puts linter.output

data/lib/wegolint/dsl.rb

@@ -0,0 +1,37 @@
+module WegoLint
+  module DSL
+    module RuleDirectives
+      @@collapse_quotes = false
+
+      def included(klass)
+        @@pattern = nil
+      end
+
+      def pattern(pattern = nil)
+        @@pattern = pattern if pattern
+        @@pattern
+      end
+
+      def collapse_quotes
+        @@collapse_quotes = true
+      end
+
+      def collapse_quotes?
+        @@collapse_quotes
+      end
+    end
+
+    def language(name, &block)
+      WegoLint::RuleRegistry.instance.language_context = name
+      yield
+      WegoLint::RuleRegistry.instance.language_context = :general
+    end
+
+    def rule(description, &rule_block)
+      rule = WegoLint::RuleRegistry.instance.add_rule(description, rule_block)
+      rule
+    end
+  end
+end
+
+extend WegoLint::DSL

data/lib/wegolint/rule.rb

@@ -0,0 +1,42 @@
+module WegoLint; end
+
+class WegoLint::Rule
+
+  attr_accessor :errors, :language, :description
+
+  @@pattern = nil
+
+  def initialize(description, language = :general)
+    @errors = []
+    @language = language
+    @output = ""
+    @description = description
+  end
+
+  def run(text)
+    text.split("\n").each_with_index do |line, index|
+      line = collapse_quotes(line) if self.class.collapse_quotes?
+      if line =~ self.class.pattern
+        @errors << {message: description, line_number: index + 1 }
+      end
+    end
+  end
+
+  ##############################################################################
+  private
+
+  def self.block_not_padded
+    # This won't work with chained blocks on one line
+    no_space_beginning_block = /\{[\w\|'"].*\}/
+    no_space_end_block = /\{.*[\w'"]\}/
+    /(#{no_space_beginning_block}|#{no_space_end_block})/
+  end
+
+  def collapse_quotes(line)
+    newline = line
+    ['"', "'"].each do |char|
+      newline.gsub!(/#{char}.+?#{char}/, "#{char}TEST#{char}")
+    end
+    newline
+  end
+end

data/lib/wegolint/rule_registry.rb

@@ -0,0 +1,57 @@
+module WegoLint; end
+
+require 'singleton'
+
+class WegoLint::RuleRegistry
+  include Singleton
+
+  @@rule_count = 0
+
+  def self.rule_count
+    @@rule_count
+  end
+
+  def self.rule_count=(rule_count)
+    @@rule_count = rule_count
+  end
+
+  attr_accessor :language_context, :rules
+
+  def initialize
+    @rule_id = 0
+    @rules = {}
+    @language_context = :general
+  end
+
+  def find_by_description(description)
+    rules.keys.each do |key|
+      match = rules[key].find {|rule| rule.description == description }
+      return match if match
+    end
+    nil
+  end
+
+  def load_rules
+    Dir[File.dirname(__FILE__) + '/rules/*'].each { |rule| require rule }
+  end
+
+  # Pattern stolen from rspec
+  def add_rule(description, block)
+    WegoLint::RuleRegistry::rule_count += 1
+    klass = WegoLint::RuleRegistry.const_set("Rule_#{WegoLint::RuleRegistry::rule_count}",
+             subclass(WegoLint::Rule, block))
+    @rules[@language_context] = [] unless @rules[@language_context]
+    rule = klass.new(description, @language_context)
+    @rules[@language_context] << rule
+    rule
+  end
+
+  private
+
+  def subclass(parent, block)
+    subclass = Class.new(parent)
+    subclass.send(:extend, WegoLint::DSL::RuleDirectives.clone)
+    subclass.module_eval(&block) if block
+    subclass
+  end
+end

data/lib/wegolint/rules/general.rb

@@ -0,0 +1,15 @@
+rule "More than eighty characters" do
+  pattern  /^.{80}.+$/
+end
+
+rule "Hard tabs (use soft tabs)" do
+  pattern  /\t/
+end
+
+rule "Whitespace at end of line" do
+  pattern /^.*\w+.*\s+$/
+end
+
+rule "Opening curly brace on its own line" do
+  pattern /^\s*\{\s*$/
+end

data/lib/wegolint/rules/ruby.rb

@@ -0,0 +1,27 @@
+language :ruby do
+  rule 'Space should be around block { |param| foo }' do
+    pattern /[\.\s]#{block_not_padded}/
+
+    collapse_quotes
+  end
+
+  rule 'No spaces after (, [ or before ], )' do
+    collapse_quotes
+
+    def self.no_spaces_padding_parens
+      space = /[ ]/
+      left_parens = /[\[\(]/
+      right_parens = /[\]\)]/
+      space_after_left_parens = /#{left_parens}#{space}/
+      space_before_right_parens =
+      /^(?!\s+#{right_parens}).*#{space}#{right_parens}/
+      /(?:#{space_after_left_parens}|#{space_before_right_parens})/
+    end
+
+    pattern no_spaces_padding_parens
+  end
+
+  rule 'Parentheses should be around function parameters' do
+    pattern /def \w+ \w/
+  end
+end

data/lib/wegolint/wegolinter.rb

@@ -0,0 +1,79 @@
+module WegoLint; end
+
+require 'stringio'
+
+class WegoLint::WegoLinter
+  def initialize(filename)
+    @filename = filename
+    @filetype = File.extname(@filename)
+    @ruleset = @filetype == '.js' ? :javascript : :ruby
+    @output = ''
+  end
+
+  def lint!
+    @output = run_language_parser
+    parse_file
+  end
+
+  def rules
+    WegoLint::RuleRegistry.instance.rules
+  end
+
+  def output
+    @output
+  end
+
+  def load_rules
+    WegoLint::RuleRegistry.instance.load_rules
+  end
+
+  ##############################################################################
+  private
+
+  def parse_file
+    File.open(@filename, 'r') do |file|
+      text = file.read
+      apply_rules(text, :general)
+      apply_rules(text, @ruleset)
+    end
+  end
+
+  def run_language_parser
+    if @filetype == ".js"
+      command = 'jsl -nologo -nofilelisting -nosummary -nocontext -process'
+      `#{command} #{@filename} 2>&1`
+    else
+      `ruby -w -T1 -c #{@filename} 2>&1`
+    end
+  end
+
+  # The real algorithm for this has to find the first instance of any pair,
+  # strip it, start over, find the second instance, strip it, start over, etc.
+  def collapse_quotes(line)
+    newline = line
+    ['"', "'"].each do |char|
+      newline.gsub!(/#{char}.+?#{char}/, "#{char}TEST#{char}")
+    end
+    newline
+  end
+
+  def apply_rules(text, ruleset = :general)
+    return unless rules[ruleset]
+    rules[ruleset].each do |rule|
+      rule.run(text)
+      @output += format_errors(rule.errors) + "\n" unless rule.errors.empty?
+    end
+  end
+
+  def format_errors(errors)
+    errors.collect { |error| format_error(error) }.join("\n")
+  end
+
+  def format_error(error)
+    if @ruleset == :ruby
+      "#{@filename}:#{error[:line_number]}: syntax error, #{error[:message]}"
+    elsif @ruleset == :javascript
+      "#{@filename}:#{error[:line_number]}: error: #{error[:message]}"
+    end
+  end
+end

data/lib/wegolint.rb

@@ -1,102 +1,5 @@
 module WegoLint; end
-
-require 'stringio'
-
-class WegoLint::WegoLinter
-  def initialize(filename)
-    @filename = filename
-    @filetype = File.extname(@filename)
-    @ruleset = @filetype == '.js' ? :javascript : :ruby
-    @output = ''
-  end
-
-  def lint!
-    @output = run_language_parser
-    parse_file
-  end
-
-  def rules
-    @rules ||= {
-      general: [
-      { name: 'More than eighty characters', pattern: /^.{80}.+$/ },
-      { name: 'Curly brace on its own line', pattern: /^\s*(\{|\})\s*$/ },
-      { name: "Hard tabs (use soft tabs)", pattern: /\t/ },
-      { name: 'Whitespace at end of line', pattern: /^.*\w+.*\s+\n$/ }],
-
-    ruby: [
-      { name: 'Space should be around block { |param| foo }',
-        pattern: /[\.\s]#{block_not_padded}/, collapse_quotes: true },
-      { name: 'No spaces after (, [ or before ], )',
-        pattern: no_spaces_padding_parens, collapse_quotes: true },
-      { name: 'No parentheses around function parameters',
-        pattern: /def \w+ \w/}]}
-  end
-
-  def output
-    @output
-  end
-
-  ##############################################################################
-  private
-
-  def parse_file
-    File.open(@filename, 'r') do |file|
-      line_number = 0
-      file.each_line do |line|
-        line_number += 1
-        apply_rules(line, line_number)
-        apply_rules(line, line_number, @ruleset)
-      end
-    end
-  end
-
-  def run_language_parser
-    if @filetype == ".js"
-      `jsl -nologo -nofilelisting -nosummary -nocontext -process #{@filename} 2>&1`
-    else
-      `ruby -w -T1 -c #{@filename} 2>&1`
-    end
-  end
-
-  def block_not_padded
-    # This won't work with chained blocks on one line
-    no_space_beginning_block = /\{[\w\|'"].*\}[\.\s]$/
-    no_space_end_block = /\{.*[\w'"]\}[\.\s]$/
-    /(#{no_space_beginning_block}|#{no_space_end_block})/
-  end
-
-  def no_spaces_padding_parens
-    space = /[ ]/
-    left_parens = /[\[\(]/
-    right_parens = /[\]\)]/
-    space_after_left_parens = /#{left_parens}#{space}/
-    space_before_right_parens = /^(?!\s+#{right_parens}).*#{space}#{right_parens}/
-    /(?:#{space_after_left_parens}|#{space_before_right_parens})/
-  end
-
-  # The real algorithm for this has to find the first instance of any pair,
-  # strip it, start over, find the second instance, strip it, start over, etc.
-  def collapse_quotes(line)
-    newline = line
-    ['"', "'"].each do |char|
-      newline.gsub!(/#{char}.+?#{char}/, "#{char}TEST#{char}")
-    end
-    newline
-  end
-
-  def apply_rules(line, line_number, ruleset = :general)
-    return unless rules[ruleset]
-
-    rules[ruleset].each do |rule|
-      line = collapse_quotes(line) if rule[:collapse_quotes]
-      if line =~ rule[:pattern]
-        if @filetype == ".js"
-          full_path = File.realpath(@filename)
-          @output += "#{full_path}(#{line_number}): SyntaxError: #{rule[:name]}\n"
-        else
-          @output += "#{@filename}:#{line_number}: syntax error, #{rule[:name]}\n"
-        end
-      end
-    end
-  end
-end
+require 'wegolint/rule_registry'
+require 'wegolint/rule'
+require 'wegolint/dsl'
+require 'wegolint/wegolinter'

data/spec/rule_registry_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+include WegoLint
+
+describe RuleRegistry do
+  let(:description) { 'A new rule' }
+  let(:block) { proc do
+    pattern /foo/
+  end }
+  let(:rule_registry) { RuleRegistry.clone.instance }
+
+  describe ".add_rule" do
+
+    let!(:subject) { rule_registry.add_rule(description, block) }
+
+    it "creates a subclass of Rule" do
+      subject.should be_a Rule
+    end
+
+    it "creates a rule with the specified pattern" do
+      subject.class.pattern.should == /foo/
+    end
+
+    context "when there are more than two rules" do
+      before do
+        rule_registry.add_rule('Another rule', proc { pattern /bar/ } )
+      end
+
+      it "creates a rule with the specified pattern" do
+        subject.class.pattern.should == /foo/
+      end
+    end
+  end
+
+  describe ".rules" do
+    it "rule is added to the general rules list when language is not set" do
+      rule_registry.add_rule(description, block)
+      rule = rule_registry.rules[:general].first
+      rule.description.should == 'A new rule'
+    end
+
+    it "rule is added to the language rules list when language is set" do
+      rule_registry.language_context = :ruby
+      rule_registry.add_rule('Another rule', block)
+      rule = rule_registry.rules[:ruby].first
+      rule.description.should == 'Another rule'
+    end
+  end
+end

data/spec/rule_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+include WegoLint
+
+describe Rule do
+  let(:rule_registry) { RuleRegistry.instance }
+  let(:subject) { rule_registry.find_by_description(description) }
+
+  before do
+    rule_registry.load_rules
+    subject.run(code)
+  end
+
+  describe "General errors" do
+    context "hard tab" do
+      let(:description) { "Hard tabs (use soft tabs)" }
+      let(:code) { "\t" }
+
+      it { should_have_error description, 1, :ruby }
+    end
+
+    context "whitespace at end of line" do
+      let(:description) { "Whitespace at end of line" }
+      let(:code) { "'foo'   \n" }
+
+      it { should_have_error description, 1, :ruby }
+    end
+
+    context "80 character limit" do
+      let(:description) { "More than eighty characters" }
+      let(:code) do
+        <<-EOF
+a = 1
+"kjkjkjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk"
+b = 3
+EOF
+      end
+
+      it { should_have_error description, 2, :ruby }
+    end
+
+  end
+
+  describe "Ruby errors" do
+    context "curly brace on its own line" do
+      let(:description) { "Opening curly brace on its own line" }
+      let(:code) do
+        <<-EOF
+q = 1
+{
+b = 1
+}
+c = a+b
+EOF
+      end
+
+      it { should_have_error description, 2, :ruby  }
+      it { should_not_have_error description, 4, :ruby  }
+    end
+
+    context "no space on inside of block" do
+      let(:description) { 'Space should be around block { |param| foo }' }
+      let(:code) do
+        <<-EOF
+a = 1
+['a','b','c'].each {|item| puts item }
+['a','b','c'].each { |item| puts item}
+b = 2
+EOF
+      end
+
+      it { should_have_error description, 2, :ruby  }
+      it { should_have_error description, 3, :ruby  }
+    end
+
+    context 'No spaces after (, [ or before ], )' do
+      let(:description) { 'No spaces after (, [ or before ], )' }
+      let(:code) do
+        <<-EOF
+b = [ 'a' ]
+def something( foo )
+  c = " [ a ] "
+  c = ' [ ] '
+  [ 'a', 'b' ].each { |line| puts " [ ] " }
+end
+doSomething(bar: 'baz', baz: 'bar', foo: 'bar', fa: 'lalalalalalaalalalalalala'
+            )
+EOF
+      end
+
+      it { should_have_error description, 1, :ruby  }
+      it { should_have_error description, 2, :ruby  }
+
+      context "when embedded in strings" do
+        it { should_not_have_error description, 3, :ruby  }
+        it { should_not_have_error description, 4, :ruby  }
+        it { should_have_error description, 5, :ruby  }
+        it { should_not_have_error description, 8, :ruby  }
+      end
+    end
+
+    context "No parentheses around function parameters" do
+      let(:description) { 'Parentheses should be around function parameters' }
+      let(:code) do
+        <<-EOF
+def something(foo)
+end
+def something foo, bar
+end
+def something
+end
+EOF
+      end
+
+      it { should_not_have_error description, 1, :ruby  }
+      it { should_have_error description, 3, :ruby  }
+      it { should_not_have_error description, 5, :ruby  }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -2,3 +2,20 @@ RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
 end
+
+require 'wegolint'
+
+def should_have_error message, line_number, language
+  message = build_error_message message, line_number, language
+  subject.errors.should include message
+end
+
+def should_not_have_error message, line_number, language
+  message = build_error_message message, line_number, language
+  subject.errors.should_not include message
+end
+
+def build_error_message message, line_number, language
+  { message: message, line_number: line_number }
+end
+

data/spec/wegolint_bin_spec.rb

@@ -0,0 +1,77 @@
+describe "wegolint bin" do
+  let(:file) { '/tmp/wegolint_spec/foo.rb' }
+  let(:args) { file }
+  let(:subject) { `bundle exec wegolint #{args} 2>&1` }
+  let(:code) { '' }
+
+  before do
+    FileUtils.mkdir_p '/tmp/wegolint_spec/'
+    File.open(file, 'w+') do |f|
+      f.write(code)
+    end
+  end
+
+  after do
+    File.unlink(file)
+    FileUtils.rmdir('/tmp/wegolint_spec')
+  end
+
+  context "without a file argument" do
+    let(:args) { '' }
+    it "without a file argument it provides usage instructions" do
+      subject.should =~ /USAGE:/
+    end
+  end
+
+  context "with a file that has no errors (ruby)" do
+    let(:code) do
+      <<-EOF
+def something
+  puts "hello world"
+end
+EOF
+    end
+
+    it "outputs a success message" do
+      subject.should == "Syntax OK\n"
+    end
+  end
+
+  context "with a file that has errors (ruby)" do
+    let(:code) do
+      <<-EOF
+a = "Loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"
+EOF
+    end
+
+    it "outputs ruby syntax parser format error message" do
+      subject.should == "Syntax OK\n#{file}:1: syntax error, More than eighty characters\n"
+    end
+  end
+
+  context "with a file that has no errors (javascript)" do
+    let(:file) { '/tmp/wegolint_spec/foo.js' }
+    let(:code) do
+      <<-EOF
+var something ='foo';
+EOF
+    end
+
+    it "outputs a success message" do
+      subject.should == "\n"
+    end
+  end
+
+  context "with a file that has errors (javascript)" do
+    let(:file) { '/tmp/wegolint_spec/foo.js' }
+    let(:code) do
+      <<-EOF
+var a = "Loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong";
+EOF
+    end
+
+    it "outputs ruby syntax parser format error message" do
+      subject.should == "#{file}:1: error: More than eighty characters\n"
+    end
+  end
+end

data/spec/wegolinter_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+include WegoLint
+
+describe WegoLinter do
+
+  let(:wegolinter) { WegoLinter.new('/tmp/wegolint_spec/foo.rb') }
+
+  before do
+    wegolinter.load_rules
+  end
+
+  describe "#rules" do
+    let(:subject) { wegolinter.rules }
+
+    it "loads rules from rules/ directory" do
+      subject.should_not be_empty
+    end
+
+    it "sorts rules into language groups" do
+      subject[:general].should_not be_empty
+      subject[:ruby].should_not be_empty
+      subject[:general].first.should be_a Rule
+    end
+  end
+
+  describe "#lint!" do
+    context "ruby parser syntax errors" do
+      let(:subject) { wegolinter.output }
+      let(:code) do
+        <<-EOF
+  Foo
+  end
+        EOF
+      end
+
+      before do
+        FileUtils.mkdir_p '/tmp/wegolint_spec/'
+        File.open('/tmp/wegolint_spec/foo.rb', 'w+') do |file|
+          file.write(code)
+        end
+        wegolinter.lint!
+      end
+
+      after do
+        File.unlink('/tmp/wegolint_spec/foo.rb')
+        FileUtils.rmdir('/tmp/wegolint_spec')
+      end
+
+      it { should include
+           "foo.rb:2: syntax error, unexpected keyword_end, expecting $end" }
+    end
+  end
+end

data/wegolint.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name        = 'wegolint'
-  s.version     = '0.0.1'
-  s.date        = '2012-09-16'
+  s.version     = '0.0.3'
+  s.date        = '2012-09-30'
   s.summary     = 'Parses code for style guide violations'
   s.description = <<-EOF
 Validates code according to style guide rules for an organization and outputs

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wegolint
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-16 00:00:00.000000000 Z
+date: 2012-09-30 00:00:00.000000000 Z
 dependencies: []
 description: ! 'Validates code according to style guide rules for an organization
   and outputs
@@ -24,14 +24,24 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - Gemfile
 - Gemfile.lock
 - README.md
+- Rakefile
 - bin/wegolint
-- lib/init.rb
 - lib/wegolint.rb
+- lib/wegolint/dsl.rb
+- lib/wegolint/rule.rb
+- lib/wegolint/rule_registry.rb
+- lib/wegolint/rules/general.rb
+- lib/wegolint/rules/ruby.rb
+- lib/wegolint/wegolinter.rb
+- spec/rule_registry_spec.rb
+- spec/rule_spec.rb
 - spec/spec_helper.rb
-- spec/wegolint_spec.rb
+- spec/wegolint_bin_spec.rb
+- spec/wegolinter_spec.rb
 - wegolint.gemspec
 homepage: ''
 licenses: []

data/lib/init.rb

@@ -1 +0,0 @@
-require 'wegolint'

data/spec/wegolint_spec.rb

@@ -1,199 +0,0 @@
-require 'spec_helper'
-require_relative '../lib/wegolint'
-
-include WegoLint
-
-describe WegoLinter do
-  let(:test_data_dir) { '/tmp/wegolint_spec'}
-  let(:wegolinter) { WegoLinter.new(file) }
-
-  subject { wegolinter.output }
-
-  before do
-    FileUtils.mkdir_p test_data_dir
-    File.open(file, 'w+') do |f|
-      f.write(code)
-    end
-    wegolinter.lint!
-  end
-
-  after do
-    File.unlink(file)
-    FileUtils.rmdir test_data_dir
-  end
-
-  describe "General errors" do
-    let(:file) { test_data_dir + '/foo.rb' }
-
-    context "hard tab" do
-      let(:code) { "\t" }
-
-      it { should_have_error "Hard tabs (use soft tabs)", 1, :ruby }
-    end
-
-    context "whitespace at end of line" do
-      let(:code) { "'foo'   \n" }
-
-      it { should_have_error "Whitespace at end of line", 1, :ruby }
-    end
-  end
-
-  describe "Ruby errors" do
-    let(:file) { test_data_dir + '/foo.rb' }
-
-    context "ruby parser syntax errors" do
-      let(:code) do
-        <<-EOF
-Foo
-end
-EOF
-      end
-
-      it { should_have_error "unexpected keyword_end, expecting $end",2, :ruby }
-    end
-
-    context "80 character limit" do
-      let(:code) do
-        <<-EOF
-a = 1
-"kjkjkjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk"
-b = 3
-EOF
-      end
-
-      it { should_have_error "More than eighty characters", 2, :ruby }
-    end
-
-    context "curly brace on its own line" do
-      let(:code) do
-        <<-EOF
-q = 1
-{
-b = 1 }
-c = a+b
-EOF
-      end
-
-      it { should_have_error "Curly brace on its own line", 2, :ruby  }
-    end
-
-    context "no space on inside of block" do
-      let(:code) do
-        <<-EOF
-a = 1
-['a','b','c'].each {|item| puts item }
-['a','b','c'].each { |item| puts item}
-b = 2
-EOF
-      end
-
-      it { should_have_error "Space should be around block", 2, :ruby  }
-      it { should_have_error "Space should be around block", 3, :ruby  }
-    end
-
-    context "no spaces after (, [ or before ], )" do
-      let(:code) do
-        <<-EOF
-b = [ 'a' ]
-def something( foo )
-  c = " [ a ] "
-  c = ' [ ] '
-  [ 'a', 'b' ].each { |line| puts " [ ] " }
-end
-doSomething(bar: 'baz', baz: 'bar', foo: 'bar', fa: 'lalalalalalaalalalalalala'
-            )
-EOF
-      end
-
-      it { should_have_error "No spaces after (", 1, :ruby  }
-      it { should_have_error "No spaces after (", 2, :ruby  }
-
-      context "when embedded in strings" do
-        it { should_not_have_error "No spaces after (", 3, :ruby  }
-        it { should_not_have_error "No spaces after (", 4, :ruby  }
-        it { should_have_error "No spaces after (", 5, :ruby  }
-        it { should_not_have_error "No spaces after (", 8, :ruby  }
-      end
-    end
-
-    context "No parentheses around function parameters" do
-      let(:code) do
-        <<-EOF
-def something(foo)
-end
-def something foo, bar
-end
-def something
-end
-EOF
-      end
-
-      it { should_not_have_error "No parentheses around", 1, :ruby  }
-      it { should_have_error "No parentheses around", 3, :ruby  }
-      it { should_not_have_error "No parentheses around", 5, :ruby  }
-    end
-
-  end
-
-  describe "Javascript errors" do
-    let(:file) { test_data_dir + '/foo.js' }
-
-    context "ruby parser syntax errors" do
-      let(:code) do
-        <<-EOF
-fah {
-}
-EOF
-      end
-
-      it { should_have_error 'missing ; before statement', 1, :javascript }
-    end
-
-    context "80 character limit" do
-      let(:code) do
-        <<-EOF
-var a = 1;
-"kjkjkjkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk";
-var b = 2;
-EOF
-      end
-
-      it { should_have_error "More than eighty characters", 2, :javascript }
-    end
-
-    context "curly brace on its own line" do
-      let(:code) do
-        <<-EOF
-var func = function()
-{
-var b = 1; }
-EOF
-      end
-
-      it { should_have_error "Curly brace on its own line", 2, :javascript }
-    end
-  end
-
-  def should_have_error message, line_number, language
-    message = build_error_message message, line_number, language
-    subject.should include message
-  end
-
-  def should_not_have_error message, line_number, language
-    message = build_error_message message, line_number, language
-    subject.should_not include message
-  end
-
-  def build_error_message message, line_number, language
-    if language == :ruby
-      name = "foo.rb"
-      line_number = ":#{line_number}:"
-      prefix = " syntax error,"
-    else
-      name = "foo.js"
-      line_number = "(#{line_number}):"
-      prefix = " SyntaxError:"
-    end
-    "#{name}#{line_number}#{prefix} #{message}"
-  end
-end