jruby-lint 0.4.1 → 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8acd78ec48b4d72064f74789407130256498dc68b6098c110a63cb09c49a157f
+  data.tar.gz: 732d5f3eca8aeb36fc73f9a36b86aa2f0491908d2e11044f9dc7eae28b8ae76d
+SHA512:
+  metadata.gz: 1a71a1e831b137e562bb5153a0734a079756c35656c5ef8dd998171f5d7b6fe7f8ea366a2bb4ef0c32a3a00bf698fcee7f1847bd65bafe1344e2b7fe9591b338
+  data.tar.gz: 18b7f7e00ead7675ac6bbe625bca3c3a825f3ac739c1a674acf568157e2a13dd0313b22b1dedb7418d59023c7858c4c1789a589607ce7f45208a815a2b1543d1

data/Gemfile

@@ -8,4 +8,5 @@ gem 'guard'
 gem 'guard-rspec'
 gem 'growl'
 gem 'rb-fsevent'
-gem 'rcov'
+
+

data/README.md

@@ -23,11 +23,8 @@ Here is a list of the current checks implemented:
 - Report usage of Thread.critical, which is discouraged in favor of a
   plain Mutex.
 - Report known gems and libraries that use C extensions and try to
-  provide known alternatives.
-- Report usage of Kernel#fork (which does not work) and Kernel#exec
-  (which does not replace the current process).
-- Report usage of Timeout::timeout which, when used excessively tend
-  to be slow and expensive because of native threads
+  provide known alternatives (Live data retrieved from https://github.com/jruby/jruby/wiki/C-Extension-Alternatives).
+- Report usage of Kernel#fork (which does not work).
 - Report behavior difference when using system('ruby'), which launches
   the command in-process in a new copy of the interpreter for speed
 
@@ -40,7 +37,6 @@ to generate an html report with the results.
 
 Here is a list of checks and options we'd like to implement:
 
-- Add in check for `` to make sure not execing ruby ...
 - Report on more threading and concurrency issues/antipatterns
   - arr.each {|x| arr.delete(x) }
 - Try to detect IO/File resource usage without blocks
@@ -52,8 +48,6 @@ Here is a list of checks and options we'd like to implement:
 - Detect Bundler gems that have a `platforms` qualifier and ignore
   "platforms :ruby"
 - Change to use jruby-parser
-- 1.8/1.9 parser support/configuration without having to run JRuby
-  itself in the right mode
 - Allow use of a comment marker to suppress individual checks
 
 ### Further Down the Road

data/jruby-lint.gemspec

@@ -6,9 +6,10 @@ Gem::Specification.new do |s|
   s.name        = "jruby-lint"
   s.version     = JRuby::Lint::VERSION
   s.platform    = Gem::Platform::RUBY
+  s.required_ruby_version = '>= 2.5.3'
   s.authors     = ["Nick Sieger"]
   s.email       = ["nick@nicksieger.com"]
-  s.licenses    = ["EPL 1.0", "GPL 2", "LGPL 2.1"]
+  s.licenses    = ["EPL-1.0", "GPL-2.0", "LGPL-2.1"]
   s.homepage    = "https://github.com/jruby/jruby-lint"
   s.summary     = %q{See how ready your Ruby code is to run on JRuby.}
   s.description = %q{This utility presents hints and suggestions to
@@ -26,8 +27,6 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_dependency "term-ansicolor"
-  s.add_dependency "jruby-openssl"
-  s.add_dependency "nokogiri", ">= 1.5.0.beta.4"
   s.add_development_dependency "rake"
   s.add_development_dependency "rspec", ">= 2.5"
   s.add_development_dependency "rspec-given"

data/lib/jruby/lint/ast.rb

@@ -32,7 +32,7 @@ module JRuby::Lint
     class Visitor
       include Enumerable
       include org.jruby.ast.visitor.NodeVisitor
-      attr_reader :ast
+      attr_reader :ast, :stack
 
       def initialize(ast)
         @ast = ast

data/lib/jruby/lint/checkers.rb

@@ -10,6 +10,24 @@ module JRuby::Lint
       @checkers ||= []
     end
 
+    # Note: for parentage methods below -1 is current visited, -2 is parent ,...
+
+    ##
+    # What is parent during visit of the current node being visited.
+    def parent
+      collector.stack.size >= 2 ? collector.stack[-2] : nil 
+    end
+
+    def grand_parent
+      collector.stack.size >= 3 ? collector.stack[-3] : nil 
+    end
+
+    ##
+    # source line with line node provides
+    def src_line(line)
+      collector.contents.split(/\n/)[line]
+    end
+
     attr_accessor :collector
   end
 
@@ -22,6 +40,5 @@ require 'jruby/lint/checkers/gem'
 require 'jruby/lint/checkers/gemspec'
 require 'jruby/lint/checkers/thread_critical'
 require 'jruby/lint/checkers/object_space'
-require 'jruby/lint/checkers/timeout'
 require 'jruby/lint/checkers/system'
 require 'jruby/lint/checkers/nonatomic'

data/lib/jruby/lint/checkers/fork_exec.rb

@@ -1,47 +1,30 @@
-module JRuby::Lint
-  module Checkers
-    class ForkExec
-      include Checker
+class JRuby::Lint::Checkers::ForkExec
+  include JRuby::Lint::Checker
 
-      def visitCallNode(node)
-        if fork_exec?(node)
-          @call_node = node
-          child = node.child_nodes.first
-          if child && %w(COLON3NODE CONSTNODE).include?(child.node_type.to_s) && child.name == "Kernel"
-            add_finding(node)
-          end
-          proc { @call_node = nil }
-        end
-      end
-
-      def visitFCallNode(node)
-        add_finding(node) if fork_exec?(node)
+  def visitCallNode(node)
+    if fork?(node)
+      @call_node = node
+      child = node.child_nodes.first
+      if child && %w(COLON3NODE CONSTNODE).include?(child.node_type.to_s) && child.name == :Kernel
+        add_finding(node)
       end
+      proc { @call_node = nil }
+    end
+  end
 
-      def visitVCallNode(node)
-        if fork_exec?(node)
-          add_finding(node) unless @call_node
-        end
-      end
+  def visitFCallNode(node)
+    add_finding node if fork?(node)
+  end
 
-      def fork_exec?(node)
-        node.name == "fork" || node.name == "exec"
-      end
+  def visitVCallNode(node)
+    add_finding node if fork?(node) && !@call_node
+  end
 
-      def add_finding(node)
-        msg = nil
-        tags = [node.name]
-        case node.name
-        when 'fork'
-          msg = 'Kernel#fork is not implemented on JRuby.'
-          tags << :error
-        when 'exec'
-          msg = 'Kernel#exec does not replace the running JRuby process and may behave unexpectedly'
-          tags << :warning
-        end
+  def fork?(node)
+    node.name == :fork
+  end
 
-        collector.findings << Finding.new(msg, tags, node.position)
-      end
-    end
+  def add_finding(node)
+    collector.add_finding('Kernel#fork is not implemented on JRuby.', [:fork, :error], node.line+1)
   end
 end

data/lib/jruby/lint/checkers/gem.rb

@@ -1,45 +1,59 @@
-module JRuby::Lint
-  module Checkers
-    module CheckGemNode
-      def self.add_wiki_link_finding(collector)
-        unless @added_wiki_link
-          collector.findings << Finding.new("For more on gem compatibility see http://wiki.jruby.org/C-Extension-Alternatives",
-                                            [:gems, :info]).tap do |f|
-            def f.to_s
-              message
-            end
+module JRuby::Lint::Checkers
+  module CheckGemNode
+    def self.add_wiki_link_finding(collector)
+      unless @added_wiki_link
+        collector.add_finding("For more on gem compatibility see http://wiki.jruby.org/C-Extension-Alternatives", [:gems, :info]).tap do |f|
+          def f.to_s
+            message
           end
-          @added_wiki_link = true
         end
+        @added_wiki_link = true
       end
+    end
+
+    def gem_name(node)
+      first_arg = node&.args_node&.child_nodes[0]
+      first_arg.value.to_s if first_arg&.node_type&.to_s == "STRNODE"
+    end
 
-      def gem_name(node)
-        first_arg = node.args_node.child_nodes[0]
-        if first_arg.node_type.to_s == "STRNODE"
-          first_arg.value.to_s
+    def jruby_gem_entry?(node)
+      node&.args_node&.child_nodes.each do |child|
+        if child&.node_type&.to_s == "HASHNODE"
+          child.pairs.each do |pair|
+            return false if pair.key.name == :platform &&
+                            pair.value.name != :jruby
+          end
         end
-      rescue
-        nil
       end
 
-      def check_gem(collector, call_node)
-        @gems ||= collector.project.libraries.gems
-        gem_name = gem_name(call_node)
-        if instructions = @gems[gem_name]
-          CheckGemNode.add_wiki_link_finding(collector)
-          msg = "Found gem '#{gem_name}' which is reported to have some issues:\n#{instructions}"
-          collector.findings << Finding.new(msg, [:gems, :warning], call_node.position)
+      # platform(:mri, ...) { gem 'rdiscount' }
+      # FIXME: Esoteric use of platform(...) { group(...) {} } is still broken
+      if grand_parent.kind_of?(org::jruby::ast::CallNode) &&
+         grand_parent.name == :platforms
+        grand_parent.args_node.child_nodes.each do |child|
+          return false if child&.name != :jruby
         end
       end
-    end
 
-    class Gem
-      include Checker
-      include CheckGemNode
+      true  
+    end
 
-      def visitFCallNode(node)
-        check_gem(collector, node) if node.name == "gem"
+    def check_gem(collector, call_node)
+      @gems ||= collector.project.libraries.gems
+      gem_name = gem_name(call_node)
+      if gem_name && jruby_gem_entry?(call_node) && instructions = @gems[gem_name]
+        CheckGemNode.add_wiki_link_finding(collector)
+        msg = "Found gem '#{gem_name}' which is reported to have some issues:\n#{instructions}"
+        collector.add_finding(msg, [:gems, :warning], call_node.line+1)
       end
     end
   end
+
+  class Gem
+    include JRuby::Lint::Checker, CheckGemNode
+
+    def visitFCallNode(node)
+      check_gem(collector, node) if node.name == :gem
+    end
+  end
 end

data/lib/jruby/lint/checkers/gemspec.rb

@@ -18,12 +18,12 @@ module JRuby::Lint
         #         DAsgnNode |s| &0 >0
         #           NilImplicitNode |nil|
         #         BlockNode
-        if node.name == "new" && # new
+        if node.name == :new && # new
             node.args_node.nil? && # no args
             node.iter_node && # with a block
             node.receiver_node.node_type.to_s == "COLON2NODE" && # :: - Colon2
-            node.receiver_node.name == "Specification" &&        # ::Specification
-            node.receiver_node.left_node.name == "Gem"           # Gem::Specification
+            node.receiver_node.name == :Specification &&        # ::Specification
+            node.receiver_node.left_node.name == :Gem           # Gem::Specification
           arg_node = find_first(node.iter_node.var_node) {|n| n.respond_to?(:name) }
           @gemspec_block_var = arg_node.name
           return proc { @gemspec_block_var = nil }
@@ -36,7 +36,7 @@ module JRuby::Lint
         #       ArrayNode
         #         StrNode =="rdiscount"
         if @gemspec_block_var &&
-            node.name == "add_dependency" &&
+            node.name == :add_dependency &&
             node.receiver_node.name == @gemspec_block_var
           check_gem(collector, node)
         end

data/lib/jruby/lint/checkers/nonatomic.rb

@@ -2,38 +2,68 @@ module JRuby::Lint
   module Checkers
     class NonAtomic
       include Checker
+      IVAR = org::jruby::ast::InstVarNode
+      CVAR = org::jruby::ast::ClassVarNode
+
+      OPERATORS = [:+, :-, :/, :*, :&, :|, :^, :>>, :<<, :%, :**]
 
       def visitOpAsgnOrNode(node)
+        @last = node
         check_nonatomic(node, node.first_node)
       end
 
       def visitOpAsgnAndNode(node)
+        @last = node
         check_nonatomic(node, node.first_node)
       end
 
       def visitOpElementAsgnNode(node)
-        add_finding(collector, node)
+        name = src_line(node.line).split(node.operator_name + '=', 2)[0].strip
+        add_finding(collector, node, name)
       end
 
       def visitOpAsgnNode(node)
-        check_nonatomic(node, node.receiver_node)
+        check_nonatomic(node, node.receiver_node, node.variable_name)
+      end
+
+      def operator_op_assignment?(node, type)
+        rhs = node.value_node
+        rhs.kind_of?(org::jruby::ast::CallNode) &&
+          OPERATORS.include?(rhs.name) &&
+          rhs.receiver_node.kind_of?(type)
       end
 
-      def check_nonatomic(orig_node, risk_node)
+      def visitInstAsgnNode(node)
+        if !@last && operator_op_assignment?(node, IVAR) ||
+           @last && parent != @last
+          check_nonatomic(node, node)
+        end
+        @last = nil
+      end
+
+      def visitClassVarAsgnNode(node)
+        if !@last && operator_op_assignment?(node, CVAR) ||
+           @last && parent != @last
+          check_nonatomic(node, node)
+        end
+        @last = nil
+      end
+      
+      def check_nonatomic(orig_node, risk_node, name=nil)
         case risk_node
         when org::jruby::ast::LocalVarNode,
              org::jruby::ast::DVarNode
           # ok...mostly-safe cases
+          false
         else
-          add_finding(collector, orig_node)
+          add_finding(collector, orig_node, name || risk_node.name)
+          true
         end
       end
 
-      def add_finding(collector, node)
-        collector.findings << Finding.new("Non-local operator assignment is not guaranteed to be atomic",
-                                          [:nonatomic, :warning], node.position)
+      def add_finding(collector, node, name)
+        collector.add_finding("Non-local operator assignment (#{name}) is not guaranteed to be atomic.", [:nonatomic, :warning], node.line+1)
       end
     end
   end
 end
-

data/lib/jruby/lint/checkers/object_space.rb

@@ -2,14 +2,16 @@ module JRuby::Lint
   module Checkers
     class ObjectSpace
       include Checker
-      METHODS = %w(each_object _id2ref)
+      METHODS = [:each_object, :_id2ref]
+      OK_ARGS = [:Class, :Module]
 
       def visitCallNode(node)
         if METHODS.include?(node.name)
           begin
-            next unless node.receiver_node.node_type.to_s == "CONSTNODE" && node.receiver_node.name == "ObjectSpace"
-            next if node.args_node && node.args_node.size == 1 &&
-              %w(Class Module).include?(node.args_node[0].name)
+            return unless node.receiver_node.node_type.to_s == "CONSTNODE" &&
+                      node.receiver_node.name == :ObjectSpace
+            return if node.args_node && node.args_node.size == 1 &&
+                      OK_ARGS.include?(node.args_node.first.name)
             add_finding(collector, node)
           rescue
           end
@@ -17,8 +19,8 @@ module JRuby::Lint
       end
 
       def add_finding(collector, node)
-        collector.findings << Finding.new("Use of ObjectSpace is expensive and disabled by default. Use -X+O to enable.",
-                                          [:objectspace, :warning], node.position)
+        collector.add_finding("Use of ObjectSpace is expensive and disabled by default. Use -X+O to enable.",
+                                          [:objectspace, :warning], node.line+1)
       end
     end
   end

data/lib/jruby/lint/checkers/system.rb

@@ -5,7 +5,7 @@ module JRuby::Lint
 
       # Make sure to follow all Kernel.system calls
       def visitCallNode(node)
-        if node.name == "system" || node.name == "`"
+        if node.name == :system || node.name == :'`'
           @call_node = node
           add_finding(node) if red_flag?(node)
           proc { @call_node = nil }
@@ -14,14 +14,14 @@ module JRuby::Lint
 
       # Visits the function calls for system
       def visitFCallNode(node)
-        if node.name == "system"
+        if node.name == :system
           add_finding(node) if red_flag?(node)
         end
       end
 
       def add_finding(node)
-        collector.findings << Finding.new("Calling Kernel.system('ruby ...') will get called in-process.  Sometimes this works differently than expected",
-                                          [:system, :warning], node.position)
+        collector.add_finding("Calling Kernel.system('ruby ...') will get called in-process.  Sometimes this works differently than expected",
+                                          [:system, :warning], node.line+1)
       end
 
       # Defines red_flag when argument matches ruby

data/lib/jruby/lint/checkers/thread_critical.rb

@@ -3,12 +3,12 @@ module JRuby::Lint
     class ThreadCritical
       include Checker
 
-      METHODS = %w(critical critical=)
+      METHODS = [:critical, :critical=]
 
       def visitCallNode(node)
         if METHODS.include?(node.name)
           begin
-            if node.receiver_node.node_type.to_s == "CONSTNODE" && node.receiver_node.name == "Thread"
+            if node.receiver_node.node_type.to_s == "CONSTNODE" && node.receiver_node.name == :Thread
               add_finding(collector, node)
             end
           rescue
@@ -18,8 +18,8 @@ module JRuby::Lint
       alias visitAttrAssignNode visitCallNode
 
       def add_finding(collector, node)
-        collector.findings << Finding.new("Use of Thread.critical is discouraged. Use a Mutex instead.",
-                                          [:threads, :warning], node.position)
+        collector.add_finding("Use of Thread.critical is discouraged. Use a Mutex instead.",
+                                          [:threads, :warning], node.line+1)
       end
     end
   end