fashion-police 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6ad2b24bff44bedebe1b4795721c4e1778aa4c31
+  data.tar.gz: fad809fe3c2e068796c67e2b44901a2a43e9b1c3
+SHA512:
+  metadata.gz: 31d53ece6148dfcfd3e610dcac377956ea9abf2deb1d858455f61b4d62421b32985ae22734438c2da421b425765c8c746809254388571e7772448571b871ccb9
+  data.tar.gz: ea4e644bffc0ca75594eae973bb03855cc15acc00c23ba0aa04f8cfd43eb5041b3af6a40739f6a946759a4ef03efc31793e062d03cc572f6588b7db449f305ed

data/bin/fashion-police

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'rainbow'
+require 'fashion-police'
+
+@fashion_police = FashionPolice.new
+errors = []
+
+unstaged = `git diff --name-only`.split("\n")
+staged = `git diff --name-only --cached`.split("\n")
+
+files = unstaged + staged
+
+files.each do |filename|
+  begin
+    @fashion_police.investigate(File.read(filename))
+  rescue FashionPolice::BadCode
+    errors << filename.background(:red)
+    errors << @fashion_police.errors.collect {|element| element.to_s.foreground(:red) }
+  end
+end
+
+if errors.empty?
+  exit(0)
+else
+  puts "JavaScript style errors!".foreground(:red)
+  errors.each do |error|
+    puts error
+  end
+  exit(1)
+end
+

data/lib/fashion-police.rb

