jshint_on_rails 1.0.1

data/lib/jshint_on_rails.rb

@@ -0,0 +1 @@
+require 'jshint'

data/spec/lint_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+describe JSHint::Lint do
+
+  JSHint::Lint.class_eval do
+    attr_reader :config, :file_list
+  end
+
+  before :all do
+    File.open(JSHint::DEFAULT_CONFIG_FILE, "w") { |f| f.write "color: red\nsize: 5\nshape: circle\n" }
+    File.open("custom_config.yml", "w") { |f| f.write "color: blue\nsize: 7\nborder: 2\n" }
+    File.open("other_config.yml", "w") { |f| f.write "color: green\nborder: 0\nshape: square" }
+    JSHint.config_path = "custom_config.yml"
+  end
+
+  def setup_java(lint)
+    lint.should_receive(:call_java_with_output).once.and_return("OK")
+  end
+
+  it "should merge default config with custom config from JSHint.config_path" do
+    lint = JSHint::Lint.new
+    lint.config.should == { 'color' => 'blue', 'size' => 7, 'border' => 2, 'shape' => 'circle' }
+  end
+
+  it "should merge default config with custom config given in argument, if available" do
+    lint = JSHint::Lint.new :config_path => 'other_config.yml'
+    lint.config.should == { 'color' => 'green', 'border' => 0, 'shape' => 'square', 'size' => 5 }
+  end
+
+  it "should convert predef to string if it's an array" do
+    File.open("predef.yml", "w") { |f| f.write "predef:\n  - a\n  - b\n  - c" }
+
+    lint = JSHint::Lint.new :config_path => 'predef.yml'
+    lint.config['predef'].should == "a,b,c"
+  end
+
+  it "should accept predef as string" do
+    File.open("predef.yml", "w") { |f| f.write "predef: d,e,f" }
+
+    lint = JSHint::Lint.new :config_path => 'predef.yml'
+    lint.config['predef'].should == "d,e,f"
+  end
+
+  it "should not pass paths and exclude_paths options to real JSHint" do
+    File.open("test.yml", "w") do |f|
+      f.write(YAML.dump({ 'paths' => ['a', 'b'], 'exclude_paths' => ['c'], 'debug' => 'true' }))
+    end
+    lint = JSHint::Lint.new :config_path => 'test.yml'
+    lint.config['debug'].should == 'true'
+    lint.config['paths'].should be_nil
+    lint.config['exclude_paths'].should be_nil
+  end
+
+  it "should fail if Java isn't available" do
+    lint = JSHint::Lint.new
+    lint.should_receive(:call_java_with_output).once.and_return("java: command not found")
+    lambda { lint.run }.should raise_error(JSHint::NoJavaException)
+  end
+
+  it "should fail if JSHint check fails" do
+    lint = JSHint::Lint.new
+    setup_java(lint)
+    lint.should_receive(:call_java_with_status).once.and_return(false)
+    lambda { lint.run }.should raise_error(JSHint::LintCheckFailure)
+  end
+
+  it "should not fail if JSHint check passes" do
+    lint = JSHint::Lint.new
+    setup_java(lint)
+    lint.should_receive(:call_java_with_status).once.and_return(true)
+    lambda { lint.run }.should_not raise_error
+  end
+
+  it "should only do Java check once" do
+    lint = JSHint::Lint.new
+    setup_java(lint)
+    lint.should_receive(:call_java_with_status).twice.and_return(true)
+    lambda do
+      lint.run
+      lint.run
+    end.should_not raise_error(JSHint::NoJavaException)
+  end
+
+  it "should pass an ampersand-separated option string to JSHint" do
+    lint = JSHint::Lint.new
+    lint.instance_variable_set("@config", { 'debug' => true, 'semicolons' => false, 'linelength' => 120 })
+    setup_java(lint)
+    param_string = ""
+    lint.
+      should_receive(:call_java_with_status).
+      once.
+      with(an_instance_of(String), an_instance_of(String), an_instance_of(String)).
+      and_return { |a, b, c| param_string = c; true }
+    lint.run
+
+    option_string = param_string.split(/\s+/).detect { |p| p =~ /linelength/ }
+    eval(option_string).split('&').sort.should == ['debug=true', 'linelength=120', 'semicolons=false']
+  end
+
+  it "should escape $ in option string when passing it to Java/JSHint" do
+    lint = JSHint::Lint.new
+    lint.instance_variable_set("@config", { 'predef' => 'window,$,Ajax,$app,Request' })
+    setup_java(lint)
+    param_string = ""
+    lint.
+      should_receive(:call_java_with_status).
+      once.
+      with(an_instance_of(String), an_instance_of(String), /window,\\\$,Ajax,\\\$app,Request/).
+      and_return(true)
+    lint.run
+  end
+
+  it "should pass space-separated list of files to JSHint" do
+    lint = JSHint::Lint.new
+    lint.instance_variable_set("@file_list", ['app.js', 'test.js', 'jquery.js'])
+    setup_java(lint)
+    lint.
+      should_receive(:call_java_with_status).
+      once.
+      with(an_instance_of(String), an_instance_of(String), /app\.js test\.js jquery\.js$/).
+      and_return(true)
+    lint.run
+  end
+
+  describe "file lists" do
+    before :each do
+      JSHint::Utils.stub!(:exclude_files).and_return { |inc, exc| inc - exc }
+      JSHint::Utils.stub!(:unique_files).and_return { |files| files.uniq }
+    end
+
+    before :all do
+      @files = ['test/app.js', 'test/lib.js', 'test/utils.js', 'test/vendor/jquery.js', 'test/vendor/proto.js']
+      @files.each { |fn| File.open(fn, "w") { |f| f.write("alert()") }}
+      @files = @files.map { |fn| File.expand_path(fn) }
+    end
+
+    it "should calculate a list of files to test" do
+      lint = JSHint::Lint.new :paths => ['test/**/*.js']
+      lint.file_list.should == @files
+
+      lint = JSHint::Lint.new :paths => ['test/a*.js', 'test/**/*r*.js']
+      lint.file_list.should == [@files[0], @files[3], @files[4]]
+
+      lint = JSHint::Lint.new :paths => ['test/a*.js', 'test/**/*r*.js'], :exclude_paths => ['**/*q*.js']
+      lint.file_list.should == [@files[0], @files[4]]
+
+      lint = JSHint::Lint.new :paths => ['test/**/*.js'], :exclude_paths => ['**/*.js']
+      lint.file_list.should == []
+
+      lint = JSHint::Lint.new :paths => ['test/**/*.js', 'test/**/a*.js', 'test/**/p*.js']
+      lint.file_list.should == @files
+
+      File.open("new.yml", "w") { |f| f.write(YAML.dump({ 'paths' => ['test/vendor/*.js'] })) }
+
+      lint = JSHint::Lint.new :config_path => 'new.yml', :exclude_paths => ['**/proto.js']
+      lint.file_list.should == [@files[3]]
+
+      lint = JSHint::Lint.new :config_path => 'new.yml', :paths => ['test/l*.js']
+      lint.file_list.should == [@files[1]]
+    end
+
+    it "should accept :paths and :exclude_paths as string instead of one-element array" do
+      lambda do
+        lint = JSHint::Lint.new :paths => 'test/*.js', :exclude_paths => 'test/lib.js'
+        lint.file_list.should == [@files[0], @files[2]]
+      end.should_not raise_error
+    end
+
+    it "should ignore empty files" do
+      File.open("test/empty.js", "w") { |f| f.write("") }
+      File.open("test/full.js", "w") { |f| f.write("qqq") }
+
+      lint = JSHint::Lint.new :paths => ['test/*.js']
+      lint.file_list.should_not include(File.expand_path("test/empty.js"))
+      lint.file_list.should include(File.expand_path("test/full.js"))
+    end
+  end
+
+end

