wegolint 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+gemspec
+gem 'rspec'
+gem 'debugger'

data/Gemfile.lock

@@ -0,0 +1,33 @@
+PATH
+  remote: .
+  specs:
+    wegolint (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    columnize (0.3.6)
+    debugger (1.2.0)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.1.1)
+      debugger-ruby_core_source (~> 1.1.3)
+    debugger-linecache (1.1.2)
+      debugger-ruby_core_source (>= 1.1.1)
+    debugger-ruby_core_source (1.1.3)
+    diff-lcs (1.1.3)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  debugger
+  rspec
+  wegolint!

data/README.md

@@ -0,0 +1,23 @@
+## What is it?
+This is a tool that validates a code file for a set of style guide rules. These
+rules are run along with the standard parser for the given language. The main
+use for this tool is to pass errors and line numbers to the [Syntastic Vim
+plugin](https://github.com/scrooloose/syntastic).
+
+## Installation Steps
+1. Install syntastic fork into `~/.vim/bundle/`:
+`git clone git://github.com/tristil/syntastic.git` (you should be using
+[pathogen](https://github.com/tpope/vim-pathogen) if you aren't already)
+2. Install the `wegolint` gem: `gem install wegolint` 
+3. Put these lines in your `.vimrc`:
+
+```vim
+let syntastic_auto_loc_list=1                                                   
+let g:syntastic_quiet_warnings=1                                                
+let g:syntastic_ruby_checker='wegolint'                                         
+let g:syntastic_javascript_checker='wegolint'    
+```
+(first two are optional but recommended for using Syntastic)
+
+## Screenshot with Syntastic
+![Screenshot](http://dl.dropbox.com/u/48928587/Screenshots/h.png)

data/bin/wegolint

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'wegolint'
+
+linter = WegoLint::WegoLinter.new(ARGV[0])
+linter.lint!
+puts linter.output

data/lib/init.rb

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

data/lib/wegolint.rb

@@ -0,0 +1,102 @@
+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

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+end

data/spec/wegolint_spec.rb

@@ -0,0 +1,199 @@
+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

data/wegolint.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |s|
+  s.name        = 'wegolint'
+  s.version     = '0.0.1'
+  s.date        = '2012-09-16'
+  s.summary     = 'Parses code for style guide violations'
+  s.description = <<-EOF
+Validates code according to style guide rules for an organization and outputs
+them as error statements that can be consumed by another program.
+EOF
+  s.authors     = ["Joseph Method"]
+  s.email       = 'jmethod@wegowise.com'
+  s.files         = `git ls-files`.split("\n")
+  s.homepage    = ''
+  s.require_paths = ['lib']
+  s.executables = ['wegolint']
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: wegolint
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Joseph Method
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-16 00:00:00.000000000 Z
+dependencies: []
+description: ! 'Validates code according to style guide rules for an organization
+  and outputs
+
+  them as error statements that can be consumed by another program.
+
+'
+email: jmethod@wegowise.com
+executables:
+- wegolint
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- bin/wegolint
+- lib/init.rb
+- lib/wegolint.rb
+- spec/spec_helper.rb
+- spec/wegolint_spec.rb
+- wegolint.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Parses code for style guide violations
+test_files: []