jruby-lint 0.1

data/spec/jruby/lint/ast_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe JRuby::Lint::AST::Visitor do
+  Given(:ast) { JRuby.parse(script) }
+  Given(:visitor) { JRuby::Lint::AST::Visitor.new(ast) }
+
+  # RootNode
+  #   NewlineNode
+  #     FCallOneArgNode |puts|
+  #       ArrayNode
+  #         StrNode =="hello"
+  Given(:script) { %{puts "hello"} }
+
+  context "visits all nodes" do
+    When { visitor.each_node { @count ||= 0; @count += 1} }
+    Then { @count.should == 5 }
+  end
+
+  context "selects nodes" do
+    When { @nodes = visitor.select {|n| n.node_type == org.jruby.ast.NodeType::STRNODE } }
+    Then { @nodes.size.should == 1 && @nodes.first.value.to_s.should == "hello" }
+  end
+end

data/spec/jruby/lint/checkers_spec.rb

@@ -0,0 +1,135 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe JRuby::Lint::Checker do
+  context "checkers" do
+    subject { Class.new { include JRuby::Lint::Checker } }
+
+    it "finds all loaded checkers" do
+      JRuby::Lint::Checker.loaded_checkers.should include(subject)
+    end
+  end
+end
+
+describe JRuby::Lint::Checkers do
+  Given(:gems) { { "rdiscount" => "may not work", "bson_ext" => "not needed" } }
+  Given(:project) { double("project").tap {|p| p.stub_chain("libraries.gems") { gems } } }
+  Given(:collector) do
+    JRuby::Lint::Collector.new(project).tap do |c|
+      c.contents = script
+      c.checkers = [checker]
+      checker.collector = c
+    end
+  end
+
+  context "Fork/exec checker" do
+    Given(:checker) { JRuby::Lint::Checkers::ForkExec.new }
+
+    context "detects fcall-style" do
+      # FCallNoArgBlockNode |fork|
+      Given(:script) { "fork { }; exec('cmd')" }
+      When { collector.run }
+      Then { collector.findings.size.should == 2 }
+    end
+
+    context "detects vcall-style" do
+      # VCallNode |fork|
+      Given(:script) { "fork" }
+      When { collector.run }
+      Then { collector.findings.size.should == 1 }
+    end
+
+    context "does not detect call-style" do
+      # CallNoArgNode |fork|
+      #   VCallNode |fork|
+      Given(:script) { "fork.fork" }
+      When { collector.run }
+      Then { collector.findings.size.should == 0 }
+    end
+
+    context "detects Kernel::fork style" do
+      # CallNoArgNode |fork|
+      #   ConstNode |Kernel|
+      Given(:script) { "Kernel::fork; Kernel::exec('cmd')" }
+      When { collector.run }
+      Then { collector.findings.size.should == 2 }
+    end
+  end
+
+  context "Gem checker" do
+    Given(:checker) { JRuby::Lint::Checkers::Gem.new }
+
+    context "creates a finding for a gem mentioned in the libraries" do
+      Given(:script) { "gem 'rdiscount'" }
+      When { collector.run }
+      Then { collector.findings.size.should == 2 }
+    end
+
+    context "creates one finding to mention the wiki for gem compatibility" do
+      Given(:script) { "gem 'rdiscount'; gem 'bson_ext'" }
+      When { collector.run }
+      Then { collector.findings.size.should == 3 }
+    end
+
+    context "does not create a finding for a gem not mentioned in the gems info" do
+      Given(:script) { "gem 'json_pure'" }
+      When { collector.run }
+      Then { collector.findings.size.should == 0 }
+    end
+
+    context "only checks calls to #gem" do
+      Given(:script) { "require 'rdiscount'" }
+      When { collector.run }
+      Then { collector.findings.size.should == 0 }
+    end
+  end
+
+  context "Gemspec checker" do
+    Given(:checker) { JRuby::Lint::Checkers::Gemspec.new }
+
+    Given(:script) { "Gem::Specification.new do |s|" +
+      "\ns.name = 'hello'\ns.add_dependency 'rdiscount'\n" +
+      "s.add_development_dependency 'ruby-debug19'\nend\n" }
+
+    When { collector.run }
+    Then { collector.findings.size.should == 2 }
+    Then { collector.findings.detect{|f| f.message =~ /rdiscount/ }.should be_true }
+  end
+
+  context "Thread.critical checker" do
+    Given(:checker) { JRuby::Lint::Checkers::ThreadCritical.new }
+
+    context "read" do
+      Given(:script) { "begin \n Thread.critical \n end"}
+      When { collector.run }
+      Then { collector.findings.size.should == 1 }
+    end
+
+    context "assign" do
+      Given(:script) { "begin \n Thread.critical = true \n ensure Thread.critical = false \n end"}
+      When { collector.run }
+      Then { collector.findings.size.should == 2 }
+    end
+  end
+
+  context "ObjectSpace" do
+    Given(:checker) { JRuby::Lint::Checkers::ObjectSpace.new }
+
+    context "_id2ref usage" do
+      Given(:script) { "ObjectSpace._id2ref(obj)"}
+      When { collector.run }
+      Then { collector.findings.size.should == 1 }
+    end
+
+    context "each_object usage" do
+      Given(:script) { "ObjectSpace.each_object { }"}
+      When { collector.run }
+      Then { collector.findings.size.should == 1 }
+    end
+
+    context "each_object(Class) usage is ok" do
+      Given(:script) { "ObjectSpace.each_object(Class) { }"}
+      When { collector.run }
+      Then { collector.findings.size.should == 0 }
+    end
+  end
+end

