jruby-lint 0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+tmp

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in jruby-lint.gemspec
+gemspec
+
+# Until a new childprocess gem incorporates my Dir.pwd fix
+gem 'childprocess', :git => "https://github.com/nicksieger/childprocess.git"
+
+gem 'guard'
+gem 'guard-rspec'
+gem 'growl'
+gem 'rb-fsevent'

data/Guardfile

@@ -0,0 +1,12 @@
+# Guardfile for JRuby-Lint
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb})
+  watch(%r{^lib/(.+)\.rb})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb') { "spec" }
+end
+
+# Local Variables:
+# mode: ruby
+# End:

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.1 / 2011-05-18
+
+* Birthday!
+

data/README.md

@@ -0,0 +1,62 @@
+# JRuby-Lint
+
+See how ready your Ruby code is to run on JRuby.
+
+JRuby-Lint is a simple tool that allows you to check your project code
+and configuration for common gotchas and issues that might make it
+difficult to run your code on JRuby.
+
+## Usage
+
+JRuby-Lint requires JRuby to run. So, [install JRuby first][install]
+if you already haven't, then `gem install jruby-lint`.
+
+Then simply run `jrlint` in your project to receive a report of
+places in your project where you should investigate further.
+
+## Checks
+
+Here is a list of the current checks implemented:
+
+- Report usage of ObjectSpace.each_object and ObjectSpace._id2ref
+  which are expensive and disabled by default
+- 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).
+
+## TODO
+
+Here is a list of checks and options we'd like to implement:
+
+- Timeout.timeout
+- Options to save report off to a file.
+  - Text, HTML formats
+- Report on more threading and concurrency issues/antipatterns
+  - arr.each {|x| arr.delete(x) }
+- Warn about `system("ruby ...")` etc. how they are run in-process by default
+- Try to detect IO/File resource usage without blocks
+- Check .gemspec files for extensions and extconf.rb for
+  #create_makefile and warn about compiliing C extensions
+- Check whether Rails production.rb contains `config.threadsafe!`
+- Detect ERB files and skip them, or...
+- Detect ERB files and pre-process them to Ruby source with Erubis
+- 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
+
+- Arbitrary method/AST search functionality 
+- Code rewriter: option to change code automatically where it's
+  feasible
+- Revive or build an isit.jruby.org site for tracking
+- Make JRuby-Lint submit results to tracking site based on lint passes
+  and/or test suite runs
+
+[install]: http://jruby.org/getting-started

data/Rakefile

@@ -0,0 +1,24 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'bundler/setup'
+require 'rspec/core/rake_task'
+ENV['RUN_ALL_SPECS'] = 'true'   # Always run all specs from Rake
+RSpec::Core::RakeTask.new
+
+task :default => [:update_fixtures, :spec]
+
+require 'rake/clean'
+require 'open-uri'
+require 'net/https'
+
+file "spec/fixtures/C-Extension-Alternatives.html" do |t|
+  require 'jruby/lint/gems'
+  cache = JRuby::Lint::Gems::Cache.new('spec/fixtures')
+  cache.fetch("C-Extension-Alternatives")
+end
+
+fixtures = ["spec/fixtures/C-Extension-Alternatives.html"]
+task :update_fixtures => fixtures
+
+CLOBBER.push *fixtures

data/bin/jrlint

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'jruby/lint/cli'
+
+JRuby::Lint::CLI.new(ARGV).run

data/jruby-lint.gemspec

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "jruby/lint/version"
+
+Gem::Specification.new do |s|
+  s.name        = "jruby-lint"
+  s.version     = JRuby::Lint::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Nick Sieger"]
+  s.email       = ["nick@nicksieger.com"]
+  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
+  give you an idea of potentially troublesome spots in your code and
+  dependencies that keep your code from running efficiently on JRuby.
+
+  Most pure Ruby code will run fine, but the two common areas that
+  trip people up are native extensions and threading}
+
+  s.rubyforge_project = "jruby-lint"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  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"
+  s.add_development_dependency "aruba"
+end
+
+# Local Variables:
+# mode: ruby
+# End:

data/lib/jruby/lint.rb

