jslint-v8 1.0.0

data/lib/jslint-v8/lint_error.rb

@@ -0,0 +1,14 @@
+
+module JSLintV8
+  class LintError
+    attr_reader :line_number, :character, :reason, :evidence
+  
+    def initialize(jsobject)
+      @line_number = jsobject["line"]
+      @character = jsobject["character"]
+      @reason = jsobject["reason"]
+      @evidence = jsobject["evidence"]
+    end
+
+  end
+end

data/lib/jslint-v8/rake_task.rb

@@ -0,0 +1,79 @@
+require 'rake'
+require 'rake/tasklib'
+
+module JSLintV8
+  class RakeTask < ::Rake::TaskLib
+    # name of the rake task
+    attr_accessor :name
+
+    # description for the task
+    attr_accessor :description
+
+    # inclusion glob pattern for files
+    attr_accessor :include_pattern
+
+    # exclusion glob pattern for files
+    attr_accessor :exclude_pattern
+
+    # output stream for this task
+    attr_accessor :output_stream
+
+    def initialize
+      # a default name
+      @name = "lint"
+      
+      # a default description
+      @description = "Runs the JSLint Test Suite"
+
+      # by default a glob pattern that will include javascript files found in rails
+      @include_pattern = "app/javascripts/**/*.js"
+
+      # by default a glob pattern which will match no files
+      @exclude_pattern = ""
+
+      # by default use standard output for writing information
+      @output_stream = STDOUT
+
+      # if a block was given allow the block to call elements on this object
+      yield self if block_given?
+
+      # create the rake task
+      new_task = task(name) do
+        formatter = JSLintV8::Formatter.new(output_stream)
+
+        lint_result = runner.run do |file, errors|
+          formatter.tick(errors)
+        end
+
+        # put a separator line in between the ticks and any summary
+        output_stream.print "\n"
+
+        # print a summary of failed files
+        formatter.summary(files_to_run, lint_result)
+
+        # raise an exception if there are errors
+        raise "jslint suite failed" unless lint_result.empty?
+      end
+      
+      # assign the description to the rake task
+      new_task.comment = description
+    end
+
+    #
+    # Returns a list of all files to run, sorted
+    #
+    def files_to_run
+      included_files = Dir.glob(include_pattern)
+      excluded_files = Dir.glob(exclude_pattern)
+
+      (included_files - excluded_files).sort
+    end
+
+  private
+    
+    def runner
+      JSLintV8::Runner.new(files_to_run)
+    end
+
+  end
+end

data/lib/jslint-v8/runner.rb

@@ -0,0 +1,82 @@
+require 'v8'
+
+module JSLintV8
+   class Runner
+      JSLintLibraryFilename = File.expand_path("js/jslint.js", File.dirname(__FILE__))
+
+      attr_reader :file_list
+
+      def initialize(files)
+         if(files.is_a?(Array))
+            @file_list = files
+         else
+            @file_list = [files]
+         end
+      end
+
+      def run
+         # make sure all files exit
+         file_list.each do |file|
+            raise "file not found: #{file}" unless File.exist?(file)
+         end
+
+         result = {}
+
+         file_list.each do |file|
+            errors = jslint(File.read(file))
+
+            yield(file, errors) if block_given?
+
+            next if errors.empty?
+
+            result[file] = errors
+         end
+
+         result
+      end
+      
+      def runtime
+         @runtime ||= lambda do
+            runtime = V8::Context.new
+
+            # load the jslint library into the runtime
+            runtime.eval(File.read JSLintLibraryFilename)
+
+            # return the runtime
+            runtime
+         end.call
+      end
+
+      def jslint(source_code)
+         jslint_function.call(source_code, jslint_options)
+         jslint_result
+      end
+
+      def jslint_function
+         runtime["JSLINT"];
+      end
+
+      def jslint_result
+         runtime["JSLINT"]["errors"].to_a.compact.map do |error_object|
+            JSLintV8::LintError.new(error_object)
+         end
+      end
+
+      def jslint_options
+         {
+            "bitwise" => true,
+            "eqeqeq" => true,
+            "immed" => true,
+            "newcap" => true,
+            "nomen" => true,
+            "onevar" => true,
+            "plusplus" => true,
+            "regexp" => true,
+            "rhino" => true,
+            "undef" => true,
+            "white" => true
+         }
+      end
+
+   end
+end