data/spec/jruby/lint/cli_spec.rb

@@ -0,0 +1,66 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require 'jruby/lint/cli'
+
+describe JRuby::Lint::CLI do
+  context "when launched" do
+    Given(:command) { "ruby -I#{project_dir}/lib -S #{project_dir}/bin/jrlint #{args}" }
+
+    context "with the help option" do
+      Given(:args) { "--help" }
+      When { run_simple(command) }
+      Then do
+        output_from(command).should =~ /help.*This message/
+        @last_exit_status.should == 0
+      end
+    end
+
+    context "with the version option" do
+      Given(:args) { "--version" }
+      When { run_simple(command) }
+      Then do
+        output_from(command).should =~ /version #{JRuby::Lint::VERSION}/
+        @last_exit_status.should == 0
+      end
+    end
+
+    context "with a dash-e option" do
+      Given(:args) { "-e true"}
+      When { run_simple(command) }
+      Then do
+        output_from(command).should =~ /Processed 1 expression/
+        @last_exit_status.should == 0
+      end
+    end
+
+    context "with a file argument" do
+      Given(:args) { "sample.rb" }
+      Given { write_file("sample.rb", "puts 'hello'"); write_file("example.rb", "puts 'hello'") }
+      When { run_simple(command) }
+      Then do
+        output_from(command).should =~ /Processed 1 file/
+        @last_exit_status.should == 0
+      end
+    end
+
+    context "with no arguments" do
+      Given(:args) { "" }
+
+      context "and some files to process" do
+        Given { write_file("Rakefile", "") }
+        When { run_simple(command) }
+        Then do
+          output = output_from(command)
+          output.should =~ /JRuby-Lint version #{JRuby::Lint::VERSION}/
+          output.should =~ /Processed 1 file/
+          output.should =~ /OK/
+          @last_exit_status.should == 0
+        end
+      end
+
+      context "and no files to process" do
+        When { run_simple(command) }
+        Then { output_from(command).should =~ /Processed 0 files/ }
+      end
+    end
+  end
+end

data/spec/jruby/lint/collectors_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe JRuby::Lint::Collector do
+  Given(:collector) { JRuby::Lint::Collector.new }
+  Given(:checker_class) { Class.new { include JRuby::Lint::Checker } }
+
+  context "loads detected checkers" do
+    When { checker_class }
+    Then { collector.checkers.detect {|c| checker_class === c }.should be_true }
+  end
+
+  context "invokes all checkers" do
+    Given(:checker) do
+      double("checker").tap do |checker|
+        checker.should_receive(:visitTrueNode)
+        collector.checkers = [checker]
+      end
+    end
+    When { collector.contents = 'true' }
+    Then { collector.run }
+  end
+
+  context "loads an AST" do
+    When { collector.contents = 'puts "hello"' }
+    When { @ast = collector.ast }
+    Then { @ast.inspect.should =~ /"hello"/m }
+  end
+
+  context "reports syntax errors as findings" do
+    When { collector.contents = '<% true %>' }
+    When { collector.run }
+    Then { collector.findings.size.should == 1 }
+  end
+end

