jruby-lint 0.4.1 → 0.9.0

data/lib/jruby/lint/cli.rb

@@ -38,6 +38,10 @@ module JRuby
             @options.ansi = true
           end
 
+          opts.on('--no-source-line', 'do not print out line of source') do
+            @options.no_src_line = true
+          end
+
           opts.on('--html [REPORT_FILE]', 'print report as html file') do |file|
             @options.html = file || 'jruby-lint.html'
           end
@@ -55,6 +59,9 @@ module JRuby
         end.parse!(args)
 
         @options.files = args.empty? ? nil : args
+      rescue OptionParser::InvalidOption
+        puts $!.message
+        exit -1
       end
 
       def run
@@ -71,7 +78,7 @@ module JRuby
           puts "OK"
           exit
         else
-          puts "Found #{project.findings.size} items"
+          puts "Found #{project.findings.count { |e| !e.tags.include? "internal" } } items"
           exit 1
         end
       end

data/lib/jruby/lint/collectors.rb

@@ -1,16 +1,25 @@
 module JRuby::Lint
   class Collector
-    attr_accessor :checkers, :findings, :project, :contents, :file
+    attr_accessor :checkers, :findings, :project, :contents, :file, :stack
 
     def initialize(project = nil, file = nil)
       @checkers = Checker.loaded_checkers.map(&:new)
       @checkers.each {|c| c.collector = self }
       @findings = []
       @project, @file = project, file || '<inline-script>'
+
+      # top to bottom list of elements as they are visited
+      @stack = [] # FIXME: ast visiting is not something checkers can see so stored here for now
+    end
+
+    def add_finding(message, tags, line=nil)
+      src_line = line ? contents.split(/\n/)[line-1] : nil
+      @findings << Finding.new(message, tags, file, line, src_line)
     end
 
     class CheckersVisitor < AST::Visitor
-      attr_reader :collector, :checkers
+      attr_reader :collector, :checkers, :stack
+
 
       def initialize(ast, collector, checkers)
         super(ast)
@@ -18,6 +27,7 @@ module JRuby::Lint
       end
 
       def visit(method, node)
+        @collector.stack.push  node
         after_hooks = []
         checkers.each do |ch|
           begin
@@ -26,19 +36,20 @@ module JRuby::Lint
               after_hooks << res if res.respond_to?(:call)
             end
           rescue Exception => e
-            collector.findings << Finding.new("Exception while traversing: #{e.message}\n  at #{e.backtrace.first}",
-                                              [:internal, :debug], node.position)
+            collector.add_finding("Exception while traversing: #{e.message}\n  at #{e.backtrace.first}",
+                                              [:internal, :debug], node.line+1)
           end
         end
         super
       rescue Exception => e
-        collector.findings << Finding.new("Exception while traversing: #{e.message}\n  at #{e.backtrace.first}",
-                                          [:internal, :debug], node.position)
+        collector.add_finding("Exception while traversing: #{e.message}\n  at #{e.backtrace.first}",
+                                          [:internal, :debug], node.line+1)
       ensure
         begin
           after_hooks.each {|h| h.call }
         rescue
         end
+        @collector.stack.pop
       end
     end
 
@@ -47,7 +58,7 @@ module JRuby::Lint
         CheckersVisitor.new(ast, self, checkers).traverse
       rescue SyntaxError => e
         file, line, message = e.message.split(/:\s*/, 3)
-        findings << Finding.new(message, [:syntax, :error], file, line)
+        add_finding(message, [:syntax, :error], line.to_i)
       end
     end
 

data/lib/jruby/lint/finding.rb

@@ -1,5 +1,5 @@
 module JRuby::Lint
-  class Finding < Struct.new(:message, :tags, :file, :line)
+  class Finding < Struct.new(:message, :tags, :file, :line, :src_line)
     def initialize(*args)
       args[1].map! {|x| x.to_s } if args.size > 1
       if args.size > 2 && args[2].respond_to?(:file) && args[2].respond_to?(:line)

data/lib/jruby/lint/libraries.rb

@@ -1,5 +1,4 @@
 require 'net/https'
