jshint-rb 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fca4b57a7fd55839fc3dfa5a48f46480a1cb0874
+  data.tar.gz: cce1f8ab14901bc48c92443af5fb179e70ca46ef
+SHA512:
+  metadata.gz: b275be473f0971b6444cd5dcea2091bf4b340315befdba0ece7a4312ff9dc4a2cb8376105d01a49c388bae5b716997e14aad6f46459c00e52013284fc636e07e
+  data.tar.gz: 2a1255b5edc01f5821b0db2ea7578295d105c37ccbad101b2ee8ae7ee3a1f0835714780a184b5a7809298f5e29a63e7a93dc041362be41d4dcfe87cb96ac45ae

data/Changelog.markdown

@@ -0,0 +1,48 @@
+Version 1.1.1 (16.04.2012)
+
+* fixed issue with jslint:copy_config task
+
+Version 1.1 (09.04.2012)
+
+* removed support for installing as a Rails plugin
+* doesn't auto-generate jslint.yml if it doesn't exist (create one explicitly using the rake task if you want)
+* no need to set JSLint.config_path (if you aren't using the Railtie) if the file is in the default location
+
+Version 1.0.7 (12.09.2011)
+
+* fixed problem with local options from one file being applied to all subsequent files
+
+Version 1.0.6 (19.02.2011)
+
+* escape $ in predef line to prevent Bash for interpreting it
+* predef can be passed as a YAML array
+
+Version 1.0.5 (08.01.2011)
+
+* options passed on the command line to JSLint are joined with "&" to fix the "predef" option
+* load YAJL module explicitly (in some environments it may not be loaded automatically)
+
+Version 1.0.4 (05.12.2010)
+
+* bundler should be able to load the gem without :require
+* added a Railtie to make things simpler in Rails 3
+* don't print any warnings if tested JS file is empty
+* lastsemic option will now not work if the missing semicolon is on a different line than the end bracket (so it only
+  makes sense for inline one-liner functions)
+* updated JSLint to version from 2010-11-27 (adds some new warnings about comparing variables with empty string using
+  "==")
+
+Version 1.0.3 (11.06.2010)
+
+* Ruby 1.9 compatibility fixes
+* 'es5' option is disabled by default
+
+Version 1.0.2 (10.04.2010)
+
+* Rails 3 compatibility fixes
+* updated JSLint to version from 2010-04-06
+* refactoring, added specs
+
+Version 1.0.0 (18.12.2009)
+
+* first gem release

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Bruno Gouveia
+
+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.markdown

@@ -0,0 +1,116 @@
+# JSHint.rb
+
+[![Build Status](https://secure.travis-ci.org/josephholsten/jshint.rb.png)](http://travis-ci.org/josephholsten/jshint.rb)
+
+**JSHint on Rails** is a Ruby library which lets you run
+the [JSHint JavaScript code checker](http://jshint.com) on your Javascript code easily.
+JSHint on rails is a fork project from [JSLint on Rails](https://github.com/jsuder/jslint_on_rails),
+adapted to work with jshint.
+
+## Requirements
+
+* Ruby 1.8.7 or 1.9.2+
+* Javascript engine compatible with [execjs](https://github.com/sstephenson/execjs) (on Mac and Windows it's provided by the OS)
+* JSON engine compatible with [multi_json](https://github.com/intridea/multi_json) (included in Ruby 1.9, on 1.8 use e.g. [json gem](http://rubygems.org/gems/json))
+* should work with (but doesn't require) Rails 2.x and 3.x
+
+## Installation
+
+To use JSHint in Rails 3 you just need to do one thing:
+
+* add `gem 'jshint-rb'` to bundler's Gemfile
+
+In Rails 2 and other frameworks JSHint on Rails can't be loaded automatically using a Railtie, so you have to load it explicitly. The procedure in this case is:
+
+* install the gem in your application using whatever technique is recommended for your framework (e.g. using bundler,
+or by installing the gem manually with `gem install jshint-rb` and loading it with `require 'jshint'`)
+* in your Rakefile, add a line to load the JSHint tasks:
+
+        require 'jshint/tasks'
+
+## Configuration
+
+It's strongly recommended that you create your own copy of the JSHint config file provided by the gem and tweak it to suit your preferences. To create a new config file from the template in your config directory, call this rake task:
+
+    [bundle exec] rake jshint:copy_config
+
+This will create a config file at `config/jshint.yml` listing all available options. If for some reason you'd like to put the config file at a different location, set the `config_path` variable somewhere in your Rakefile:
+
+    JSHint.config_path = "config/lint.yml"
+
+There are two things you can change in the config file:
+
+* define which Javascript files are checked by default; you'll almost certainly want to change that, because the default
+is `public/javascripts/**/*.js` which means all Javascript files, and you probably don't want JSHint to check entire
+jQuery, Prototype or whatever other libraries you use - so change this so that only your scripts are checked (you can
+put multiple entries under "paths:" and "exclude_paths:")
+* enable or disable specific checks - I've set the defaults to what I believe is reasonable,
+but what's reasonable for me may not be reasonable for you
+
+## Running
+
+To start the check, run the rake task:
+
+    [bundle exec] rake jshint
+
+You will get a result like this (if everything goes well):
+
+    Running JSHint:
+    
+    checking public/javascripts/Event.js... OK
+    checking public/javascripts/Map.js... OK
+    checking public/javascripts/Marker.js... OK
+    checking public/javascripts/Reports.js... OK
+    
+    No JS errors found.
+
+If anything is wrong, you will get something like this instead:
+
+    Running JSHint:
+    
+    checking public/javascripts/Event.js... 2 errors:
+    
+    Lint at line 24 character 15: Use '===' to compare with 'null'.
+    if (a == null && b == null) {
+    
+    Lint at line 72 character 6: Extra comma.
+    },
+    
+    checking public/javascripts/Marker.js... 1 error:
+    
+    Lint at line 275 character 27: Missing radix parameter.
+    var x = parseInt(mapX);
+    
+    
+    Found 3 errors.
+    rake aborted!
+    JSHint test failed.
+
+If you want to test specific file or files (just once, without modifying the config), you can pass paths to include
+and/or paths to exclude to the rake task:
+
+    rake jshint paths=public/javascripts/models/*.js,public/javascripts/lib/*.js exclude_paths=public/javascripts/lib/jquery.js
+
+For the best effect, you should include JSHint check in your Continuous Integration build - that way you'll get
+immediate notification when you've committed JS code with errors.
+
+## Running from your code
+
+If you would prefer to write your own rake task to run JSHint, you can create and execute the JSHint object manually:
+
+    require 'jshint'
+    
+    lint = JSHint::Lint.new(
+      :paths => ['public/javascripts/**/*.js'],
+      :exclude_paths => ['public/javascripts/vendor/**/*.js'],
+      :config_path => 'config/jslint.yml'
+    )
+    
+    lint.run
+
+## Credits
+
+* JSLint on Rails was created by [Jakub Suder](http://psionides.eu), licensed under MIT License
+* JSHint by [JSHint Community](https://github.com/jshint/jshint)
+* JSHint is a fork of JSLint and is maintained by the [JSHint Community](https://github.com/jshint/jshint)
+* JSLint was created by [Douglas Crockford](http://jslint.com)

data/Rakefile

@@ -0,0 +1,10 @@
+require "rubygems"
+require "bundler"
+Bundler.setup
+
+require 'rspec/core/rake_task'
+
+desc 'Run the specs'
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ['--colour', '--format', 'documentation']
+end

data/lib/jshint.rb

@@ -0,0 +1,7 @@
+require 'jshint/errors'
+require 'jshint/utils'
+require 'jshint/lint'
+
+if defined?(Rails) && Rails::VERSION::MAJOR >= 3
+  require 'jshint/railtie'
+end

data/lib/jshint/config/jshint.yml

@@ -0,0 +1,91 @@
+# ------------ rake task options ------------
+
+# JS files to check by default, if no parameters are passed to rake jshint
+# (you may want to limit this only to your own scripts and exclude any external scripts and frameworks)
+
+# this can be overridden by adding 'paths' and 'exclude_paths' parameter to rake command:
+#   rake jshint paths=path1,path2,... exclude_paths=library1,library2,...
+
+paths:
+  - public/javascripts/**/*.js
+
+exclude_paths:
+
+
+# ------------ jshint options ------------
+# visit http://jshint.com/ for complete documentation
+
+# "enforce" type options (true means potentially more warnings)
+
+adsafe:   false     # true if ADsafe rules should be enforced. See http://www.ADsafe.org/
+bitwise:  true      # true if bitwise operators should not be allowed
+newcap:   true      # true if Initial Caps must be used with constructor functions
+eqeqeq:   false     # true if === should be required (for ALL equality comparisons)
+immed:    false     # true if immediate function invocations must be wrapped in parens
+nomen:    false     # true if initial or trailing underscore in identifiers should be forbidden
+onevar:   false     # true if only one var statement per function should be allowed
+plusplus: false     # true if ++ and -- should not be allowed
+regexp:   false     # true if . and [^...] should not be allowed in RegExp literals
+safe:     false     # true if the safe subset rules are enforced (used by ADsafe)
+strict:   false     # true if the ES5 "use strict"; pragma is required
+undef:    true      # true if variables must be declared before used
+white:    false     # true if strict whitespace rules apply (see also 'indent' option)
+
+# "allow" type options (false means potentially more warnings)
+
+cap:      false     # true if upper case HTML should be allowed
+css:      false     # true if CSS workarounds should be tolerated
+debug:    false     # true if debugger statements should be allowed (set to false before going into production)
+es5:      false     # true if ECMAScript 5 syntax should be allowed
+evil:     false     # true if eval should be allowed
+forin:    false     # true if unfiltered 'for in' statements should be allowed
+fragment: false     # true if HTML fragments should be allowed
+laxbreak: false     # true if statement breaks should not be checked
+on:       false     # true if HTML event handlers (e.g. onclick="...") should be allowed
+sub:      false     # true if subscript notation may be used for expressions better expressed in dot notation
+
+# other options
+
+maxlen:   160       # Maximum line length
+indent:   2         # Number of spaces that should be used for indentation - used only if 'white' option is set
+maxerr:   50        # The maximum number of warnings reported (per file)
+passfail: false     # true if the scan should stop on first error (per file)
+# following are relevant only if undef = true
+predef:   ''        # Names of predefined global variables - comma-separated string or a YAML array
+browser:  true      # true if the standard browser globals should be predefined
+rhino:    false     # true if the Rhino environment globals should be predefined
+windows:  false     # true if Windows-specific globals should be predefined
+widget:   false     # true if the Yahoo Widgets globals should be predefined
+devel:    false     # true if functions like alert, confirm, console, prompt etc. are predefined
+
+# jshint options
+loopfunc: true      # true if functions should be allowed to be defined within loops
+asi:      true      # true if automatic semicolon insertion should be tolerated
+boss:     true      # true if advanced usage of assignments and == should be allowed
+couch:    true      # true if CouchDB globals should be predefined
+curly:    false     # true if curly braces around blocks should be required (even in if/for/while)
+noarg:    true      # true if arguments.caller and arguments.callee should be disallowed
+node:     true      # true if the Node.js environment globals should be predefined
+noempty:  true      # true if empty blocks should be disallowed
+nonew:    true      # true if using `new` for side-effects should be disallowed
+
+
+# ------------ jshint_on_rails custom lint options (switch to true to disable some annoying warnings) ------------
+
+# ignores "missing semicolon" warning at the end of a function; this lets you write one-liners
+# like: x.map(function(i) { return i + 1 }); without having to put a second semicolon inside the function
+lastsemic: false
+
+# allows you to use the 'new' expression as a statement (without assignment)
+# so you can call e.g. new Ajax.Request(...), new Effect.Highlight(...) without assigning to a dummy variable
+newstat: false
+
+# ignores the "Expected an assignment or function call and instead saw an expression" warning,
+# if the expression contains a proper statement and makes sense; this lets you write things like:
+#    element && element.show();
+#    valid || other || lastChance || alert('OMG!');
+#    selected ? show() : hide();
+# although these will still cause a warning:
+#    element && link;
+#    selected ? 5 : 10;
+statinexp: false

data/lib/jshint/errors.rb

@@ -0,0 +1,7 @@
+module JSHint
+  class NoEngineException < StandardError
+  end
+
+  class LintCheckFailure < StandardError
+  end
+end

data/lib/jshint/lint.rb

@@ -0,0 +1,105 @@
+require 'jshint/errors'
+require 'jshint/utils'
+require 'execjs'
+require 'multi_json'
+
+module JSHint
+
+  PATH = File.dirname(__FILE__)
+
+  JSHINT_FILE = File.expand_path("#{PATH}/vendor/jshint.js")
+
+  class Lint
+
+    # available options:
+    # :paths => [list of paths...]
+    # :exclude_paths => [list of exluded paths...]
+    # :config_path => path to custom config file (can be set via JSHint.config_path too)
+    def initialize(options = {})
+      default_config = Utils.load_config_file(DEFAULT_CONFIG_FILE)
+      custom_config = Utils.load_config_file(options[:config_path] || JSHint.config_path)
+      @config = default_config.merge(custom_config)
+      if @config['predef']
+        @config['predef'] = @config['predef'].split(",") unless @config['predef'].is_a?(Array)
+      end
+
+      included_files = files_matching_paths(options, :paths)
+      excluded_files = files_matching_paths(options, :exclude_paths)
+      @file_list = Utils.exclude_files(included_files, excluded_files)
+      @file_list.delete_if { |f| File.size(f) == 0 }
+
+      ['paths', 'exclude_paths'].each { |field| @config.delete(field) }
+    end
+
+    def run
+      raise NoEngineException, "No JS engine available" unless js_engine
+      Utils.log "Running JSHint via #{js_engine.name}:\n\n"
+
+      errors = @file_list.map { |file| process_file(file) }.flatten
+
+      if errors.length == 0
+        Utils.log "\nNo JS errors found."
+      else
+        Utils.log "\nFound #{Utils.pluralize(errors.length, 'error')}."
+        raise LintCheckFailure, "JSHint test failed."
+      end
+    end
+
+    private
+
+    def js_engine
+      ExecJS.runtime
+    end
+
+    def process_file(filename)
+      Utils.display "checking #{filename}... "
+      errors = []
+
+      if File.exist?(filename)
+        source = File.read(filename)
+        errors = run_lint(source)
+
+        if errors.length == 0
+          Utils.log "OK"
+        else
+          Utils.log print(Utils.pluralize(errors.length, "error") + ":\n");
+
+          errors.each do |error|
+            Utils.log "Lint at line #{error['line']} character #{error['character']}: #{error['reason']}"
+
+            if error['evidence']
+              evidence = error['evidence'].gsub(/^\s*(\S*(\s+\S+)*)\s*$/) { $1 }
+              Utils.log(evidence)
+            end
+
+            Utils.log ''
+          end
+        end
+      else
+        Utils.log "Error: couldn't open file."
+      end
+
+      errors
+    end
+
+    def run_lint(source)
+      code = %(
+        JSHINT(#{source.inspect}, #{MultiJson.dump(@config)});
+        return JSHINT.errors;
+      )
+
+      context.exec(code)
+    end
+
+    def context
+      @context ||= ExecJS.compile(File.read(JSHINT_FILE))
+    end
+
+    def files_matching_paths(options, field)
+      path_list = options[field] || @config[field.to_s] || []
+      path_list = [path_list] unless path_list.is_a?(Array)
+      file_list = path_list.map { |p| Dir[p] }.flatten
+      Utils.unique_files(file_list)
+    end
+  end
+end

data/lib/jshint/rails.rb

@@ -0,0 +1,4 @@
+require 'jshint/utils'
+
+# for Rails, set config file path to config/jshint.yml in Rails root
+JSHint.config_path = File.join(Rails.root, 'config', 'jshint.yml')

data/lib/jshint/railtie.rb

@@ -0,0 +1,19 @@
+module JSHint
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      require 'jshint/tasks'
+      JSHint::Railtie.create_example_config
+    end
+
+    def self.create_example_config
+      unless File.exists?(JSHint.config_path)
+        begin
+          JSHint::Utils.copy_config_file
+        rescue StandardError => error
+          puts "Error: #{error.message}"
+        end
+      end
+    end
+
+  end
+end