jshint4r 0.1.0

data/spec/jshint4r/reporter/compilcation_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe JSHint4r::Reporter::Compilation do
+  before(:all) {
+    @reporter = JSHint4r.reporter( :compilation )
+  }
+
+  describe 'report' do
+    context 'ordinary errors' do
+      subject {
+        target, errors = sample_error
+        @reporter.report( target, errors )
+      }
+      it {
+        should eq(<<EOD)
+jshint.js:4019:32: Missing semicolon.
+    itself.edition = '2011-04-16'
+jshint.js:4026:28: Missing semicolon.
+    exports.JSHINT = JSHINT
+EOD
+      }
+    end
+    context 'no errors' do
+      subject {
+        @reporter.report( 'jshint.js', nil )
+      }
+      it {
+        should be_nil
+      }
+    end
+  end
+end

data/spec/jshint4r/reporter/text_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe JSHint4r::Reporter::Text do
+  before(:all) {
+    @reporter = JSHint4r.reporter( :text )
+  }
+
+  describe 'report' do
+    context 'ordinary errors' do
+      subject {
+        target, errors = sample_error
+        @reporter.report( target, errors )
+      }
+      it {
+        should eq(<<EOD)
+jshint.js: line 4019, col 32, Missing semicolon.
+jshint.js: line 4026, col 28, Missing semicolon.
+
+2 errors
+EOD
+      }
+    end
+    describe 'no errors' do
+      context 'verbose' do
+        subject {
+          @reporter.report( 'jshint.js', nil, true )
+        }
+        it {
+          should eq(<<EOD)
+jshint.js ... ok
+EOD
+        }
+      end
+      context 'silent' do
+        subject {
+          @reporter.report( 'jshint.js', nil )
+        }
+        it {
+          should be_nil
+        }
+      end
+    end
+  end
+end

data/spec/jshint4r/reporter_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+class JSHint4r::TestingReporter
+  include JSHint4r::Reporter
+end
+
+describe JSHint4r::Reporter do
+  describe 'reporter' do
+    context 'no args' do
+      subject {
+        JSHint4r.reporter
+      }
+      it {
+        subject.class.should be(JSHint4r::Reporter::Text)
+      }
+    end
+    context :text do
+      subject {
+        JSHint4r.reporter( :text )
+      }
+      it {
+        subject.class.should be(JSHint4r::Reporter::Text)
+      }
+    end
+    context :compilation do
+      subject {
+        JSHint4r.reporter( :compilation )
+      }
+      it {
+        subject.class.should be(JSHint4r::Reporter::Compilation)
+      }
+    end
+  end
+
+  describe 'symbolize' do
+    subject {
+      JSHint4r::TestingReporter.new
+    }
+    it {
+      subject.key_symbolize( 'abc' => 123 ).should eq( :abc => 123 )
+    }
+  end
+end

data/spec/jshint4r/result_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe JSHint4r::Result do
+  def __DATA__
+    File.read(__FILE__).sub(/.*\n__END__\n(.*)$/m, '\1')
+  end
+
+  before(:all) {
+    @errors = JSHint4r::Result.new( 'target.js', __DATA__ )
+  }
+
+  describe 'target' do
+    subject {
+      @errors.target
+    }
+    it {
+      should == 'target.js'
+    }
+  end
+
+  describe 'errors' do
+    subject {
+      @errors.errors
+    }
+    it {
+      subject.class.should be(Array)
+    }
+    it {
+      subject.size.should == 2
+    }
+  end
+
+  describe 'parse' do
+    context 'simple key-value' do
+      subject {
+        @errors.parse( "{ abc: 'def' }" )
+      }
+      it {
+        should eq( { 'abc' => 'def' } )
+      }
+    end
+    context 'value is bare word' do
+      subject {
+        @errors.parse( "{ abc: def }" )
+      }
+      it {
+        expect{subject}.should raise_error(ExecJS::ProgramError)
+      }
+    end
+    context "'[]'" do
+      subject {
+        @errors.parse( '[]' )
+      }
+      it {
+        should eq([])
+      }
+    end
+    context 'empty array' do
+      subject {
+        @errors.parse( [] )
+      }
+      it {
+        expect{should}.to raise_error(TypeError)
+      }
+    end
+    context 'empty string' do
+      subject {
+        @errors.parse( '' )
+      }
+      it {
+        should be_nil
+      }
+    end
+    context 'nil' do
+      subject {
+        @errors.parse( nil )
+      }
+      it {
+        should be_nil
+      }
+    end
+    context 'abc' do
+      subject {
+        @errors.parse( 'abc' )
+      }
+      it {
+        expect{subject}.to raise_error(ExecJS::ProgramError)
+      }
+    end
+    context 'var abc' do
+      subject {
+        @errors.parse( 'var abc' )
+      }
+      it {
+        expect{should}.to raise_error(ExecJS::ProgramError)
+      }
+    end
+  end
+end
+
+__END__
+[ { id: '(error)',
+    raw: 'Missing semicolon.',
+    evidence: '    itself.edition = \'2011-04-16\'',
+    line: 4019,
+    character: 32,
+    a: undefined,
+    b: undefined,
+    c: undefined,
+    d: undefined,
+    reason: 'Missing semicolon.' },
+  { id: '(error)',
+    raw: 'Missing semicolon.',
+    evidence: '    exports.JSHINT = JSHINT',
+    line: 4026,
+    character: 28,
+    a: undefined,
+    b: undefined,
+    c: undefined,
+    d: undefined,
+    reason: 'Missing semicolon.' } ]

