jslint_on_rails 1.0.0 → 1.0.2

data/spec/lint_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe JSLint::Lint do
+
+  before :all do
+    File.open(JSLint::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" }
+    JSLint.config_path = "custom_config.yml"
+  end
+
+  def setup_java(lint)
+    lint.should_receive(:call_java_with_output).once.and_return("OK")
+  end
+
+  def file_list(lint)
+    lint.instance_variable_get("@file_list")
+  end
+
+  it "should merge default config with custom config from JSLint.config_path" do
+    lint = JSLint::Lint.new
+    config = lint.instance_variable_get("@config")
+    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 = JSLint::Lint.new :config_path => 'other_config.yml'
+    config = lint.instance_variable_get("@config")
+    config.should == { 'color' => 'green', 'border' => 0, 'shape' => 'square', 'size' => 5 }
+  end
+
+  it "should not pass paths and exclude_paths options to real JSLint" do
+    File.open("test.yml", "w") do |f|
+      f.write(YAML.dump({ 'paths' => ['a', 'b'], 'exclude_paths' => ['c'], 'debug' => 'true' }))
+    end
+    lint = JSLint::Lint.new :config_path => 'test.yml'
+    config = lint.instance_variable_get("@config")
+    config['debug'].should == 'true'
+    config['paths'].should be_nil
+    config['exclude_paths'].should be_nil
+  end
+
+  it "should fail if Java isn't available" do
+    lint = JSLint::Lint.new
+    lint.should_receive(:call_java_with_output).once.and_return("java: command not found")
+    lambda { lint.run }.should raise_error(JSLint::NoJavaException)
+  end
+
+  it "should fail if JSLint check fails" do
+    lint = JSLint::Lint.new
+    setup_java(lint)
+    lint.should_receive(:call_java_with_status).once.and_return(false)
+    lambda { lint.run }.should raise_error(JSLint::LintCheckFailure)
+  end
+
+  it "should not fail if JSLint check passes" do
+    lint = JSLint::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 = JSLint::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(JSLint::NoJavaException)
+  end
+
+  it "should pass comma-separated option string to JSLint" do
+    lint = JSLint::Lint.new
+    lint.instance_variable_set("@config", { 'debug' => true, 'semicolons' => false, 'linelength' => 120 })
+    setup_java(lint)
+    lint.
+      should_receive(:call_java_with_status).
+      once.
+      with(an_instance_of(String), an_instance_of(String), /semicolons=false,linelength=120,debug=true/).
+      and_return(true)
+    lint.run
+  end
+
+  it "should pass space-separated list of files to JSLint" do
+    lint = JSLint::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
+      JSLint::Utils.stub!(:exclude_files).and_return { |inc, exc| inc - exc }
+      JSLint::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 = JSLint::Lint.new :paths => ['test/**/*.js']
+      file_list(lint).should == @files
+
+      lint = JSLint::Lint.new :paths => ['test/a*.js', 'test/**/*r*.js']
+      file_list(lint).should == [@files[0], @files[3], @files[4]]
+
+      lint = JSLint::Lint.new :paths => ['test/a*.js', 'test/**/*r*.js'], :exclude_paths => ['**/*q*.js']
+      file_list(lint).should == [@files[0], @files[4]]
+
+      lint = JSLint::Lint.new :paths => ['test/**/*.js'], :exclude_paths => ['**/*.js']
+      file_list(lint).should == []
+
+      lint = JSLint::Lint.new :paths => ['test/**/*.js', 'test/**/a*.js', 'test/**/p*.js']
+      file_list(lint).should == @files
+
+      File.open("new.yml", "w") { |f| f.write(YAML.dump({ 'paths' => ['test/vendor/*.js'] })) }
+
+      lint = JSLint::Lint.new :config_path => 'new.yml', :exclude_paths => ['**/proto.js']
+      file_list(lint).should == [@files[3]]
+
+      lint = JSLint::Lint.new :config_path => 'new.yml', :paths => ['test/l*.js']
+      file_list(lint).should == [@files[1]]
+    end
+
+    it "should accept :paths and :exclude_paths as string instead of one-element array" do
+      lambda do
+        lint = JSLint::Lint.new :paths => 'test/*.js', :exclude_paths => 'test/lib.js'
+        file_list(lint).should == [@files[0], @files[2]]
+      end.should_not raise_error
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'jslint'
+require 'fakefs'
+
+module JSLint::Utils
+  # disable logging to stdout
+  def self.xprint(x) ; end
+  def self.xputs(x) ; end
+end

data/spec/utils_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+describe JSLint::Utils do
+
+  JSU = JSLint::Utils
+
+  before :all do
+    File.open(JSLint::DEFAULT_CONFIG_FILE, "w") { |f| f.puts "default config file" }
+  end
+
+  it "should have a config_path setting" do
+    JSLint.config_path = 'some/path'
+    JSLint.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
+      JSLint.config_path = nil
+      lambda { JSLint::Utils.copy_config_file }.should raise_error(ArgumentError)
+    end
+
+    it "should copy default config to config_path" do
+      JSLint.config_path = "newfile.yml"
+      File.should_receive(:copy).with(JSLint::DEFAULT_CONFIG_FILE, "newfile.yml")
+      JSLint::Utils.copy_config_file
+    end
+
+    it "should not overwrite the file if it exists" do
+      JSLint.config_path = "newfile2.yml"
+      File.open("newfile2.yml", "w") { |f| f.write("qwe") }
+      File.should_not_receive(:copy)
+      JSLint::Utils.copy_config_file
+    end
+  end
+
+  describe "remove_config_file" do
+    it "throw an error if config path isn't set" do
+      JSLint.config_path = nil
+      lambda { JSLint::Utils.remove_config_file }.should raise_error(ArgumentError)
+    end
+
+    it "should remove the file if it's identical to default one" do
+      JSLint.config_path = "newfile3.yml"
+      File.open("newfile3.yml", "w") { |f| f.puts("default config file") }
+      File.exists?("newfile3.yml").should be_true
+      JSLint::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
+      JSLint.config_path = "newfile4.yml"
+      File.open("newfile4.yml", "w") { |f| f.puts("something's changed") }
+      File.exists?("newfile4.yml").should be_true
+      JSLint::Utils.remove_config_file
+      File.exists?("newfile4.yml").should be_true
+    end
+
+    it "should not remove the file if it doesn't exist" do
+      JSLint.config_path = "this_doesnt_exist.yml"
+      lambda { JSLint::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")
+      JSLint.config_path = "public"
+      lambda { JSLint::Utils.remove_config_file }.should_not raise_error
+      File.exist?("public").should be_true
+      File.directory?("public").should be_true
+    end
+  end
+
+end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: jslint_on_rails
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 2
+  version: 1.0.2
 platform: ruby
 authors: 
 - Jakub Suder
@@ -9,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-18 00:00:00 +01:00
+date: 2010-04-10 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -24,16 +29,21 @@ extra_rdoc_files: []
 files: 
 - MIT-LICENSE
 - README.markdown
-- config/jslint.yml
+- Gemfile
+- Rakefile
+- lib/jslint/config/jslint.yml
 - lib/jslint/errors.rb
 - lib/jslint/lint.rb
 - lib/jslint/rails.rb
 - lib/jslint/tasks.rb
 - lib/jslint/utils.rb
+- lib/jslint/vendor/jslint.js
+- lib/jslint/vendor/rhino.jar
+- lib/jslint/vendor/test.jar
 - lib/jslint.rb
-- vendor/jslint.js
-- vendor/rhino.jar
-- vendor/test.jar
+- spec/lint_spec.rb
+- spec/spec_helper.rb
+- spec/utils_spec.rb
 has_rdoc: true
 homepage: http://github.com/psionides/jslint_on_rails
 licenses: []
@@ -47,18 +57,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: 
 - Java JRE (5.0 or later)
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: JSLint JavaScript checker wrapped in a Ruby gem for easier use