@@ -0,0 +1,19 @@
+begin
+  require 'jruby'
+rescue LoadError
+  raise LoadError, 'JRuby-Lint must be run under JRuby'
+end
+
+module JRuby
+  module Lint
+  end
+end
+
+require 'jruby/lint/ast'
+require 'jruby/lint/project'
+require 'jruby/lint/finding'
+require 'jruby/lint/libraries'
+require 'jruby/lint/collectors'
+require 'jruby/lint/checkers'
+require 'jruby/lint/reporters'
+require 'jruby/lint/version'

data/lib/jruby/lint/ast.rb

@@ -0,0 +1,56 @@
+module JRuby::Lint
+  module AST
+    module MethodCalls
+      def visitCallNode(node)
+        visitMethodCallNode(node)
+      end
+
+      def visitFCallNode(node)
+        visitMethodCallNode(node)
+      end
+
+      def visitVCallNode(node)
+        visitMethodCallNode(node)
+      end
+
+      def visitAttrAssignNode(node)
+        visitMethodCallNode(node)
+      end
+    end
+
+    class Visitor
+      include Enumerable
+      include org.jruby.ast.visitor.NodeVisitor
+      attr_reader :ast
+
+      def initialize(ast)
+        @ast = ast
+      end
+
+      def each(&block)
+        @block = block
+        ast.accept(self)
+      ensure
+        @block = nil
+      end
+
+      alias each_node each
+      alias traverse each
+
+      def visit(method, node)
+        @block.call(node) if @block
+        node.child_nodes.each do |cn|
+          cn.accept(self) rescue nil
+        end
+      end
+
+      def method_missing(name, *args, &block)
+        if name.to_s =~ /^visit/
+          visit(name, *args)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/jruby/lint/checkers.rb

@@ -0,0 +1,24 @@
+# Any class with this module included in it will be loaded as a
+# checker.
+module JRuby::Lint
+  module Checker
+    def self.included(cls)
+      loaded_checkers << cls
+    end
+
+    def self.loaded_checkers
+      @checkers ||= []
+    end
+
+    attr_accessor :collector
+  end
+
+  module Checkers
+  end
+end
+
+require 'jruby/lint/checkers/fork_exec'
+require 'jruby/lint/checkers/gem'
+require 'jruby/lint/checkers/gemspec'
+require 'jruby/lint/checkers/thread_critical'
+require 'jruby/lint/checkers/object_space'

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

@@ -0,0 +1,47 @@
+module JRuby::Lint
+  module Checkers
+    class ForkExec
+      include 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)
+      end
+
+      def visitVCallNode(node)
+        if fork_exec?(node)
+          add_finding(node) unless @call_node
+        end
+      end
+
+      def fork_exec?(node)
+        node.name == "fork" || node.name == "exec"
+      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
+
+        collector.findings << Finding.new(msg, tags, node.position)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+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
+          end
+          @added_wiki_link = true
+        end
+      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
+        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)
+        end
+      end
+    end
+
+    class Gem
+      include Checker
+      include CheckGemNode
+
+      def visitFCallNode(node)
+        check_gem(collector, node) if node.name == "gem"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module JRuby::Lint
+  module Checkers
+    class Gemspec
+      include Checker
+      include CheckGemNode
+
+      def visitCallNode(node)
+        # Gem::Specification.new do |s| =>
+        #
+        #     CallNoArgBlockNode |new|
+        #       Colon2ConstNode |Specification|
+        #       IterNode
+        #         DAsgnNode |s| &0 >0
+        #           NilImplicitNode |nil|
+        #         BlockNode
+        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
+          @gemspec_block_var = node.iter_node.var_node.name
+          return proc { @gemspec_block_var = nil }
+        end
+
+        # s.add_dependency "rdiscount" =>
+        #
+        #     CallOneArgNode |add_dependency|
+        #       DVarNode |s| &0 >0
+        #       ArrayNode
+        #         StrNode =="rdiscount"
+        if @gemspec_block_var &&
+            node.name == "add_dependency" &&
+            node.receiver_node.name == @gemspec_block_var
+          check_gem(collector, node)
+        end
+      rescue
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module JRuby::Lint
+  module Checkers
+    class ObjectSpace
+      include Checker
+      METHODS = %w(each_object _id2ref)
+
+      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)
+            add_finding(collector, node)
+          rescue
+          end
+        end
+      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)
+      end
+    end
+  end
+end