data/spec/jshint4r/source_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe JSHint4r::Source do
+  describe 'src' do
+    describe 'include jshint.js' do
+      it {
+        JSHint4r::Source.src.should be_include('JSHINT')
+      }
+    end
+    describe 'include jshint_runner.js' do
+      it {
+        JSHint4r::Source.src.should be_include('JSHINT.run')
+      }
+    end
+  end
+
+  describe 'context' do
+    before(:all) {
+      @subject = JSHint4r::Source.context
+    }
+    context 'ExecJS::*::Context object' do
+      it {
+        @subject.should be_respond_to(:exec)
+      }
+      it {
+        @subject.should be_respond_to(:eval)
+      }
+      it {
+        @subject.should be_respond_to(:call)
+      }
+    end
+    context 'singleton' do
+      it {
+        JSHint4r::Source.context.object_id.should be(@subject.object_id)
+      }
+    end
+  end
+end

data/spec/jshint4r/target_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe JSHint4r::Target do
+  before(:all) {
+    config  = JSHint4r::Config.new( fixture( 'config.yml' ) )
+    @target = JSHint4r::Target.new( config.targets, config.excludes )
+  }
+
+  describe 'initialize' do
+    context 'nil' do
+      subject {
+        JSHint4r::Target.new nil, nil
+      }
+      it {
+        subject.targets.should eq([])
+      }
+      it {
+        subject.excludes.should eq([])
+      }
+    end
+    context 'no args' do
+      subject {
+        JSHint4r::Target.new
+      }
+      it {
+        lambda {subject}.should raise_error( ArgumentError )
+      }
+      it {
+        lambda {subject}.should_not raise_error( TypeError )
+      }
+    end
+  end
+
+  describe 'targets' do
+    describe 'Array' do
+      subject {
+        @target.targets.class
+      }
+      it {
+        should eq(Array)
+      }
+    end
+    describe 'size' do
+      subject {
+        @target.targets.size
+      }
+      it {
+        should > 0
+      }
+    end
+  end
+
+  describe 'excludes' do
+    describe 'Array' do
+      subject {
+        @target.excludes.class
+      }
+      it {
+        should eq(Array)
+      }
+    end
+    describe 'size' do
+      subject {
+        @target.excludes.size
+      }
+      it {
+        should > 0
+      }
+    end
+  end
+
+  describe 'each' do
+    describe 'list' do
+      subject {
+        side = []
+        @target.each { |e|
+          side << e
+        }
+
+        side
+      }
+      it {
+        should eq(['spec/fixtures/missing_semicolon.js'])
+      }
+    end
+    describe 'exist' do
+      subject {
+        side = []
+
+        @target.each { |e|
+          side << File.exist?( e )
+        }
+
+        side
+      }
+      it {
+        should eq([true])
+      }
+    end
+  end
+
+  describe 'real_targets' do
+    before(:all) {
+      @t = @target.real_targets
+    }
+    describe 'no_errors.js' do
+      subject {
+        @t.grep( /no_errors\.js/ )
+      }
+      it {
+        should eq([])
+      }
+    end
+    describe 'directory not exist' do
+      subject {
+        @t.find { |e| File.directory? e }
+      }
+      it {
+        should be_nil
+      }
+    end
+    describe 'file exists' do
+      subject {
+        @t.find_all { |e| File.file? e }
+      }
+      it {
+        subject.class.should eq(Rake::FileList)
+      }
+      it {
+        subject.size.should > 0
+      }
+    end
+  end
+end

data/spec/jshint4r_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe JSHint4r do
+  pending
+  it "fails" do
+    puts "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'jshint4r'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end
+
+def fixture( name )
+  File.join( File.dirname(__FILE__), 'fixtures', name )
+end

data/spec/support/sample_error.rb

@@ -0,0 +1,22 @@
+def sample_error
+  [ 'jshint.js',
+    [
+      {
+        'id'        => '(error)',
+        'raw'       => 'Missing semicolon.',
+        'evidence'  => '    itself.edition = \'2011-04-16\'',
+        'line'      => 4019,
+        'character' => 32,
+        'reason'    => 'Missing semicolon.'
+      },
+      {
+        'id'        => '(error)',
+        'raw'       => 'Missing semicolon.',
+        'evidence'  => '    exports.JSHINT = JSHINT',
+        'line'      => 4026,
+        'character' => 28,
+        'reason'    => 'Missing semicolon.'
+      }
+    ]
+  ]
+end