data/spec/railtie_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'jshint/railtie'
+
+describe JSHint::Railtie do
+  before :all do
+    File.open(JSHint::DEFAULT_CONFIG_FILE, "w") { |f| f.write "foo" }
+    JSHint.config_path = "custom_config.yml"
+  end
+
+  before :each do
+    File.delete(JSHint.config_path) if File.exist?(JSHint.config_path)
+  end
+
+  describe "create_example_config" do
+    it "should create a config file if it doesn't exist" do
+      JSHint::Railtie.create_example_config
+
+      File.exist?(JSHint.config_path).should be_true
+      File.read(JSHint.config_path).should == "foo"
+    end
+
+    it "should not do anything if config already exists" do
+      File.open(JSHint.config_path, "w") { |f| f.write "bar" }
+
+      JSHint::Railtie.create_example_config
+
+      File.exist?(JSHint.config_path).should be_true
+      File.read(JSHint.config_path).should == "bar"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require 'jshint'
+require 'fakefs'
+
+module JSHint::Utils
+  # disable logging to stdout
+  def self.xprint(x) ; end
+  def self.xputs(x) ; end
+end
+
+module Rails
+  class Railtie
+    def self.rake_tasks
+    end
+  end
+end
+
+module FileUtils
+  def copy(*args)
+    cp(*args)
+  end
+end