-require 'nokogiri'
 require 'tempfile'
 require 'fileutils'
 
@@ -27,7 +26,7 @@ module JRuby::Lint
 
       def filename_for(name)
         name = File.basename(name)
-        File.join(@cache_dir, File.extname(name).empty? ? "#{name}.html" : name)
+        File.join(@cache_dir, File.extname(name).empty? ? "#{name}.md" : name)
       end
 
       def stale?(filename)
@@ -35,28 +34,10 @@ module JRuby::Lint
       end
 
       def read_from_wiki(name, filename)
-        content = nil
-        uri = Net::HTTP.start('wiki.jruby.org', 80) do |http|
-          URI.parse http.head(name =~ %r{^/} ? name : "/#{name}")['Location']
-        end
-        if uri.host == "github.com"
-          Net::HTTP.new(uri.host, uri.port).tap do |http|
-            if uri.scheme == "https"
-              http.use_ssl = true
-              http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-              # gd_bundle.crt from https://certs.godaddy.com/anonymous/repository.seam
-              http.ca_file = File.expand_path('../github.crt', __FILE__)
-            end
-            http.start do
-              response = http.get(uri.path)
-              content = response.body
-              File.open(filename, "w") do |f|
-                f << content
-              end
-            end
-          end
-        end
-        raise "Unknown location '#{uri}' for page '#{name}'" unless content
+        require 'open-uri'
+        download = open('https://github.com/jruby/jruby/wiki/C-Extension-Alternatives.md')
+        content = download.read(nil)
+        File.open(filename, "w") { |f| f << content }
         content
       rescue => e
         raise "Error while reading from wiki: #{e.message}\nPlease try again later."
@@ -72,11 +53,21 @@ module JRuby::Lint
 
       def load
         @gems = {}
-        content = @cache.fetch('C-Extension-Alternatives')
-        doc = Nokogiri::HTML(content)
-        doc.css('#wiki-body ul li').each do |li|
-          key, message = li.text.split(/[ -]+/, 2)
-          @gems[key.downcase] = message
+        content = @cache.fetch('C-Extension-Alternatives.md')
+
+        in_suggestions = false
+        content.split("\n").each do |line|
+          if line =~ /<!-- suggestions start/
+            in_suggestions = true
+          elsif !in_suggestions
+            next
+          elsif line =~ /<!-- suggestions end/
+            in_suggestions = false
+            break
+          else
+            _, key, value = line.gsub(/[\[\]]/, '').split("|", 3)
+            @gems[key.downcase] = value
+          end
         end
       rescue => e
         @error = "Unable to load C Extension alternatives list: #{e.message}"
@@ -85,7 +76,7 @@ module JRuby::Lint
 
     SOURCES = [CExtensions]
 
-    attr_reader :gems
+    attr_accessor :gems
 
     def initialize(cache)
       @sources = SOURCES.map {|s| s.new(cache) }

data/lib/jruby/lint/project.rb

@@ -52,9 +52,9 @@ module JRuby::Lint
 
     def load_reporters(options)
       @reporters = []
-      @reporters << Reporters::Html.new(self, options.html) if options.html
-      @reporters << Reporters::ANSIColor.new(self, STDOUT) if options.ansi || STDOUT.tty?
-      @reporters << Reporters::Text.new(self, STDOUT) if options.text || @reporters.empty?
+      @reporters << Reporters::Html.new(self, options.html, options) if options.html
+      @reporters << Reporters::ANSIColor.new(self, STDOUT, options) if options.ansi || STDOUT.tty?
+      @reporters << Reporters::Text.new(self, STDOUT, options) if options.text || @reporters.empty?
     end
 
     def load_libraries

data/lib/jruby/lint/reporters/html.rb

@@ -1,11 +1,12 @@
+require 'ostruct'
+
 module JRuby::Lint
   module Reporters
     class Html
       require 'erb'
 
-      def initialize(project, output)
-        @tags = project.tags
-        @output = output
+      def initialize(project, output, options=OpenStruct.new)
+        @tags, @output, @options = project.tags, output, options
         @template = ERB.new(File.read(File.expand_path('../jruby-lint.html.erb', __FILE__)))
       end
 

