stylr 0.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d24c550f19bdc73beb58ad28bc25ae1a10295d0b
+  data.tar.gz: c4eb18254875e21ac141c4fbaabf6488a82c9bbe
+SHA512:
+  metadata.gz: adc05ab742724d576381d07e498b8992fd4f0c34342d5e36ec5b0192e3c91bc61cf03975c07139000c38bb6d7d6fa0bf1b3e0f4fe76fb50813803b400c66eabb
+  data.tar.gz: e5502a2c101be36b9ecd344dec9da4ee4d4ba813f67e8374e1513f6e43988cc99305779a718236b4e207b41505be3fbf3ba704606c4463f9ffa1f34e0b088adf

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in stylr.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    stylr (0.0.4)
+      main (~> 5.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    arrayfields (4.9.0)
+    chronic (0.10.2)
+    diff-lcs (1.2.5)
+    fattr (2.2.1)
+    main (5.2.0)
+      arrayfields (>= 4.7.4)
+      chronic (>= 0.6.2)
+      fattr (>= 2.2.0)
+      map (>= 5.1.0)
+    map (6.5.1)
+    rake (10.1.1)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  rake
+  rspec
+  stylr!

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Mark Billie & ThoughtWorks, Inc.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+<h1>stylr</h1>
+
+Check if source code conforms to some elements of the Github Ruby Style Guidelines ( https://github.com/styleguide/ruby )
+
+Kind of raw still.  Currently supports checking against the following:
+
+* Line length (user-configurable)
+* Missing parens around method definitions with parameters (ie, "def foo bar" is disallowed)
+* Trailing whitespace of any kind
+* Use of the 'and' or 'or' operators (&& and || are preferred)
+* Use of 'then' on a multiline if/then construct
+* Spacing around parens
+* Spacing around brackets (this is a little broken on multi-line arrays)
+* Spacing around curly braces (this is also a little broken)
+* Using the keyword 'for'
+* Spacing around commas
+* Using tab characters instead of soft tabs
+* Spacing around math operators (+, *, etc)
+
+Optionally checks for some metaprogramming, which you might not want in a large, enterprise codebase with varied levels of skill on your development team.  This is not a condemnation of these practices - most of them are good, idiomatic Ruby.  You might not, however, want your junior developers checking in lots of metaprogrammed code.  Pass the '--meta' flag to enable these checks.
+
+* eval
+* class_eval
+* instance_eval
+* module_eval
+* define_method
+* send
+
+All of these things are configurable via yml.  See "stylr.yml" in the repo, and place it in "~/.stylr.yml"
+
+Checks all *.rb files in the specified directory and subdirectories, excluding _spec.rb and _test.rb
+
+<b>Usage</b>
+
+./stylr /path/to/directory           # normal checks
+
+./stylr /path/to/directory --meta    # also check for use of metaprogramming

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/stylr

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require 'main'
+require 'stylr'
+
+module Stylr
+  Main {
+
+    argument('directory') {
+    description "The directory to be parsed."
+    cast :string
+  }
+
+  option('meta') {
+    default false
+    description "Check for metaprogramming violations.  Defaults to false."
+  }
+
+  def run
+    directory = params['directory'].values.first
+    meta = params['meta'].values.first ? true : false
+    dir_loader = DirLoader.new
+    dir_loader.load_dir(directory)
+
+    dir_loader.filenames.each do |filename|
+      puts "Checking #{filename}..."
+      FileParser.new(filename, Lint.new, true).violations?(meta)
+    end
+  end
+
+  }
+end
+

data/lib/stylr/dir_loader.rb

@@ -0,0 +1,16 @@
+class DirLoader
+  attr_reader :filenames
+
+  DEPTH = "**/**/**/**/**/**/**/**/**/**/**/**" # lol wut
+
+  def load_dir(dir)
+    @filenames = Dir[File.expand_path(dir) + DEPTH].select do |f|
+      File.file?(f) &&
+        f =~ /\.rb$/
+    end.reject do |f|
+        f =~ /_spec\.rb$/ || f =~ /_test\.rb$/
+    end
+  end
+
+end
+

data/lib/stylr/file_parser.rb

@@ -0,0 +1,67 @@
+module Stylr
+  class FileParser
+    attr_reader :lines
+
+    UniqueConstant = ";;;;;"
+
+    def initialize(file_path, lint, display = false)
+      @lines       = []
+      @lint        = lint
+      @display     = display
+      @file_string = File.read(file_path)
+    end
+
+    def violations?(meta = false)
+      pre_multiline_string_removal_length_check!
+      remove_multiline_strings!
+      assign_lines_with_numbers!
+
+      @lines.each do |array|
+        line, number = array
+        @lint.violation?(line, number)
+        @lint.exception_violation?(line, number)
+        @lint.meta_violation?(line, number) if meta
+      end
+
+      if @lint.errors.any?
+        display_errors if @display
+        true
+      else
+        display_no_error_message if @display
+        false
+      end
+    end
+
+    def assign_lines_with_numbers!
+      @file_string.each_with_index do |line, number|
+        @lines << [line, number + 1]
+      end
+    end
+
+    def pre_multiline_string_removal_length_check!
+      @file_string.split(/\n/).each_with_index do |line, number|
+        @lint.line_too_long_violation?(line, number + 1)
+      end
+    end
+
+    def remove_multiline_strings!
+      @file_string = @file_string.gsub(/\n/, UniqueConstant)
+      @file_string = @lint.strip_multiline_strings(@file_string)
+      @file_string = @file_string.gsub(/#{UniqueConstant}/, "#{UniqueConstant}\n")
+        @file_string = @file_string.split(/#{UniqueConstant}/)
+    end
+
+    def display_no_error_message
+      puts "Your file is free of errors."
+    end
+
+    def display_errors
+      puts "You have the following errors:"
+      @lint.errors.each do |hash|
+        error = hash.keys.first
+        line_number = hash.values.first
+        puts "Line #{line_number}: #{@lint.send(error)}"
+      end
+    end
+  end
+end

data/lib/stylr/lint.rb

@@ -0,0 +1,129 @@
+require 'yaml'
+
+class Lint
+  attr_reader :errors, :violations, :exception_violations, :metaprogramming_violations, :messages
+
+  def initialize
+    @errors = []
+    @config = YAML.load_file(ENV["HOME"] + "/.stylr.yml")
+    setup_class_values
+  end
+
+  def line_too_long_violation?(line, number = 1)
+    abstract_violation?(@line_too_long_violations, line, number)
+  end
+
+  def violation?(line, number = 1)
+    line = strip_strings(line)
+    abstract_violation?(@violations, line, number)
+  end
+
+  def meta_violation?(line, number = 1)
+    abstract_violation?(@metaprogramming_violations, line, number)
+  end
+
+  def exception_violation?(line, number = 1)
+    abstract_violation?(@exception_violations, line, number)
+  end
+
+  def strip_multiline_strings(string)
+    string.tap do |str|
+      str.gsub!(/""".*"""/, '""')
+      start = /<<-?[A-Z]+/
+      finish = (str[start] || "")[/[A-Z]+/]
+      regexp = /#{start}.*\b#{finish}\b/
+      str.gsub!(/#{str[regexp]}/,'""') if str[regexp]
+    end
+  end
+
+  def strip_strings(line)
+    line.gsub(/".*"/, '""').gsub(/'.*'/, "''")
+  end
+
+  private
+
+  def abstract_violation?(list, line, number)
+    list.each do |pattern, error|
+      @commented_line.each do |comment|
+        return false if line[comment]
+      end
+
+      if line[pattern]
+        @errors << { error => number }
+        return true
+      end
+    end
+    return false
+  end
+
+  def setup_class_values
+    @line_too_long_violations = {
+      /.{#{@config["line_length"]}}+/ => :line_too_long
+    }.delete_if { |_, v| !@config[v.to_s] }
+
+    @violations = {
+      /def (self\.)?\w+[!?]? .\w+/  => :missing_parens,
+      /( )+$/                       => :trailing_whitespace,
+      /\band\b/                     => :the_word_and,
+      /\bor\b/                      => :the_word_or,
+      /\bfor\b/                     => :the_word_for,
+      /\bif\b.*\bthen\b\n/          => :multiline_if_then,
+      /\(\s|\s\)/                   => :paren_spacing,
+      /\[\s|\s\]/                   => :bracket_spacing,
+      /[^\s][{}]|{[^\s]/            => :brace_spacing,
+      /,[^ \n]/                     => :comma_spacing,
+      /\t/                          => :no_soft_tabs,
+      /[^\s]\+/                     => :no_operator_spaces,
+      /\+[^\s=]/                    => :no_operator_spaces,
+      /[^\s]-/                      => :no_operator_spaces
+    }.delete_if { |_, v| !@config[v.to_s] }
+
+    @exception_violations = {
+      /rescue\s*(Exception)?$/      => :rescue_class_exception
+    }.delete_if { |_, v| !@config[v.to_s] }
+
+    @metaprogramming_violations = {
+      /\beval\b/                    => :used_eval,
+      /\bclass_eval\b/              => :used_class_eval,
+      /\bmodule_eval\b/             => :used_module_eval,
+      /\binstance_eval\b/           => :used_instance_eval,
+      /\bdefine_method\b/           => :used_define_method,
+      /\w+\.send.*".*#\{/           => :dynamic_invocation
+    }.delete_if { |_, v| !@config[v.to_s] }
+
+    @commented_line = [
+      /^\s*#/
+    ]
+
+    @messages = {
+      :missing_parens               => "You have omitted parentheses from a method definition with parameters.",
+      :line_too_long                => "Line length of #{@config['line_length']} characters or more.",
+      :trailing_whitespace          => "Trailing whitespace.",
+      :used_eval                    => "Used eval.",
+      :used_define_method           => "Used define_method.",
+      :dynamic_invocation           => "Dynamic invocation of a method.",
+      :rescue_class_exception       => "Rescuing class Exception.",
+      :the_word_and                 => "Used 'and'; please use && instead.",
+      :the_word_or                  => "Used 'or'; please use || instead.",
+      :the_word_for                 => "Used 'for'; please use an enumerator, or else explain yourself adequately to the team.",
+      :multiline_if_then            => "Used 'then' on a multiline if statement.",
+      :used_class_eval              => "Used class_eval.",
+      :used_module_eval             => "Used module_eval.",
+      :used_instance_eval           => "Used instance_eval.",
+      :paren_spacing                => "Space after ( or before ).",
+      :bracket_spacing              => "Space after [ or before ].",
+      :brace_spacing                => "No space around { or before }.",
+      :comma_spacing                => "No space after a comma.",
+      :no_soft_tabs                 => "Used tab characters; please use soft tabs.",
+      :no_operator_spaces           => "Please use spaces around operators."
+    }
+  end
+
+  def method_missing(method_name, *args, &block)
+    if @messages.keys.include?(method_name.to_sym)
+      @messages[method_name]
+    else
+      super(method_name, *args, &block)
+    end
+  end
+end

data/lib/stylr/version.rb

@@ -0,0 +1,3 @@
+module Stylr
+  VERSION = "0.0.6"
+end

data/lib/stylr.rb

@@ -0,0 +1,8 @@
+require "stylr/version"
+require "stylr/file_parser"
+require "stylr/lint"
+require "stylr/dir_loader"
+
+module Stylr
+  # Your code goes here...
+end

data/spec/dir_loader_spec.rb

@@ -0,0 +1,26 @@
+require "stylr"
+
+module Stylr
+  describe DirLoader do
+    let(:d) { DirLoader.new }
+
+    it "loads all ruby files in a directory" do
+      dir = "/Users/Thoughtworker/stylr/spec/dir"
+      d.load_dir(dir)
+      d.filenames.should == ["#{dir}/one.rb", "#{dir}/two.rb", "#{dir}/three.rb"].sort
+    end
+
+    it "loads all files even in a recursive structure" do
+      dir = "/Users/Thoughtworker/stylr/spec/rdir"
+      d.load_dir(dir)
+      d.filenames.should == ["#{dir}/one/one.rb", "#{dir}/two/two.rb", "#{dir}/three/three.rb", "#{dir}/base.rb"].sort
+    end
+
+    it "ignores specs" do
+      dir = "/Users/Thoughtworker/stylr/spec/sdir"
+      d.load_dir(dir)
+      d.filenames.should == []
+    end
+  end
+end
+

data/spec/file_parser_spec.rb

@@ -0,0 +1,83 @@
+require "stylr"
+
+module Stylr
+  YAML_FILE_LOCATION = "/Users/Thoughtworker/stylr/stylr.yml"
+  describe FileParser do
+    context "sample_1" do
+      before(:each) do
+        @string = "/Users/Thoughtworker/stylr/spec/txt/sample_1.rb"
+        @f = FileParser.new(@string, Lint.new)
+      end
+
+      it "checks the file for errors" do
+        @f.violations?.should be_false
+      end
+    end
+
+    context "sample_fail" do
+      before(:each) do
+        @string = "/Users/Thoughtworker/stylr/spec/txt/sample_fail.rb"
+        @f = FileParser.new(@string, Lint.new)
+      end
+
+      it "knows when something has failed" do
+        @f.violations?.should be_true
+      end
+    end
+
+    context "sample_pass2" do
+      before(:each) do
+        @string = "/Users/Thoughtworker/stylr/spec/txt/sample_pass2.rb"
+        @f = FileParser.new(@string, Lint.new)
+      end
+
+      it "doesn't break when shit appears in strings" do
+        @f.violations?.should be_false
+      end
+    end
+
+    context "sample_fail2" do
+      before(:each) do
+        @string = "/Users/Thoughtworker/stylr/spec/txt/sample_fail2.rb"
+        @f = FileParser.new(@string, Lint.new)
+      end
+
+      it "knows when something has failed" do
+        @f.violations?(meta = true).should be_true
+      end
+    end
+
+    context "sample_fail3" do
+      before(:each) do
+        @string = "/Users/Thoughtworker/stylr/spec/txt/sample_fail3.rb"
+        @f = FileParser.new(@string, Lint.new)
+      end
+
+      it "knows when something has failed" do
+        @f.violations?.should be_true
+      end
+    end
+
+    context "sample_fail4" do
+      before(:each) do
+        @string = "/Users/Thoughtworker/stylr/spec/txt/sample_fail4.rb"
+        @f = FileParser.new(@string, Lint.new)
+      end
+
+      it "knows when something has failed" do
+        @f.violations?.should be_false
+      end
+    end
+
+    context "sample_fail5" do
+      before(:each) do
+        @string = "/Users/Thoughtworker/stylr/spec/txt/sample_fail5.rb"
+        @f = FileParser.new(@string, Lint.new)
+      end
+
+      it "knows when something has failed" do
+        @f.violations?.should be_true
+      end
+    end
+  end
+end

data/spec/lint_spec.rb

@@ -0,0 +1,313 @@
+require "stylr"
+
+module Stylr
+  describe Lint do
+    let(:l) { Lint.new }
+
+    context "#violation?" do
+      context "missing_parens" do
+        it "wants parens around method definitions with args" do
+          l.violation?("def foo bar, baz").should be_true
+        end
+
+        it "does not need parens for methods with no args" do
+          l.violation?("def some_method").should be_false
+        end
+
+        it "using parens is good" do
+          l.violation?("def foo(bar, baz)").should be_false
+        end
+
+        it "using parens for methods with bang is the same" do
+          l.violation?("def foo!").should be_false
+        end
+
+        it "a bang method with args needs parens too" do
+          l.violation?("def foo! bar").should be_true
+        end
+
+        it "a question mark method without args is fine" do
+          l.violation?("def foo?").should be_false
+        end
+
+        it "a question mark method with args needs parens" do
+          l.violation?("def foo? bar").should be_true
+        end
+
+        it "class methods with bang+no args are fine" do
+          l.violation?("def self.foo!").should be_false
+        end
+
+        it "class methods with bang+args need parens" do
+          l.violation?("def self.foo! bar").should be_true
+        end
+
+        it "class methods with qmark+no args are fine" do
+          l.violation?("def self.foo?").should be_false
+        end
+
+        it "class methods with qmark+args need parens" do
+          l.violation?("def self.foo? bar").should be_true
+        end
+
+        it "positive case for bang" do
+          l.violation?("def foo!(bar)").should be_false
+        end
+
+        it "positive case for class method bang" do
+          l.violation?("def self.foo!(bar)").should be_false
+        end
+
+        it "positive case for qmark" do
+          l.violation?("def foo?(bar)").should be_false
+        end
+
+        it "positive case for class method qmark" do
+          l.violation?("def self.foo?(bar)").should be_false
+        end
+
+        it "acts the same for class methods" do
+          l.violation?("def self.something foo, bar").should be_true
+        end
+
+        it "no parens for class methods without args is fine too" do
+          l.violation?("def self.something").should be_false
+        end
+
+        it "arrays of args too need parens in the method def" do
+          l.violation?("def foo *args").should be_true
+        end
+      end
+
+      context "operator spacing" do
+        it "spaces around + are good" do
+          l.violation?("2+2").should be_true
+        end
+
+        it "on both sides" do
+          l.violation?("2 +2").should be_true
+        end
+
+        it "but += is ok" do
+          l.violation?("x += 2").should be_false
+        end
+
+        it "same with -" do
+          l.violation?("2-2").should be_true
+        end
+
+        it "-= is fine" do
+          l.violation?("x -= 3").should be_false
+        end
+      end
+
+      context "soft tabs" do
+        it "don't use actual tabs" do
+          l.violation?("\t").should be_true
+        end
+      end
+
+      context "space after open paren/bracket or before close paren/bracket" do
+        it "space after open paren is bad" do
+          l.violation?("def foo( bar)").should be_true
+        end
+
+        it "space before close paren is also bad" do
+          l.violation?("def foo(bar )").should be_true
+        end
+
+        it "space after open bracket is bad" do
+          l.violation?("list = [ 1, 2, 3]").should be_true
+        end
+      end
+
+      context "space around { and } is good" do
+        it "no space before { is bad" do
+          l.violation?("lambda{puts :foo}").should be_true
+        end
+
+        it "no space before } is bad" do
+          l.violation?("lambda { puts :foo}").should be_true
+        end
+
+        it "no space after { is also bad" do
+          l.violation?("{:foo }").should be_true
+        end
+
+        it "no space after } is fine" do
+          l.violation?("lambda { puts :foo }.call").should be_false
+        end
+      end
+
+      context "space after commas" do
+        it "should have a space after a comma" do
+          l.violation?("[1,2,3]").should be_true
+        end
+
+        it "can also pass..." do
+          l.violation?("[1, 2, 3]").should be_false
+        end
+
+        it "newline after a comma is fine" do
+          l.violation?(":a => 1,\n").should be_false
+        end
+      end
+
+      context "line_too_long" do
+        it "dislikes lines of >= 80 chars" do
+          l.line_too_long_violation?("#{'a' * 80}").should be_true
+        end
+      end
+
+      context "trailing_whitespace" do
+        it "whitespace at the end of the line is a no-no" do
+          l.violation?("def foo(bar) ").should be_true
+        end
+
+        it "a newline is ok by itself" do
+          l.violation?("\n").should be_false
+        end
+      end
+
+      context "and and or" do
+        it "the word 'and' is banned" do
+          l.violation?("foo and bar").should be_true
+        end
+
+        it "the word 'or' is also banned" do
+          l.violation?("1 or nil").should be_true
+        end
+      end
+
+      context "for loops" do
+        it "generally you should not use for loops" do
+          l.violation?("for x in list do").should be_true
+        end
+      end
+
+      context "multiline if then" do
+        it "should not use then in multiline if" do
+          l.violation?("if foo then\nbar\nend").should be_true
+        end
+
+        it "single line if then end is ok" do
+          l.violation?("if true then false end").should be_false
+        end
+      end
+
+      context "multiline strings" do
+        it "ignores multiline strings" do
+          l.strip_multiline_strings("sql = <<-SQL for and or SQL").should == "sql = \"\""
+        end
+
+        it "ignores the other kind too" do
+          l.strip_multiline_strings('"""foo bar baz"""').should == '""'
+        end
+      end
+
+      context "comments" do
+        it "ignores comments" do
+          l.violation?("# a comment").should be_false
+        end
+
+        it "ignores comments even when they otherwise violate the rules" do
+          l.violation?("# def foo bar").should be_false
+        end
+
+        it "does not care what violation the comment breaks" do
+          l.violation?("# and or def foo bar, baz").should be_false
+        end
+
+        it "ignores indented comments" do
+          l.violation?(" # def foo bar").should be_false
+        end
+
+        it "ignores comments indented with soft tabs" do
+          l.violation?("  # def foo bar").should be_false
+        end
+      end
+    end
+
+    context "#meta_violation?" do
+      it "can optionally check for metaprogramming" do
+        l.meta_violation?("eval").should be_true
+      end
+
+      it "fucking HATES define_method" do
+        l.meta_violation?("define_method").should be_true
+      end
+
+      it "dynamic method invocation via send is bad, mmkay?" do
+        l.meta_violation?('foo.send "foo_#{:bar}"').should be_true
+      end
+
+      it "class eval, why not?" do
+        l.meta_violation?("class_eval &block").should be_true
+      end
+
+      it "module eval is also naughty" do
+        l.meta_violation?("module_eval foo").should be_true
+      end
+
+      it "and even instance eval!" do
+        l.meta_violation?("instance_eval &block").should be_true
+      end
+    end
+
+    context "#exception_violation?" do
+      it "rescuing Exception is bad" do
+        l.exception_violation?("rescue Exception").should be_true
+      end
+
+      it "rescuing nothing is the same as rescuing Exception" do
+        l.exception_violation?("rescue    ").should be_true
+      end
+
+      it "rescuing an exception that ends with Exception is ok" do
+        l.violation?("rescue MyCustomException").should be_false
+      end
+    end
+
+    context "string stripping" do
+      it "removes strings so it doesn't break on them" do
+        l.strip_strings("def foo(\"bar\")").should == "def foo(\"\")"
+      end
+
+      it "does the same with single-quoted strings" do
+        l.strip_strings("def foo('bar')").should == "def foo('')"
+      end
+    end
+
+    context "error messages" do
+      it "keeps track of your mistakes and their lines, defaulting to line #1" do
+        l.violation?("def foo bar")
+        l.errors.first.values.should == [1]
+      end
+
+      it "knows what line number you fucked up on" do
+        l.violation?("def foo bar", 3)
+        l.errors.first.values.should == [3]
+      end
+
+      it "everything has an error message" do
+        expect do
+          l.violations.values.each do |violation|
+            l.messages.fetch(violation)
+          end
+          l.exception_violations.values.each do |exception_violation|
+            l.messages.fetch(exception_violation)
+          end
+          l.metaprogramming_violations.values.each do |metaprogramming_violation|
+            l.messages.fetch(metaprogramming_violation)
+          end
+        end.to_not raise_error
+      end
+    end
+
+    context "#method_missing" do
+      it "implements method_missing intelligently" do
+        expect { l.foo }.to raise_error
+      end
+    end
+  end
+end

data/spec/txt/sample_1.rb

@@ -0,0 +1,5 @@
+class Foo
+  def initialize(foo)
+    puts foo
+  end
+end

data/spec/txt/sample_fail.rb

@@ -0,0 +1,5 @@
+class Foo
+  def initialize bar
+    nil
+  end
+end

data/spec/txt/sample_fail2.rb

@@ -0,0 +1,9 @@
+class Foo
+  def initialize(bar)
+    @bar = bar
+  end
+
+  def some_bad_metaprogrammed_method(foo)
+    @bar.send("call_#{foo}")
+  end
+end

data/spec/txt/sample_fail3.rb

@@ -0,0 +1,9 @@
+class Foo
+  def something_risky(bar)
+    begin
+      # doesn't matter
+    rescue
+      nil
+    end
+  end
+end

data/spec/txt/sample_fail4.rb

@@ -0,0 +1,15 @@
+class TextFail
+  STRING = <<-EOS
+    def initialize foo, bar
+      and for or
+    end
+  EOS
+
+  def puts_a_string
+    """this is
+    one dumb for and or
+    big def foo bar, baz
+    def foo bar, baz
+    multiline string"""
+  end
+end

data/spec/txt/sample_fail5.rb

@@ -0,0 +1,5 @@
+class Foo
+  """
+  TENLETTERSTENLETTERSTENLETTERSTENLETTERSTENLETTERSTENLETTERSTENLETTERSTENLETTERSTENLETTERSTENLETTERSTENLETTERS
+  """
+end

data/spec/txt/sample_pass2.rb

@@ -0,0 +1,9 @@
+class Foo
+  def initialize(bar)
+    @bar = bar
+  end
+
+  def some_string
+    "and or for wat does you mean"
+  end
+end

data/stylr.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'stylr/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "stylr"
+  spec.version       = Stylr::VERSION
+  spec.authors       = ["Mark Billie"]
+  spec.email         = ["mbillie1@gmail.com"]
+  spec.description   = %q{An attempt at enforcing https://github.com/styleguide/ruby}
+  spec.summary       = %q{stylr - enforcing Ruby coding style standards}
+  spec.homepage      = "https://github.com/yaaase/stylr.git"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency     "main",    "~> 5.2.0"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rake"
+end

data/stylr.yml

@@ -0,0 +1,21 @@
+line_length: 80
+line_too_long: true
+missing_parens: true
+trailing_whitespace: true
+the_word_and: true
+the_word_or: true
+the_word_for: true
+multiline_if_then: true
+paren_spacing: true
+bracket_spacing: true
+brace_spacing: true
+comma_spacing: true
+no_soft_tabs: true
+no_operator_spaces: true
+rescue_class_exception: true
+used_eval: true
+used_class_eval: true
+used_module_eval: true
+used_instance_eval: true
+used_define_method: true
+dynamic_invocation: true

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: stylr
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+platform: ruby
+authors:
+- Mark Billie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: main
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An attempt at enforcing https://github.com/styleguide/ruby
+email:
+- mbillie1@gmail.com
+executables:
+- stylr
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/stylr
+- lib/stylr.rb
+- lib/stylr/dir_loader.rb
+- lib/stylr/file_parser.rb
+- lib/stylr/lint.rb
+- lib/stylr/version.rb
+- spec/dir/one.rb
+- spec/dir/three.rb
+- spec/dir/two.rb
+- spec/dir_loader_spec.rb
+- spec/file_parser_spec.rb
+- spec/lint_spec.rb
+- spec/rdir/base.rb
+- spec/rdir/one/one.rb
+- spec/rdir/three/three.rb
+- spec/rdir/two/two.rb
+- spec/sdir/one_spec.rb
+- spec/txt/sample_1.rb
+- spec/txt/sample_fail.rb
+- spec/txt/sample_fail2.rb
+- spec/txt/sample_fail3.rb
+- spec/txt/sample_fail4.rb
+- spec/txt/sample_fail5.rb
+- spec/txt/sample_pass2.rb
+- stylr.gemspec
+- stylr.yml
+homepage: https://github.com/yaaase/stylr.git
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: stylr - enforcing Ruby coding style standards
+test_files:
+- spec/dir/one.rb
+- spec/dir/three.rb
+- spec/dir/two.rb
+- spec/dir_loader_spec.rb
+- spec/file_parser_spec.rb
+- spec/lint_spec.rb
+- spec/rdir/base.rb
+- spec/rdir/one/one.rb
+- spec/rdir/three/three.rb
+- spec/rdir/two/two.rb
+- spec/sdir/one_spec.rb
+- spec/txt/sample_1.rb
+- spec/txt/sample_fail.rb
+- spec/txt/sample_fail2.rb
+- spec/txt/sample_fail3.rb
+- spec/txt/sample_fail4.rb
+- spec/txt/sample_fail5.rb
+- spec/txt/sample_pass2.rb