data/spec/utils_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe JSHint::Utils do
+
+  JSU = JSHint::Utils
+
+  before :all do
+    File.open(JSHint::DEFAULT_CONFIG_FILE, "w") { |f| f.puts "default config file" }
+  end
+
+  it "should have a config_path setting" do
+    JSHint.config_path = 'some/path'
+    JSHint.config_path.should == 'some/path'
+  end
+
+  describe "paths_from_command_line" do
+    it "should extract an array of paths from command line argument" do
+      ENV['test_arg'] = 'one,two,three'
+      JSU.paths_from_command_line('test_arg').should == ['one', 'two', 'three']
+    end
+  
+    it "should also work if the argument name is given in uppercase" do
+      ENV['TEST_ARG'] = 'ruby,python,js'
+      JSU.paths_from_command_line('test_arg').should == ['ruby', 'python', 'js']
+    end
+  
+    it "should return nil if the argument isn't set" do
+      JSU.paths_from_command_line('crash').should be_nil
+    end
+  
+    after :each do
+      ENV['test_arg'] = nil
+      ENV['TEST_ARG'] = nil
+    end
+  end
+  
+  describe "load_config_file" do
+  
+    before :all do
+      File.open("sample.yml", "w") { |f| f.puts("framework: rails") }
+      Dir.mkdir("tmp")
+    end
+  
+    it "should load a YAML file if it can be read" do
+      JSU.load_config_file("sample.yml").should == { 'framework' => 'rails' }
+    end
+  
+    it "should return an empty hash if file name is nil" do
+      JSU.load_config_file(nil).should == {}
+    end
+  
+    it "should return an empty hash if file doesn't exist" do
+      JSU.load_config_file("crack.exe").should == {}
+    end
+  
+    it "should return an empty hash if file is not a file" do
+      JSU.load_config_file("tmp").should == {}
+    end
+  
+    it "should return an empty hash if file is not readable" do
+      File.should_receive(:readable?).once.with("sample.yml").and_return(false)
+      JSU.load_config_file("sample.yml").should == {}
+    end
+  end
+
+  describe "unique and exclude" do
+    def set_identical(file1, file2, value)
+      File.should_receive(:identical?).with(file1, file2).once.and_return(value)
+    end
+
+    it "should remove duplicate files from a list" do
+      set_identical('config.yml',  'lib/../config.yml', true)
+      set_identical('config.yml',  'Rakefile',          false)
+      set_identical('config.yml',  'Config.yml',        true)
+      unique = JSU.unique_files(['config.yml', 'lib/../config.yml', 'Rakefile', 'Config.yml'])
+      unique.should == ['config.yml', 'Rakefile']
+    end
+
+    it "should subtract files on the second list from the first list" do
+      set_identical('RaKeFiLe',    'config.yml', false)
+      set_identical('wtf',         'config.yml', false)
+      set_identical('Config.yml',  'config.yml', true)
+      set_identical('RaKeFiLe',    'Rakefile',   true)
+      set_identical('RaKeFiLe',    'Gemfile',    false)
+      set_identical('wtf',         'Gemfile',    false)
+      set_identical('Config.yml',  'Gemfile',    false)
+      included = JSU.exclude_files(['config.yml', 'Rakefile', 'Gemfile'], ['RaKeFiLe', 'wtf', 'Config.yml'])
+      included.should == ['Gemfile']
+    end
+  end
+
+  describe "copy_config_file" do
+    it "throw an error if config path isn't set" do
+      JSHint.config_path = nil
+      lambda { JSHint::Utils.copy_config_file }.should raise_error(ArgumentError)
+    end
+
+    it "should copy default config to config_path" do
+      JSHint.config_path = "newfile.yml"
+      FileUtils.should_receive(:copy).with(JSHint::DEFAULT_CONFIG_FILE, "newfile.yml")
+      JSHint::Utils.copy_config_file
+    end
+
+    it "should not overwrite the file if it exists" do
+      JSHint.config_path = "newfile2.yml"
+      File.open("newfile2.yml", "w") { |f| f.write("qwe") }
+      FileUtils.should_not_receive(:copy)
+      JSHint::Utils.copy_config_file
+    end
+  end
+
+  describe "remove_config_file" do
+    it "throw an error if config path isn't set" do
+      JSHint.config_path = nil
+      lambda { JSHint::Utils.remove_config_file }.should raise_error(ArgumentError)
+    end
+
+    it "should remove the file if it's identical to default one" do
+      JSHint.config_path = "newfile3.yml"
+      File.open("newfile3.yml", "w") { |f| f.puts("default config file") }
+      File.exists?("newfile3.yml").should be_true
+      JSHint::Utils.remove_config_file
+      File.exists?("newfile3.yml").should be_false
+    end
+
+    it "should not remove the file if it's not identical to default one" do
+      JSHint.config_path = "newfile4.yml"
+      File.open("newfile4.yml", "w") { |f| f.puts("something's changed") }
+      File.exists?("newfile4.yml").should be_true
+      JSHint::Utils.remove_config_file
+      File.exists?("newfile4.yml").should be_true
+    end
+
+    it "should not remove the file if it doesn't exist" do
+      JSHint.config_path = "this_doesnt_exist.yml"
+      lambda { JSHint::Utils.remove_config_file }.should_not raise_error
+    end
+
+    it "should not remove the file if it's not a file" do
+      Dir.mkdir("public")
+      JSHint.config_path = "public"
+      lambda { JSHint::Utils.remove_config_file }.should_not raise_error
+      File.exist?("public").should be_true
+      File.directory?("public").should be_true
+    end
+  end
+
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: jshint_on_rails
+version: !ruby/object:Gem::Version 
+  hash: 21
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 1
+  version: 1.0.1
+platform: ruby
+authors: 
+- Bruno Gouveia
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-13 00:00:00 -03:00
+default_executable: 
+dependencies: []
+
+description: 
+email: brunogouveia@buzungo.com.br
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- MIT-LICENSE
+- README.markdown
+- Changelog.markdown
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- lib/jshint/config/jshint.yml
+- lib/jshint/errors.rb
+- lib/jshint/lint.rb
+- lib/jshint/rails.rb
+- lib/jshint/railtie.rb
+- lib/jshint/tasks.rb
+- lib/jshint/utils.rb
+- lib/jshint/vendor/jshint.js
+- lib/jshint/vendor/rhino.jar
+- lib/jshint/vendor/test.jar
+- lib/jshint.rb
+- lib/jshint_on_rails.rb
+- spec/lint_spec.rb
+- spec/railtie_spec.rb
+- spec/spec_helper.rb
+- spec/utils_spec.rb
+has_rdoc: true
+homepage: http://github.com/bgouveia/jshint_on_rails
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: 
+- Java JRE (5.0 or later)
+rubyforge_project: 
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: JSHint is a little more flexible JavaScript checker, wrapped in a Ruby gem for easier use
+test_files: []
+