data/spec/jruby/lint/finding_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe JRuby::Lint::Finding do
+  Given(:message) { "bad code" }
+  Given(:file) { "file" }
+  Given(:line) { 19 }
+  Given(:tags) { ["threads", "info"] }
+
+  context "has a message, location and tags" do
+    When { @finding = JRuby::Lint::Finding.new(message, tags, file, line) }
+    Then { @finding.message.should == message }
+    Then { @finding.tags.should == tags }
+    Then { @finding.file.should == file }
+    Then { @finding.line.should == line }
+    Then { @finding.to_s.should == "#{file}:#{line}: [#{tags.join(', ')}] #{message}" }
+  end
+
+  context "can receive location from SourcePosition" do
+    Given(:source_position) { org.jruby.lexer.yacc.SimpleSourcePosition.new(file, line) }
+
+    When { @finding = JRuby::Lint::Finding.new(message, tags, source_position) }
+    Then { @finding.file.should == file }
+    Then { @finding.line.should == line + 1 }
+  end
+
+  context "converts all tags to strings" do
+    Given(:tags) { [1, :two, 3.0] }
+    When { @finding = JRuby::Lint::Finding.new(message, tags, file, line) }
+    Then { @finding.tags.should == ["1", "two", "3.0"] }
+  end
+end

data/spec/jruby/lint/libraries_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe JRuby::Lint::Libraries do
+  Given(:cache_dir) { ENV['JRUBY_LINT_CACHE'] }
+  Given(:cache) { JRuby::Lint::Libraries::Cache.new(cache_dir) }
+
+  context "cache" do
+    Given(:cache_dir) { current_dir }
+
+    context "with net access", :requires_net => true do
+      context "fetch" do
+        When { cache.fetch('C-Extension-Alternatives') }
+        Then { check_file_presence('C-Extension-Alternatives.html', true) }
+      end
+
+      context "refreshes a file that's too old" do
+        Given { write_file('C-Extension-Alternatives.html', 'alternatives') }
+        Given(:yesterday) { Time.now - 25 * 60 * 60 }
+        Given { File.utime yesterday, yesterday, File.join(current_dir, 'C-Extension-Alternatives.html')}
+        When { cache.fetch('C-Extension-Alternatives') }
+        Then { File.mtime(File.join(current_dir, 'C-Extension-Alternatives.html')).should > yesterday }
+      end
+    end
+
+    context "with no net access" do
+      Given { Net::HTTP.should_not_receive(:start) }
+
+      context "store assumes .html extension by default" do
+        When { cache.store('hello.yml', 'hi')}
+        Then { check_file_presence('hello.yml', true) }
+      end
+
+      context "store assumes .html extension by default" do
+        When { cache.store('hello', 'hi')}
+        Then { check_file_presence('hello.html', true) }
+      end
+
+      context "fetch should not access net when file is cached" do
+        Given { write_file('hello.html', 'hi') }
+        When { cache.fetch('hello') }
+      end
+    end
+  end
+
+  context "c extensions list" do
+    Given(:list) { JRuby::Lint::Libraries::CExtensions.new(cache) }
+    When { list.load }
+    Then { list.gems.keys.should include("rdiscount", "rmagick")}
+  end
+
+  context "aggregate information" do
+    Given(:info) { JRuby::Lint::Libraries.new(cache) }
+    When { info.load }
+    Then { info.gems.keys.should include("rdiscount", "rmagick")}
+  end
+end