data/lib/jslint-v8/version.rb

@@ -0,0 +1,11 @@
+
+module JSLintV8
+  module Version
+     MAJOR = 1
+     MINOR = 0
+     PATCH = 0
+     BUILD = nil
+    
+     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')
+  end
+end

data/lib/jslint-v8.rb

@@ -0,0 +1,6 @@
+module JSLintV8 end
+
+require File.expand_path("jslint-v8/runner", File.dirname(__FILE__))
+require File.expand_path("jslint-v8/rake_task", File.dirname(__FILE__))
+require File.expand_path("jslint-v8/lint_error", File.dirname(__FILE__))
+require File.expand_path("jslint-v8/formatter", File.dirname(__FILE__))

data/test/helper.rb

@@ -0,0 +1,18 @@
+require "rubygems"
+require 'test/unit'
+require 'erb'
+
+# require the library code
+require File.expand_path("../lib/jslint-v8", File.dirname(__FILE__))
+
+def erb_fixture(basename)
+  ::ERB.new(File.read(erb_filename(basename))).result
+end
+
+def erb_filename(basename)
+  File.expand_path("fixtures/#{basename}.txt.erb", File.dirname(__FILE__))
+end
+
+def js_filename(basename)
+  File.expand_path("fixtures/#{basename}.js", File.dirname(__FILE__))
+end

data/test/suite.rb

@@ -0,0 +1,5 @@
+
+# require all test cases
+Dir.glob(File.join(File.dirname(__FILE__), "test_*.rb")).each do |test_file|
+  require test_file
+end

data/test/test_cli.rb