@@ -0,0 +1,196 @@
+class FashionPolice
+  attr_reader :errors
+  attr_accessor :rules
+
+  class SpacesNotTabs
+    def test(string)
+      not string.match(/\t/)
+    end
+
+    def error_message
+      "Use spaces, not tabs"
+    end
+  end
+
+  class FourSpaces
+    def test(string)
+      spaces = string.match(/^(\s+)\S/)
+      return true unless spaces && spaces[1]
+
+      return (spaces[1].length % 4 == 0)
+    end
+
+    def error_message
+      "Four spaces per indentation level"
+    end
+  end
+
+  class SpacesInFunctionDeclarations
+    def test(string)
+      return false if string.match(/function\(\.*\)\{/)
+      return false if string.match(/function\s+\(.*\)\{/)
+      return true if string.match(/function\s+\(.*\)\s+\{/)
+      return true
+    end
+
+    def error_message
+      "Put spaces in function declarations"
+    end
+  end
+
+  class SpacesAroundElses
+    def test(string)
+      return true if string.match(/} else {/)
+      return false if string.match(/}else{/)
+      return false if string.match(/} +else{/)
+      return false if string.match(/}else +{/)
+      return false if string.match(/} +else ?{/)
+      return false if string.match(/} ?else +{/)
+      return true
+    end
+
+    def error_message
+      "Put spaces around elses"
+    end
+  end
+
+  class SpacesAroundEqualsSigns
+    def test(string)
+      return true if string.match(/ = /)
+      return false if string.match(/\S=[^=]/)
+      return true
+    end
+
+    def error_message
+      "Put spaces around equals signs"
+    end
+  end
+
+  class SpacesAroundArgumentsInForLoops
+    def test(string)
+      return false if string.match(/for\(\S+\s+[^\)]+\)/)
+      return true
+    end
+
+    def error_message
+      "Put spaces around for loop arguments"
+    end
+  end
+
+  class SpacesAroundArgumentsInParens
+    def test(string)
+      return true if string.match(/\( .* \)/)
+      return true if string.match(/\S*\(function\(/)
+      return true if string.match(/\S+\(["'].*["']\)/)
+      return false if string.match(/\(\S+\)/)
+
+      return true
+    end
+
+    def error_message
+      "Put spaces around arguments inside parentheses"
+    end
+  end
+
+  class SpacesBeforeAngleBrackets
+    def test(string)
+      return true if string.match(/(\S+ )?\{/)
+      return false if string.match(/\S\{/)
+
+      return true
+    end
+
+    def error_message
+      "Put spaces in front of angle brackets"
+    end
+  end
+
+  class SpacesAroundArgumentsInAngleBrackets
+    def test(string)
+      return true if string.match(/\{ .* \}/)
+      return false if string.match(/\{[^\}]+\}/)
+
+      return true
+    end
+
+    def error_message
+      "Put spaces around arguments inside angle brackets"
+    end
+  end
+
+  class SpacesAroundArgumentsInSquareBrackets
+    def test(string)
+      return true if string.match(/\[ .* \]/)
+      return false if string.match(/\[[^\]]+\]/)
+
+      return true
+    end
+
+    def error_message
+      "Put spaces around arguments inside square brackets"
+    end
+  end
+
+  class SpacesAroundArgumentsInFunctionDeclarations
+    def test(string)
+      return true if string.match(/function( .+)?\( [^\)]+ \)/)
+      return false if string.match(/function( .+)?\([^\)]+\)/)
+      return true
+    end
+
+    def error_message
+      "Put spaces around for loop arguments"
+    end
+  end
+
+  class ColumnWidth
+    def test(string)
+      string.length <= 80
+    end
+
+    def error_message
+      "Maximum text width: 80 characters"
+    end
+  end
+
+  class BadCode < Exception; end
+
+  def initialize
+    @errors = []
+    @rules = [ SpacesNotTabs.new,
+               FourSpaces.new,
+               SpacesInFunctionDeclarations.new,
+               SpacesAroundElses.new,
+               SpacesAroundEqualsSigns.new,
+               SpacesAroundArgumentsInForLoops.new,
+               SpacesAroundArgumentsInParens.new,
+               SpacesBeforeAngleBrackets.new,
+               SpacesAroundArgumentsInAngleBrackets.new,
+               SpacesAroundArgumentsInSquareBrackets.new,
+               SpacesAroundArgumentsInFunctionDeclarations.new,
+               ColumnWidth.new ]
+  end
+
+  def investigate(code)
+    code.split("\n").each_with_index do |line, index|
+      next if comment?(line)
+      line_number = index + 1
+      raise(BadCode) unless permit?(line_number, line)
+    end
+  end
+
+  def comment?(line)
+    line.match(/^ *\/\//)
+  end
+
+  def permit?(line_number, string)
+    @rules.inject(true) do |memo, rule|
+      unless rule.test(string)
+        memo = false
+        @errors << {line_number => rule.error_message}
+      end
+      memo
+    end
+  end
+end
+

data/spec/fashion_police_spec.rb

@@ -0,0 +1,361 @@
+require_relative("../lib/fashion-police")
+
+describe FashionPolice do
+
+  describe "has a very simple set of integration specs which" do
+
+    before do
+      @fashion_police = FashionPolice.new
+    end
+
+    it "passes good JavaScript through silently" do
+      good = File.dirname(__FILE__) + '/fixtures/good.js'
+      expect(lambda { @fashion_police.investigate(File.read(good)) }).to_not raise_error
+    end
+
+    it "complains about bad JavaScript" do
+      bad = File.dirname(__FILE__) + '/fixtures/bad.js'
+      expect(lambda { @fashion_police.investigate(File.read(bad)) }).to raise_error
+    end
+  end
+
+  describe "provides a tool which" do
+
+    before do
+      @fashion_police = FashionPolice.new
+      @bad_code = <<-BAD_CODE
+  function (argument) {
+    console.log('wrong indentation style');
+  }
+    BAD_CODE
+  end
+
+    it "detects violations of style rules" do
+      expect( lambda {@fashion_police.investigate(@bad_code)} ).to raise_error(FashionPolice::BadCode)
+    end
+
+    describe "on error" do
+
+      it "keeps track of line number and error message" do
+        @fashion_police.permit?(1, '				function( arg ) {').should be_false
+        @fashion_police.errors.should == [{1 => "Use spaces, not tabs"}]
+      end
+
+    end
+
+  end
+
+  describe "enforces a coding style which" do
+
+    it "uses spaces, not tabs" do
+      FashionPolice::SpacesNotTabs.new.test("				").should be_false
+    end
+
+    describe "uses four spaces per indent" do
+
+      it "at zero levels in" do
+        FashionPolice::FourSpaces.new.test("function").should be_true
+      end
+
+      it "at 0.5 levels in" do
+        FashionPolice::FourSpaces.new.test("  function").should be_false
+      end
+
+      it "at one level in" do
+        FashionPolice::FourSpaces.new.test("    function").should be_true
+      end
+
+      it "at 1.5 levels in" do
+        FashionPolice::FourSpaces.new.test("      function").should be_false
+      end
+
+      it "at two levels in" do
+        FashionPolice::FourSpaces.new.test("        function").should be_true
+      end
+
+    end
+
+    describe "puts spaces before function definitions" do
+
+      before do
+        @rule = FashionPolice::SpacesInFunctionDeclarations.new
+      end
+
+      it "(positive case)" do
+        @rule.test("function() { return true; }").should be_true
+      end
+
+      it "(negative case)" do
+        @rule.test("function (){ return true; }").should be_false
+      end
+
+    end
+
+    it "allows some leeway for functions invoking anonymous functions" do
+      @rule = FashionPolice::SpacesAroundArgumentsInParens.new
+      @rule.test("foo(function() {});").should be_true
+    end
+
+    it "makes an exception for functions invoking single string literals" do
+      @rule = FashionPolice::SpacesAroundArgumentsInParens.new
+      @rule.test("foo('bar');").should be_true
+    end
+
+    describe "puts spaces around arguments in parentheses" do
+
+      before do
+        @rule = FashionPolice::SpacesAroundArgumentsInParens.new
+      end
+
+      it "(positive case)" do
+        @rule.test("function( arg ){ return true; }").should be_true
+      end
+
+      it "(negative case)" do
+        @rule.test("function(arg){ return true; }").should be_false
+      end
+
+    end
+
+    describe "puts spaces around arguments in angle brackets" do
+
+      before do
+        @rule = FashionPolice::SpacesAroundArgumentsInAngleBrackets.new
+      end
+
+      it "(positive case)" do
+        @rule.test("function( arg ){ return true; }").should be_true
+      end
+
+      it "(negative case)" do
+        @rule.test("function( arg ){return true;}").should be_false
+      end
+
+    end
+
+    describe "puts spaces before angle brackets" do
+
+      before do
+        @rule = FashionPolice::SpacesBeforeAngleBrackets.new
+      end
+
+      it "(positive case)" do
+        @rule.test("function( arg ) { return true; }").should be_true
+      end
+
+      it "(negative case)" do
+        @rule.test("function( arg ){ return true; }").should be_true
+      end
+
+    end
+
+    it "allows some leeway when giving a function an object without spaces" do
+      @rule = FashionPolice::SpacesBeforeAngleBrackets.new
+      @rule.test("    foo({").should be_true
+    end
+
+    describe "puts spaces around arguments in square brackets" do
+
+      before do
+        @rule = FashionPolice::SpacesAroundArgumentsInSquareBrackets.new
+      end
+
+      it "(positive case)" do
+        @rule.test("function( arg ){ return [ 0 ]; }").should be_true
+      end
+
+      it "(negative case)" do
+        @rule.test("function( arg ){ return [0]; }").should be_false
+      end
+
+    end
+
+    it "makes an exception for parentheses around square brackets" do
+      @rule = FashionPolice::SpacesAroundArgumentsInParens.new
+      @rule.test("foo([ 'alpha', 'beta' ]);").should be_true
+    end
+
+    describe "puts spaces around args to ifs" do
+
+      before do
+        @rule = FashionPolice::SpacesAroundArgumentsInParens.new
+      end
+
+      it "(positive case)" do
+        @rule.test("if ( condition ) {").should be_true
+      end
+
+      it "(negative case)" do
+        @rule.test("if(condition){").should be_false
+      end
+
+    end
+
+    describe "puts spaces around args to ifs" do
+
+      before do
+        @rule = FashionPolice::SpacesAroundArgumentsInParens.new
+      end
+
+      it "(positive case)" do
+        @rule.test("if ( true ) {").should be_true
+      end
+
+      it "(negative case)" do
+        @rule.test("if(true){").should be_false
+      end
+
+    end
+
+    describe "puts spaces around args to whiles" do
+
+      before do
+        @rule = FashionPolice::SpacesAroundArgumentsInParens.new
+      end
+
+      it "(positive case)" do
+        @rule.test("while ( condition ) {").should be_true
+      end
+
+      it "(negative case)" do
+        @rule.test("while(condition){").should be_false
+      end
+
+    end
+
+    describe "allows hashes, un-preceded by spaces, as arguments to functions" do
+
+      it "(positive case)" do
+        @rule = FashionPolice::SpacesAroundArgumentsInParens.new
+        @rule.test("var fooBar = new FooBar({ a : 'alpha' });").should be_true
+      end
+
+      it "(negative case)" do
+        @rule = FashionPolice::SpacesAroundArgumentsInAngleBrackets.new
+        @rule.test("var fooBar = new FooBar({a : 'alpha'});").should be_false
+      end
+
+    end
+
+    it "makes an exception for function invocations with parentheses around square brackets" do
+      @rule = FashionPolice::SpacesAroundArgumentsInParens.new
+      @rule.test("foo([ 'alpha', 'beta' ]);").should be_true
+    end
+
+    describe "puts spaces around args to for loops which go through array elements" do
+
+      it "(positive case)" do
+        @rule = FashionPolice::SpacesAroundArgumentsInParens.new
+        @rule.test("for ( prop in object ) {").should be_true
+      end
+
+      it "(negative case)" do
+        @rule = FashionPolice::SpacesAroundArgumentsInForLoops.new
+        @rule.test("for(prop in object){").should be_false
+      end
+
+    end
+
+    describe "puts spaces around args to iterating for loops" do
+
+      it "(positive case)" do
+        @rule = FashionPolice::SpacesAroundArgumentsInParens.new
+        @rule.test("for ( var i = 0; i < 100; i++ ) {").should be_true
+      end
+
+      it "(negative case)" do
+        @rule = FashionPolice::SpacesAroundArgumentsInForLoops.new
+        @rule.test("for(var i=0;i<100;i++) {").should be_false
+      end
+
+    end
+
+    describe "puts spaces around elses" do
+
+      before do
+        @rule = FashionPolice::SpacesAroundElses.new
+      end
+
+      it "(positive case)" do
+        @rule.test("} else {").should be_true
+      end
+
+      it "(negative cases)" do
+        @rule.test("}else{").should be_false
+        @rule.test("} else{").should be_false
+        @rule.test("}else {").should be_false
+        @rule.test("} else  {").should be_false
+        @rule.test("}  else {").should be_false
+      end
+
+    end
+
+    describe "puts spaces around anonymous function args" do
+
+      before do
+        @rule = FashionPolice::SpacesAroundArgumentsInFunctionDeclarations.new
+      end
+
+      it "(positive case)" do
+        @rule.test("var square = function( number ) {").should be_true
+      end
+
+      it "(negative cases)" do
+        @rule.test("var square = function(number){").should be_false
+      end
+
+    end
+
+    describe "puts spaces around named function args" do
+
+      before do
+        @rule = FashionPolice::SpacesAroundArgumentsInFunctionDeclarations.new
+      end
+
+      it "(positive cases)" do
+        @rule.test("var factorial = function factorial( number ) {").should be_true
+        @rule.test("function FooBar( options ) {").should be_true
+      end
+
+      it "(negative cases)" do
+        @rule.test("var factorial = function factorial(number){").should be_false
+      end
+
+    end
+
+    describe "puts spaces around equals signs" do
+
+      before do
+        @rule = FashionPolice::SpacesAroundEqualsSigns.new
+      end
+
+      it "(positive case)" do
+        @rule.test("var square = function( number ) {").should be_true
+      end
+
+      it "(negative cases)" do
+        @rule.test("var square=function( number ){").should be_false
+      end
+
+    end
+
+  end
+
+  describe "limits column width to 80 characters" do
+
+    before do
+      @rule = FashionPolice::ColumnWidth.new
+    end
+
+    it "(positive case)" do
+      @rule.test("sdfasdfasdf").should be_true
+    end
+
+    it "(negative case)" do
+      too_big = "                                                                                  "
+      @rule.test(too_big).should be_false
+    end
+
+  end
+
+end

data/spec/fixtures/bad.js

@@ -0,0 +1,24 @@
+    // 2.A.1.1
+    // Examples of really cramped syntax
+
+    if(condition) doSomething();
+
+    while(condition) iterating++;
+
+    for(var i=0;i<100;i++) someIterativeFn();
+
+    // Bad
+    var foo = "";
+    var bar = "";
+    var qux;
+
+
+    // Bad
+    function foo() {
+
+      // some statements here
+
+      var bar = "",
+        qux;
+    }
+

data/spec/fixtures/good.js

@@ -0,0 +1,244 @@
+        // 2.A.1.1
+        // Use whitespace to promote readability
+
+        if ( condition ) {
+                // statements
+        }
+
+        while ( condition ) {
+                // statements
+        }
+
+        for ( var i = 0; i < 100; i++ ) {
+                // statements
+        }
+
+        // Even better:
+
+        var i,
+                length = 100;
+
+        for ( i = 0; i < length; i++ ) {
+                // statements
+        }
+
+        // Or...
+
+        var i = 0,
+                length = 100;
+
+        for ( ; i < length; i++ ) {
+                // statements
+        }
+
+        var prop;
+
+        for ( prop in object ) {
+                // statements
+        }
+
+
+        if ( true ) {
+                // statements
+        } else {
+                // statements
+        }
+
+        // 2.B.1.1
+        // Variables
+        var foo = "bar",
+                num = 1,
+                undef;
+
+        // Literal notations:
+        var array = [],
+                object = {};
+
+
+        // 2.B.1.2
+        // Using only one `var` per scope (function) promotes readability
+        // and keeps your declaration list free of clutter (also saves a few keystrokes)
+
+        // Bad
+        var foo = "";
+        var bar = "";
+        var qux;
+
+        // Good
+        var foo = "",
+                bar = "",
+                quux;
+
+        // or..
+        var // Comment on these
+        foo = "",
+        bar = "",
+        quux;
+
+        // 2.B.1.3
+        // var statements should always be in the beginning of their respective scope (function).
+        // Same goes for const and let from ECMAScript 6.
+
+        // Good
+        function foo() {
+                var bar = "",
+                    qux;
+
+                // all statements after the variables declarations.
+        }
+
+        // 2.B.2.1
+        // Named Function Declaration
+        function foo( arg1, argN ) {
+
+        }
+
+        // Usage
+        foo( arg1, argN );
+
+
+        // 2.B.2.2
+        // Named Function Declaration
+        function square( number ) {
+                return number * number;
+        }
+
+        // Usage
+        square( 10 );
+
+        // Really contrived continuation passing style
+        function square( number, callback ) {
+                callback( number * number );
+        }
+
+        square( 10, function( square ) {
+                // callback statements
+        });
+
+
+        // 2.B.2.3
+        // Function Expression
+        var square = function( number ) {
+                // Return something valuable and relevant
+                return number * number;
+        };
+
+        // Function Expression with Identifier
+        // This preferred form has the added value of being
+        // able to call itself and have an identity in stack traces:
+        var factorial = function factorial( number ) {
+                if ( number < 2 ) {
+                    return 1;
+                }
+
+                return number * factorial( number - 1 );
+        };
+
+
+        // 2.B.2.4
+        // Constructor Declaration
+        function FooBar( options ) {
+
+                this.options = options;
+        }
+
+        // Usage
+        var fooBar = new FooBar({ a: "alpha" });
+
+        fooBar.options;
+        // { a: "alpha" }
+
+        // 2.C.1.1
+        // Functions with callbacks
+        foo(function() {
+                // Note there is no extra space between the first paren
+                // of the executing function call and the word "function"
+        });
+
+        // Function accepting an array, no space
+        foo([ "alpha", "beta" ]);
+
+        // 2.C.1.2
+        // Function accepting an object, no space
+        foo({
+                a: "alpha",
+                b: "beta"
+        });
+
+        // Single argument string literal, no space
+        foo("bar");
+
+        // Inner grouping parens, no space
+        if ( !("foo" in obj) ) {
+
+        }
+
+        // 5.1.1
+        // A Practical Module
+
+        (function( global ) {
+                var Module = (function() {
+
+                    var data = "secret";
+
+                    return {
+                        // This is some boolean property
+                        bool: true,
+                        // Some string value
+                        string: "a string",
+                        // An array property
+                        array: [ 1, 2, 3, 4 ],
+                        // An object property
+                        object: {
+                                lang: "en-Us"
+                        },
+                        getData: function() {
+                                // get the current value of `data`
+                                return data;
+                        },
+                        setData: function( value ) {
+                                // set the value of `data` and return it
+                                return ( data = value );
+                        }
+                    };
+                })();
+
+                // Other things might happen here
+
+                // expose our module to the global object
+                global.Module = Module;
+
+        })( this );
+
+        // 5.2.1
+        // A Practical Constructor
+
+        (function( global ) {
+
+                function Ctor( foo ) {
+
+                    this.foo = foo;
+
+                    return this;
+                }
+
+                Ctor.prototype.getFoo = function() {
+                    return this.foo;
+                };
+
+                Ctor.prototype.setFoo = function( val ) {
+                    return ( this.foo = val );
+                };
+
+
+                // To call constructor's without `new`, you might do this:
+                var ctor = function( foo ) {
+                    return new Ctor( foo );
+                };
+
+
+                // expose our constructor to the global object
+                global.ctor = ctor;
+
+        })( this );
+

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: fashion-police
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Giles Bowkett
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-10 00:00:00.000000000 Z
+dependencies:
+- !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: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Style guide all the things.
+email:
+- gilesb@gmail.com
+executables:
+- fashion-police
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/fashion-police.rb
+- bin/fashion-police
+- spec/fashion_police_spec.rb
+- spec/fixtures/bad.js
+- spec/fixtures/good.js
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: |2+
+
+    =====================================================================
+    To enforce JS code style:
+      rm $(git rev-parse --git-dir)/hooks/pre-commit.sample
+      echo 'fashion-police' > $(git rev-parse --git-dir)/hooks/pre-commit
+      chmod 0755 $(git rev-parse --git-dir)/hooks/pre-commit
+    =====================================================================
+
+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: fashion-police
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Enforce Idiomatic.js via pre-commit hook.
+test_files:
+- spec/fashion_police_spec.rb
+- spec/fixtures/bad.js
+- spec/fixtures/good.js