data/lib/jruby/lint/reporters/jruby-lint.html.erb

@@ -29,10 +29,19 @@ nav { position: relative; }
           <% @findings.each do |finding| %>
             <% if finding.error? %>
               <li class="error"><%= finding %></li>
-            <% elsif finding.warning? %>
+              <% if finding.src_line && !@options.no_src_line%>
+              <pre><%= finding.src_line %></pre>
+              <% end %>
+              <% elsif finding.warning? %>
               <li class="warning"><%= finding %></li>
+              <% if finding.src_line && !@options.no_src_line%>
+              <pre><%= finding.src_line %></pre>
+              <% end %>
             <% else %>
               <li class="message"><%= finding %></li>
+              <% if finding.src_line && !@options.no_src_line%>
+              <pre><%= finding.src_line %></pre>
+              <% end %>
             <% end %>
           <% end %>
         </ul>

data/lib/jruby/lint/reporters/text.rb

@@ -1,8 +1,8 @@
 module JRuby::Lint
   module Reporters
     class Text
-      def initialize(project, output)
-        @tags, @output = project.tags, output
+      def initialize(project, output, options=OpenStruct.new)
+        @tags, @output, @options = project.tags, output, options
       end
 
       def report(findings)
@@ -23,11 +23,12 @@ module JRuby::Lint
         msg = if finding.error?
                 red(finding.to_s)
               elsif finding.warning?
-                yellow(finding.to_s)
+                cyan(finding.to_s)
               else
-                finding.to_s
+                blue(finding.to_s)
               end
         @output.puts msg
+        @output.puts finding.src_line if finding.src_line && !@options.no_src_line
       end
     end
   end

data/lib/jruby/lint/version.rb

@@ -1,5 +1,5 @@
 module JRuby
   module Lint
-    VERSION = "0.4.1"
+    VERSION = "0.9.0"
   end
 end

data/spec/fixtures/C-Extension-Alternatives.md