@@ -0,0 +1,44 @@
+require File.expand_path('helper', File.dirname(__FILE__))
+require 'erb'
+
+class TestCli < Test::Unit::TestCase
+  Executable = File.expand_path("../bin/jslint-v8", File.dirname(__FILE__))
+  
+  def test_executable_exists
+    assert File.exist?(Executable)
+  end
+
+  def test_empty_args
+    result = `#{Executable}`
+
+    assert_equal "usage: jslint-v8 FILES\n", result
+    assert_equal false, $?.success?
+  end
+
+  def test_valid
+    result = %x{#{Executable} "#{js_filename "valid"}"}
+
+    assert $?.success?
+    assert_equal erb_fixture("cli-valid-expected-output"), result
+  end
+
+  def test_invalid
+    result = %x{#{Executable} "#{js_filename "invalid"}"}
+
+    assert_equal false, $?.success?
+    assert_equal erb_fixture("cli-invalid-expected-output"), result
+  end
+
+  def test_suite
+    defined_globals = js_filename("defined-globals")
+    defined_options = js_filename("defined-options")
+    invalid = js_filename("invalid")
+    valid = js_filename("valid")
+
+    result = %x{#{Executable} "#{defined_globals}" "#{defined_options}" "#{invalid}" "#{valid}"}
+
+    assert_equal false, $?.success?
+    assert_equal erb_fixture("cli-suite-expected-output"), result
+  end
+
+end

data/test/test_formatter.rb

@@ -0,0 +1,51 @@
+require File.expand_path('helper', File.dirname(__FILE__))
+require 'erb'
+require 'stringio'
+
+class TestFormatter < Test::Unit::TestCase
+
+  def setup
+    @output = String.new
+    @output_stream = StringIO.new(@output, "w+")
+
+    @formatter = JSLintV8::Formatter.new(@output_stream)
+  end
+
+  def test_create
+    assert_equal @output_stream.object_id, @formatter.output_stream.object_id
+  end
+
+  def test_tick
+    assert_equal "", @output
+
+    @formatter.tick([])
+
+    assert_equal ".", @output
+
+    @formatter.tick(["foo"])
+
+    assert_equal ".*", @output
+  end
+
+  def test_summary_with_no_errors
+    @formatter.summary(%w(foo bar), {})
+
+    assert_equal erb_fixture("formatter-summary-noerrors"), @output
+  end
+
+  def test_summary_with_errors
+    error_1 = JSLintV8::LintError.new("line" => 42, "character" => 10, "reason" => "because i can")
+    error_2 = JSLintV8::LintError.new("line" => 43, "character" => 3, "reason" => "a proof is not a proof")
+    error_3 = JSLintV8::LintError.new("line" => 139, "character" => 12, "reason" => "undefined global 'foo'")
+
+    result = {
+      "foo" => [error_1, error_2],
+      "bar" => [error_3]
+    }
+
+    @formatter.summary(%w(foo bar baz one two three), result)
+
+    assert_equal erb_fixture("formatter-summary-errors"), @output
+  end
+
+end

data/test/test_lint_error.rb

@@ -0,0 +1,32 @@
+require File.expand_path('helper', File.dirname(__FILE__))
+
+class TestLintError < Test::Unit::TestCase
+
+  def setup
+    @object = {
+      "line" => 42,
+      "character" => 10,
+      "reason" => "because i can",
+      "evidence" => "I don't know, a proof is a proof. What kind of a proof? It's a proof. A proof is a proof, and when you have a good proof, it's because it's proven."
+    }
+
+    @error = JSLintV8::LintError.new(@object)
+  end
+
+  def test_line_number
+    assert_equal @error.line_number, 42
+  end
+
+  def test_character
+    assert_equal @error.character, 10
+  end
+
+  def test_reason
+    assert_equal @error.reason, "because i can"
+  end
+
+  def test_evidence
+    assert_equal @error.evidence, "I don't know, a proof is a proof. What kind of a proof? It's a proof. A proof is a proof, and when you have a good proof, it's because it's proven."
+  end
+
+end

data/test/test_runner.rb

@@ -0,0 +1,141 @@
+require File.expand_path('helper', File.dirname(__FILE__))
+
+class TestRunner < Test::Unit::TestCase
+
+  def setup
+    @runner = JSLintV8::Runner.new(%w(foo bar))
+  end
+
+  def test_lint_library_filename
+    assert File.exist? JSLintV8::Runner::JSLintLibraryFilename
+  end
+
+  def test_file_list
+    assert_equal @runner.file_list, %w(foo bar)
+  end
+
+  def test_constructor_enumerable_wrapping
+    @runner = JSLintV8::Runner.new("foo")
+
+    assert_equal @runner.file_list, %w(foo)
+  end
+
+  def test_file_not_found
+    assert_raise RuntimeError do
+      @runner.run
+    end
+  end
+
+  def test_file_found
+    filename = js_filename "valid"
+
+    assert_nothing_raised do
+      JSLintV8::Runner.new(filename).run
+    end
+  end
+
+  def test_runtime
+    assert @runner.runtime.is_a?(V8::Context)
+  end
+
+  def test_runtime_caching
+    first = @runner.runtime
+    assert_equal @runner.runtime.object_id, first.object_id
+  end
+
+  def test_jslint_function_proxy
+    assert_not_nil @runner.jslint_function
+  end
+
+  def test_jslint_result
+    assert @runner.jslint_result.is_a?(Array)
+  end
+
+  def test_jslint_default_options
+    assert @runner.jslint_options.keys.any?
+  end
+
+  def test_jslint_returns_array_of_errors
+    result = @runner.jslint("if(true) alert('foo');")
+    
+    assert result.is_a?(Array)
+    assert result.length > 0
+    assert result.all? {|error| error.is_a?(JSLintV8::LintError) }
+  end
+
+  def test_run
+    filename = js_filename("invalid")
+
+    result = JSLintV8::Runner.new(filename).run
+
+    assert result.is_a?(Hash)
+    assert result.keys.include?(filename)
+    assert result[filename].is_a?(Array)
+  end
+
+  def test_valid_run
+    filename = js_filename("valid")
+
+    result = JSLintV8::Runner.new(filename).run
+
+    errors = result[filename]
+
+    assert errors.nil?
+  end
+
+  def test_invalid_run
+    filename = js_filename("invalid")
+
+    result = JSLintV8::Runner.new(filename).run
+
+    errors = result[filename]
+
+    assert errors.any?
+  end
+
+  def test_defined_globals
+    filename = js_filename("defined-globals")
+
+    result = JSLintV8::Runner.new(filename).run
+
+    errors = result[filename]
+
+    assert errors.nil?
+  end
+
+  def test_defined_options
+    filename = js_filename("defined-options")
+
+    result = JSLintV8::Runner.new(filename).run
+
+    errors = result[filename]
+
+    assert errors.nil?
+  end
+
+  def test_block
+    filename = js_filename("valid")
+
+    count = 0
+
+    JSLintV8::Runner.new(filename).run do |file, errors|
+      count += 1
+
+      if count == 1
+        assert_equal file, filename
+        assert_equal errors, []
+      end
+    end
+
+    assert_equal count, 1
+  end
+
+  def test_rejects_successful
+    valid_file = js_filename("valid")
+    invalid_file = js_filename("invalid")
+
+    result = JSLintV8::Runner.new([valid_file, invalid_file]).run
+
+    assert_equal result.keys.length, 1
+  end
+end

data/test/test_task.rb

@@ -0,0 +1,126 @@
+require File.expand_path('helper', File.dirname(__FILE__))
+require 'rake'
+require 'tempfile'
+
+class TestTask < Test::Unit::TestCase
+
+  def setup
+    # completely reset the rake application to ensure everything is clean
+    Rake.application = nil
+  end
+
+  def test_creation
+    initial_length = Rake.application.tasks.length
+
+    JSLintV8::RakeTask.new
+
+    # the number of tasks should have increased by 1
+    assert_equal initial_length + 1, Rake.application.tasks.length
+  end
+
+  def test_default_name
+    JSLintV8::RakeTask.new
+
+    task = Rake.application.lookup("lint")
+
+    assert_equal "lint", task.name
+  end
+
+  def test_default_description
+    JSLintV8::RakeTask.new 
+
+    task = Rake.application.lookup("lint")
+
+    assert_equal "Runs the JSLint Test Suite", task.comment
+  end
+
+  def test_default_include_pattern
+    task = JSLintV8::RakeTask.new 
+
+    assert_equal "app/javascripts/**/*.js", task.include_pattern
+  end
+
+  def test_default_exclude_pattern
+    task = JSLintV8::RakeTask.new
+
+    assert_equal "", task.exclude_pattern
+  end
+
+  def test_default_output_stream
+    task = JSLintV8::RakeTask.new
+
+    assert_equal STDOUT, task.output_stream
+  end
+
+  def test_creation_block
+    tempfile = Tempfile.new("foo")
+
+    task = JSLintV8::RakeTask.new do |task|
+      task.name = "foo"
+      task.description = "Points out the bad codezzzz"
+      task.include_pattern = "js/**/*.js"
+      task.exclude_pattern = "js/**/*.txt"
+      task.output_stream = tempfile
+    end
+
+    rake_task = Rake.application.lookup("foo")
+
+    assert_equal "foo", rake_task.name
+    assert_equal "Points out the bad codezzzz", rake_task.comment
+    assert_equal "js/**/*.js", task.include_pattern
+    assert_equal "js/**/*.txt", task.exclude_pattern
+    assert_equal tempfile.object_id, task.output_stream.object_id
+  end
+
+  def test_files_to_run
+    task = JSLintV8::RakeTask.new do |task|
+      task.include_pattern = File.expand_path("fixtures/*", File.dirname(__FILE__))
+      task.exclude_pattern = File.expand_path("fixtures/*.erb", File.dirname(__FILE__))
+    end
+
+    expected_files = Dir.glob(File.expand_path("fixtures/*.js", File.dirname(__FILE__))).sort
+
+    assert_equal expected_files, task.files_to_run
+  end
+
+  def test_valid_output
+    result = String.new
+
+    task = JSLintV8::RakeTask.new do |task|
+      task.include_pattern = File.expand_path("fixtures/valid.js", File.dirname(__FILE__))
+      task.output_stream = StringIO.new(result, "w+")
+    end
+
+    Rake.application.lookup("lint").invoke
+
+    assert_equal erb_fixture("cli-valid-expected-output"), result
+  end
+
+  def test_invalid_output
+    result = String.new
+
+    task = JSLintV8::RakeTask.new do |task|
+      task.include_pattern = File.expand_path("fixtures/invalid.js", File.dirname(__FILE__))
+      task.output_stream = StringIO.new(result, "w+")
+    end
+
+    assert_raise RuntimeError do
+      Rake.application.lookup("lint").invoke
+    end
+
+    assert_equal erb_fixture("cli-invalid-expected-output"), result
+  end
+
+  def test_suite_output
+    result = String.new
+
+    task = JSLintV8::RakeTask.new do |task|
+      task.include_pattern = File.expand_path("fixtures/*.js", File.dirname(__FILE__))
+      task.output_stream = StringIO.new(result, "w+")
+    end
+
+    Rake.application.lookup("lint").invoke rescue # exception raised because of failing suite
+
+    assert_equal erb_fixture("cli-suite-expected-output"), result
+  end
+end