data/spec/jruby/lint/project_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe JRuby::Lint::Project do
+  Given(:project) { in_current_dir { JRuby::Lint::Project.new.tap {|p| p.reporters.clear } } }
+
+  context "collects Ruby scripts" do
+    Given { write_file('script.rb', '') }
+    When { @collectors = project.collectors }
+    Then { @collectors.size.should == 1 }
+    Then { @collectors.first.should be_instance_of(JRuby::Lint::Collectors::Ruby) }
+  end
+
+  context "collects Bundler Gemfiles" do
+    Given { write_file('Gemfile', '') }
+    When { @collectors = project.collectors }
+    Then { @collectors.size.should == 1 }
+    Then { @collectors.first.should be_instance_of(JRuby::Lint::Collectors::Bundler) }
+  end
+
+  context "collects Rakefiles" do
+    Given { write_file('Rakefile', '') }
+    When { @collectors = project.collectors }
+    Then { @collectors.size.should == 1 }
+    Then { @collectors.first.should be_instance_of(JRuby::Lint::Collectors::Rake) }
+  end
+
+  context "collects gemspecs" do
+    Given { write_file('temp.gemspec', '') }
+    When { @collectors = project.collectors }
+    Then { @collectors.size.should == 1 }
+    Then { @collectors.first.should be_instance_of(JRuby::Lint::Collectors::Gemspec) }
+  end
+
+  context "aggregates findings from all collectors" do
+    Given(:collector1) do
+      double("collector 1").tap do |c1|
+        c1.should_receive(:run)
+        c1.stub!(:findings).and_return [double("finding 1")]
+      end
+    end
+    Given(:collector2) do
+      double("collector 2").tap do |c2|
+        c2.should_receive(:run)
+        c2.stub!(:findings).and_return [double("finding 2")]
+      end
+    end
+
+    When { project.collectors.replace([collector1, collector2]) }
+    When { findings = project.run }
+
+    Then { project.findings.size.should == 2 }
+  end
+
+  context "reports findings" do
+    Given(:finding) { double "finding" }
+
+    Given(:collector) do
+      double("collector").tap do |c|
+        c.should_receive(:run)
+        c.stub!(:findings).and_return [finding]
+      end
+    end
+
+    Given(:reporter) do
+      double("reporter").tap do |r|
+        r.should_receive(:report).with([finding])
+      end
+    end
+
+    When do
+      project.collectors.replace [collector]
+      project.reporters.replace [reporter]
+    end
+
+    Then { project.run }
+  end
+end

data/spec/jruby/lint/reporters_spec.rb

@@ -0,0 +1,42 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe JRuby::Lint::Reporters do
+  Given(:project) { double "project", :tags => %w(warning error info) }
+
+  context "Text reporter" do
+    Given(:reporter) { JRuby::Lint::Reporters::Text.new(project, output) }
+
+    context "with a finding sharing a tag with the project" do
+      Given(:finding) { double "finding", :to_s => "hello", :tags => %w(info) }
+      Given(:output) { double("output").tap {|o| o.should_receive(:puts).with("hello") } }
+
+      Then { reporter.report [finding] }
+    end
+
+    context "with a finding sharing no tags with the project" do
+      Given(:finding) { double "finding", :to_s => "hello", :tags => %w(debug) }
+      Given(:output) { double("output").tap {|o| o.should_not_receive(:puts) } }
+
+      Then { reporter.report [finding] }
+    end
+  end
+
+  context "Color text reporter" do
+    include Term::ANSIColor
+    Given(:reporter) { JRuby::Lint::Reporters::ANSIColor.new(project, output) }
+
+    context "shows a finding tagged 'error' in red" do
+      Given(:finding) { double "finding", :to_s => "hello", :tags => %w(error) }
+      Given(:output) { double("output").tap {|o| o.should_receive(:puts).with(red("hello")) } }
+
+      Then { reporter.report [finding] }
+    end
+
+    context "shows a finding tagged 'warning' in yellow" do
+      Given(:finding) { double "finding", :to_s => "hello", :tags => %w(warning) }
+      Given(:output) { double("output").tap {|o| o.should_receive(:puts).with(yellow("hello")) } }
+
+      Then { reporter.report [finding] }
+    end
+  end
+end