data/vendor/jshint/CHANGELOG

@@ -0,0 +1,63 @@
+April 16, 2011
+  * New edition: 2011-04-16
+
+  * Unit tests for all options and some core functions
+  * A number of small typo and message fixes
+  * JSHint is now a JavaScript/JSON parser only
+    (ADSafe, HTML, CSS related code was removed)
+  * JSHint now supports function-scoped options
+  * JSHint now supports both /*jshint and /*jslint
+
+  * JSHint now supports shebangs (#!)
+  * Added support for typed array globals
+  * Allowed the use of variables/functions before definition.
+    (option 'latedef' to disallow)
+  * Fixed a bug with 'forin' option
+  * Fixed Rhino wrapper's CLI options support
+  * Fixed a bug with JSHint leaking internal variables
+  * Added option 'expr' to allow ExpressionStatement as valid Program
+  * Added an option 'prototypejs' to pre-define Prototype globals
+  * Added XPathResult et al. to the 'browser' option
+  * Added support for 'undefined' as a function parameter
+  * Option 'boss' has now precedence over 'eqeqeq' when it comes to '== null'
+  * Fixed a bug with JSHint parsing getters/setters as function statements
+  * Added an option 'mootools' to pre-define MooTools globals
+  * Added an option 'globalstrict' to allow the use of global strict mode
+  * Added HTMLElement to the browser environment
+  * Added support for the void operator
+  * Fixed a bug with 'new Array'
+  * Added option 'white' to check for trailing whitespaces
+
+March 01, 2011
+  * New edition: 2011-03-02
+
+  * When library is used from Rhino, you can provide options via command line arguments
+
+  * Added new HTML5 globals to the 'browser' option
+  * Tolerate == null when boss:true
+  * Tolerate undefined variables in the typeof and delete
+  * Tolerate undefined as a formal parameter
+  * Recognize new Array(<expr>) as a valid expression
+  * Added support for explicit case statement fallthroughs (using special comments)
+  * Added third formal parameter to JSHINT for specifying pre-defined globals
+
+  * New option 'asi' to tolerate the use of automatic semicolon insertion
+  * New option 'jquery' to assume jQuery environment
+  * New option 'couch' to assume CouchDB environment
+
+February 19, 2011
+  * New edition: 2011-02-19
+
+  * Library can act as a Node.js module and a Rhino program
+
+  * Tolerate single statements in if/for/while constructions ('curly' to disallow)
+  * Tolerate arguments.callee and arguments.caller ('noarg' to disallow)
+  * Tolerate empty blocks ('noempty' to disallow)
+  * Tolerate the use of `new` for side-effects ('nonew' to disallow)
+  * Less strict styling check by default ('white' to revert)
+
+  * New option 'boss' to tolerate assignments inside if/for/while
+  * New option 'node' to assume Node environment
+
+January 19, 2011
+  * Forked JSLint from the edition 2010-12-16

data/vendor/jshint/README.markdown

@@ -0,0 +1,70 @@
+JSHint, The (Gentler) JavaScript Code Quality Tool
+==================================================
+
+JSHint is a fork of Douglas Crockford's [JSLint](http://jslint.com/) that does
+not tyrannize your code. It is designed to detect errors that actually break your
+code while skipping things that, according to Crockford, “are known to
+contribute mistakes in projects”. In other words, JSHint is a fork of JSLint
+for the real world.
+
+For example, JSLint does not tolerate the following constructions:
+
+    if (cond) statement();
+
+It expects all blocks to be enclosed in braces ({}):
+
+    if (cond) {
+      statement();
+    }
+
+JSHint removes that requirement (but it is still available as an option).
+
+
+Community
+---------
+
+The most important part is that JSHint is developed and supported by
+the JavaScript developers community and not by one very opinionated person.
+
+If you use JSLint and think that it is too strict, use
+[Issues](https://github.com/jshint/jshint/issues) to describe most annoying
+JSLint gripes you encounter.
+
+
+Development
+-----------
+
+JSHint was forked from the JSLint, edition 2010-12-16.
+The current stable edition is [2011-02-19](http://jshint.com/jshint.js).
+
+
+Environments
+------------
+
+JSHint can be used as a Node module out of the box:
+
+    var JSHINT = require("jshint.js").JSHINT;
+
+If you use Rhino, we have a special wrapper script for that:
+
+    java -jar /path/to/js.jar env/rhino.js myscript.js
+
+Also included is a Windows Scripting Host wrapper:
+
+    cscript env/wsh.js myscript.js
+
+And if you're on OS X, use Apple's built-in JavaScriptCore:
+
+	env/jsc.sh myscript.js
+
+Tests
+-----
+
+To run tests you will need to install [node.js](http://nodejs.org/) and
+expresso. You can install the latter with npm:
+
+    npm install expresso
+
+After that, running tests is as easy as:
+
+    expresso tests/*.js