@@ -0,0 +1,81 @@
+JRuby does not support native C extensions, but it does have it's own Java native extensions API.  Several gems have implementations of both Java and C extensions rolled into the same gem and those will not be listed here since they will just work.  In some cases there is a JRuby version with a slightly different name or possibly even a totally different name and we list these here so you can update your Gemfile:
+
+```ruby
+gem 'therubyracer', platform: :mri
+gem 'therubyrhino', platform: :jruby
+```
+
+When there is not an exact match some gems come close enough where a little work on your part can make your application compatible with JRuby.
+
+This page lists common C extensions and JRuby-friendly alternatives you can use to replace them.
+
+If you are interested in helping us port an extension to JRuby, this article is helpful: [Your first Ruby native extension: Java](https://blog.jcoglan.com/2012/08/02/your-first-ruby-native-extension-java/) see also [JRuby examples](https://github.com/jruby/jruby-examples) for a maven build.
+
+<!-- suggestions start -->
+| Gem | Suggestions |
+|-----|-------------|
+|[RDiscount][]|Use [kramdown][], [Maruku][] (pure Ruby) or [markdown_j][] (wrapper around a Java library)|
+|[RedCarpet][]|Same as with **RDiscount** use alternatives such as [kramdown][], [Maruku][] or [markdown_j][]|
+|[RMagick][]|Try [RMagick4J][] (implements ImageMagick functionality in Java) or preferably use alternatives [mini_magick][] & [quick_magick][]. For simple resizing, cropping, greyscaling, etc look at [image_voodoo][]. You can also use Java's Graphics2D.|
+|[Unicorn][]| Use [Puma][].|
+|[Thin][]| Use [Puma][].|
+|mysql|Use [activerecord-jdbcmysql-adapter][].|
+|mysql2|Use [activerecord-jdbcmysql-adapter][].|
+|sqlite3|Use [activerecord-jdbcsqlite3-adapter][].|
+|pg|Use [activerecord-jdbcpostgresql-adapter][] instead or [pg_jruby][] (drop-in replacement).|
+|[yajl-ruby][]|Try `json` or `json_pure` instead. Unfortunately there is no known equivalent JSON stream parser.|
+|[oj][]|Try `gson`, `json` or `json_pure` instead.|
+|[bson_ext][]|`bson_ext` isn't used with JRuby. Instead, some native Java extensions are bundled with the `bson` gem.|
+|[win32ole][]|Use the `jruby-win32ole` gem (preinstalled in JRuby's Windows installer).|
+|[curb][]|[Rurl][] is an example how to implement _some_ of curb's functionality using [Apache HttpClient][]|
+|[therubyracer][]|Try using [therubyrhino][] instead (or [dienashorner][] on Java 8+).|
+|[kyotocabinet][]|Try using [kyotocabinet-java][] instead. This isn't 100% complete yet, but it covers most of the API.|
+|[memcached][]|Try using [jruby-memcached][] instead. Alternatively you can use [jruby-ehcache][], a JRuby interface to Java's (JSR-107 compliant) Ehcache.|
+|[charlock_holmes][]|Use [charlock_holmes-jruby][] instead.|
+<!-- suggestions end -->
+
+Please add to this list with your findings.
+
+*Note that the [JRuby-Lint][] gem parses the contents of the list above to use for its Ruby gem checker. In order for JRuby-Lint to use the information, please adhere to the table format above and the links to projects below (in the source for this page).
+
+<!-- links start -->
+[RDiscount]: http://dafoster.net/projects/rdiscount/
+[RedCarpet]: https://github.com/vmg/redcarpet
+[kramdown]: https://github.com/gettalong/kramdown
+[Maruku]:https://github.com/bhollis/maruku
+[markdown_j]: https://github.com/nate/markdown_j
+[RMagick]: https://github.com/rmagick/rmagick
+[RMagick4J]: https://github.com/Serabe/RMagick4J
+[mini_magick]: https://github.com/minimagick/minimagick
+[quick_magick]: https://github.com/aseldawy/quick_magick
+[image_voodoo]: https://github.com/jruby/image_voodoo
+[Unicorn]: http://unicorn.bogomips.org/
+[Puma]: http://puma.io/
+[Thin]: http://code.macournoyer.com/thin/
+[Typhoeus]: https://github.com/dbalatero/typhoeus
+[activerecord-jdbc-adapter]: https://github.com/jruby/activerecord-jdbc-adapter
+[JRuby-Lint]: https://github.com/jruby/jruby-lint
+[Nokogiri]: http://nokogiri.org/
+[yajl-ruby]: https://github.com/brianmario/yajl-ruby
+[bson_ext]: https://github.com/mongodb/mongo-ruby-driver
+[Apache HttpClient]: http://hc.apache.org/httpcomponents-client-ga/
+[HttpURLConnection]: http://download.oracle.com/javase/1,5.0/docs/api/java/net/HttpURLConnection.html
+[win32ole]: http://www.ruby-doc.org/stdlib/libdoc/win32ole/rdoc/index.html
+[Rurl]: https://github.com/rcyrus/Rurl
+[curb]: https://github.com/taf2/curb
+[therubyracer]: https://github.com/cowboyd/therubyracer
+[therubyrhino]: https://github.com/cowboyd/therubyrhino
+[dienashorner]: https://github.com/kares/dienashorner
+[kyotocabinet]: http://fallabs.com/kyotocabinet/
+[kyotocabinet-java]: https://github.com/csw/kyotocabinet-java
+[memcached]: https://github.com/evan/memcached
+[jruby-memcached]: https://github.com/aurorafeint/jruby-memcached
+[jruby-ehcache]: https://github.com/dylanz/ehcache
+[oj]: https://github.com/ohler55/oj
+[activerecord-jdbcmysql-adapter]: https://rubygems.org/gems/activerecord-jdbcmysql-adapter
+[activerecord-jdbcsqlite3-adapter]: https://rubygems.org/gems/activerecord-jdbcsqlite3-adapter
+[activerecord-jdbcpostgresql-adapter]: https://rubygems.org/gems/activerecord-jdbcpostgresql-adapter
+[pg_jruby]: https://rubygems.org/gems/pg_jruby
+[charlock_holmes]: https://github.com/brianmario/charlock_holmes
+[charlock_holmes-jruby]: https://github.com/siuying/charlock_holmes-jruby
+<!-- links start -->

data/spec/jruby/lint/ast_spec.rb

@@ -5,19 +5,19 @@ describe JRuby::Lint::AST::Visitor do
   Given(:visitor) { JRuby::Lint::AST::Visitor.new(ast) }
 
   # RootNode
-  #   NewlineNode
-  #     FCallOneArgNode |puts|
-  #       ArrayNode
-  #         StrNode =="hello"
+  #   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 }
+    Then { expect(@count).to eq(4) }
   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" }
+    Then { expect(@nodes.size).to(eq(1)) &&
+           expect(@nodes.first.value.to_s).to(eq("hello")) }
   end
 end

data/spec/jruby/lint/checkers_spec.rb

@@ -5,14 +5,14 @@ describe JRuby::Lint::Checker do
     subject { Class.new { include JRuby::Lint::Checker } }
 
     it "finds all loaded checkers" do
-      JRuby::Lint::Checker.loaded_checkers.should include(subject)
+      expect(JRuby::Lint::Checker.loaded_checkers).to 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(:project) {JRuby::Lint::Project.new.tap {|p| p.libraries.gems = gems }}
   Given(:collector) do
     JRuby::Lint::Collector.new(project).tap do |c|
       c.contents = script
@@ -26,16 +26,16 @@ describe JRuby::Lint::Checkers do
 
     context "detects fcall-style" do
       # FCallNoArgBlockNode |fork|
-      Given(:script) { "fork { }; exec('cmd')" }
+      Given(:script) { "fork { }" }
       When { collector.run }
-      Then { collector.findings.size.should == 2 }
+      Then { expect(collector.findings.size).to eq(1) }
     end
 
     context "detects vcall-style" do
       # VCallNode |fork|
       Given(:script) { "fork" }
       When { collector.run }
-      Then { collector.findings.size.should == 1 }
+      Then { expect(collector.findings.size).to eq(1) }
     end
 
     context "does not detect call-style" do
@@ -43,15 +43,15 @@ describe JRuby::Lint::Checkers do
       #   VCallNode |fork|
       Given(:script) { "fork.fork" }
       When { collector.run }
-      Then { collector.findings.size.should == 0 }
+      Then { expect(collector.findings.size).to eq(0) }
     end
 
     context "detects Kernel::fork style" do
       # CallNoArgNode |fork|
       #   ConstNode |Kernel|
-      Given(:script) { "Kernel::fork; Kernel::exec('cmd')" }
+      Given(:script) { "Kernel::fork" }
       When { collector.run }
-      Then { collector.findings.size.should == 2 }
+      Then { expect(collector.findings.size).to eq(1) }
     end
   end
 
@@ -61,25 +61,43 @@ describe JRuby::Lint::Checkers do
     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 }
+      Then { expect(collector.findings.size).to eq(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 }
+      Then { expect(collector.findings.size).to eq(3) }
+    end
+
+    context "ignores platform for gem compatibility if not right platform" do
+      Given(:script) { "gem 'rdiscount', platform: :ruby" }
+      When { collector.run }
+      Then { expect(collector.findings.size).to eq(0) }
+    end
+
+    context "creates a finding if platform for gem compatibility is ours" do
+      Given(:script) { "gem 'rdiscount', platform: :jruby" }
+      When { collector.run }
+      Then { expect(collector.findings.size).to eq(2) }
+    end
+
+    context "creates no finding if in wrong platform block" do
+      Given(:script) { "platforms :ruby {  gem 'rdiscount' }" }
+      When { collector.run }
+      Then { expect(collector.findings.size).to eq(1) }
     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 }
+      Then { expect(collector.findings.size).to eq(0) }
     end
 
     context "only checks calls to #gem" do
       Given(:script) { "require 'rdiscount'" }
       When { collector.run }
-      Then { collector.findings.size.should == 0 }
+      Then { expect(collector.findings.size).to eq(0) }
     end
   end
 
@@ -91,8 +109,8 @@ describe JRuby::Lint::Checkers do
       "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 }
+    Then { expect(collector.findings.size).to eq(2) }
+    Then { expect(collector.findings.detect{|f| f.message =~ /rdiscount/ }).to be_truthy }
   end
 
   context "Thread.critical checker" do
@@ -101,13 +119,13 @@ describe JRuby::Lint::Checkers do
     context "read" do
       Given(:script) { "begin \n Thread.critical \n end"}
       When { collector.run }
-      Then { collector.findings.size.should == 1 }
+      Then { expect(collector.findings.size).to eq(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 }
+      Then { expect(collector.findings.size).to eq(2) }
     end
   end
 
@@ -117,70 +135,53 @@ describe JRuby::Lint::Checkers do
     context "_id2ref usage" do
       Given(:script) { "ObjectSpace._id2ref(obj)"}
       When { collector.run }
-      Then { collector.findings.size.should == 1 }
+      Then { expect(collector.findings.size).to eq(1) }
     end
 
     context "each_object usage" do
       Given(:script) { "ObjectSpace.each_object { }"}
       When { collector.run }
-      Then { collector.findings.size.should == 1 }
+      Then { expect(collector.findings.size).to eq(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 }
+      Then { collector.findings; expect(collector.findings.size).to eq(0) }
     end
   end
 
-  context "Timeout::timeout" do
-    Given(:checker) { JRuby::Lint::Checkers::Timeout.new }
-
-    context "::timeout usage" do
-      Given(:script) { "Timeout::timeout(5) { sleep 10 }"}
-      When { collector.run }
-      Then { collector.findings.size.should == 1}
-    end
-
-    context ".timeout usage" do
-      Given(:script) { "Timeout.timeout(5) { sleep 10 }" }
-      When { collector.run }
-      Then { collector.findings.size.should == 1}
-    end
-  end
-
-
   context "System" do
     Given(:checker) { JRuby::Lint::Checkers::System.new }
 
     context "calling ruby -v in system" do
       Given(:script) { "system('echo'); system('/usr/bin/ruby -v')"}
       When { collector.run }
-      Then { collector.findings.size.should == 1}
+      Then { expect(collector.findings.size).to eq(1) }
     end
 
     context "calling ruby in the first argument to system" do
       Given(:script) { "system('/usr/bin/ruby', '-v')"}
       When { collector.run }
-      Then { collector.findings.size.should == 1}
+      Then { expect(collector.findings.size).to eq(1) }
     end
 
     context "calling irb or jirb from system" do
       Given(:script) { "system('jirb'); system('irb')"}
       When { collector.run }
-      Then { collector.findings.size.should == 2 }
+      Then { expect(collector.findings.size).to eq(2) }
     end
 
     context "calling a .rb file from system" do
       Given(:script) { "system('asdf.rb')" }
       When { collector.run }
-      Then { collector.findings.size.should == 1 }
+      Then { expect(collector.findings.size).to eq(1) }
     end
 
     context "calling ruby -v in Kernel.system should have a finding" do
       Given(:script) { "Kernel.system('ruby -v'); Kernel.system('echo \"zomg\"')"}
       When { collector.run }
-      Then { collector.findings.size.should == 1}
+      Then { expect(collector.findings.size).to eq(1) }
     end
 
   end
@@ -191,75 +192,103 @@ describe JRuby::Lint::Checkers do
     context "class variable or-assignment" do
       Given(:script) { "@@foo ||= 1" }
       When { collector.run }
-      Then { collector.findings.size.should == 1 }
+      Then { expect(collector.findings.size).to eq(1) }
     end
 
     context "instance variable or-assignment" do
       Given(:script) { "@foo ||= 1" }
       When { collector.run }
-      Then { collector.findings.size.should == 1 }
+      Then { expect(collector.findings.size).to eq(1) }
+      Then { expect(collector.findings.first.message).to be =~ /\(@foo\)/ }
     end
 
     context "attribute or-assignment" do
       Given(:script) { "foo.bar ||= 1" }
       When { collector.run }
-      Then { collector.findings.size.should == 1 }
+      Then { expect(collector.findings.size).to eq(1) }
+      Then { expect(collector.findings.first.message).to be =~ /\(bar\)/ }
     end
 
     context "element or-assignment" do
       Given(:script) { "foo[bar] ||= 1" }
       When { collector.run }
-      Then { collector.findings.size.should == 1 }
+      Then { expect(collector.findings.size).to eq(1) }
+      Then { expect(collector.findings.first.message).to be =~ /\(foo\[bar\]\)/ }
     end
 
     context "class variable and-assignment" do
       Given(:script) { "@@foo &&= 1" }
       When { collector.run }
-      Then { collector.findings.size.should == 1 }
+      Then { expect(collector.findings.size).to eq(1) }
+      Then { expect(collector.findings.first.message).to be =~ /\(@@foo\)/ }
     end
 
     context "instance variable and-assignment" do
       Given(:script) { "@foo &&= 1" }
       When { collector.run }
-      Then { collector.findings.size.should == 1 }
+      Then { expect(collector.findings.size).to eq(1) }
+      Then { expect(collector.findings.first.message).to be =~ /\(@foo\)/ }
     end
 
     context "attribute and-assignment" do
       Given(:script) { "foo.bar &&= 1" }
       When { collector.run }
-      Then { collector.findings.size.should == 1 }
+      Then { expect(collector.findings.size).to eq(1) }
+      Then { expect(collector.findings.first.message).to be =~ /\(bar\)/ }
     end
 
     context "element and-assignment" do
       Given(:script) { "foo[bar] &&= 1" }
       When { collector.run }
-      Then { collector.findings.size.should == 1 }
+      Then { expect(collector.findings.size).to eq(1) }
+      Then { expect(collector.findings.first.message).to be =~ /\(foo\[bar\]\)/ }
     end
 
-    pending "needs better representation in AST" do
-      context "class variable op-assignment" do
-	Given(:script) { "@@foo += 1" }
-	When { collector.run }
-	Then { collector.findings.size.should == 1 }
-      end
+    context "element and-assignment (complicated name)" do
+      Given(:script) { "foo[bar(2, heh)] &&= 1" }
+      When { collector.run }
+      Then { expect(collector.findings.size).to eq(1) }
+      Then { expect(collector.findings.first.message).to be =~ /\(foo\[bar\(2, heh\)\]\)/ }
+    end
+
+    context "class variable op-assignment" do
+      Given(:script) { "@@foo += 1" }
+      When { collector.run }
+      Then { expect(collector.findings.size).to eq(1) }
+      Then { expect(collector.findings.first.message).to be =~ /\(@@foo\)/ }
+    end
 
-      context "instance variable op-assignment" do
-	Given(:script) { "@foo += 1" }
-	When { collector.run }
-	Then { collector.findings.size.should == 1 }
-      end
+    context "instance variable op-assignment" do
+      Given(:script) { "@foo += 1" }
+      When { collector.run }
+      Then { expect(collector.findings.size).to eq(1) }
+      Then { expect(collector.findings.first.message).to be =~ /\(@foo\)/ }
     end
 
     context "attribute op-assignment" do
       Given(:script) { "foo.bar += 1" }
       When { collector.run }
-      Then { collector.findings.size.should == 1 }
+      Then { expect(collector.findings.size).to eq(1) }
+      Then { expect(collector.findings.first.message).to be =~ /\(bar\)/ }
     end
 
     context "element op-assignment" do
       Given(:script) { "foo[bar] += 1" }
       When { collector.run }
-      Then { collector.findings.size.should == 1 }
+      Then { expect(collector.findings.size).to eq(1) }
+      Then { expect(collector.findings.first.message).to be =~ /\(foo\[bar\]\)/ }
+    end
+
+    context "ignores simple inst assignment" do
+      Given(:script) { "@foo = 1" }
+      When { collector.run }
+      Then { expect(collector.findings.size).to eq(0) }
+    end
+    
+    context "ignores simple cvar assignment" do
+      Given(:script) { "@@foo = 1" }
+      When { collector.run }
+      Then { expect(collector.findings.size).to eq(0) }
     end
   end
 end