rails_best_practices 0.5.6 → 0.6.1

data/lib/rails_best_practices/checks/use_scope_access_check.rb

@@ -3,37 +3,92 @@ require 'rails_best_practices/checks/check'
 
 module RailsBestPractices
   module Checks
-    # Check a controller to make sure using scope access
+    # Check a controller to make sure to use scope access instead of manually checking current_user and redirect.
     #
-    # Implementation: simply check if or unless compare with current_user or current_user.id and there is a redirect_to message in if or unless block
+    # See the best practice details here http://rails-bestpractices.com/posts/3-use-scope-access.
+    #
+    # Implementation:
+    #
+    # Prepare process:
+    #   none
+    #
+    # Review process:
+    #   check all if nodes to see
+    #
+    #   if they are compared with current_user or current_user.id,
+    #   and there is redirect_to method call in if block body,
+    #   then it should be replaced by using scope access.
     class UseScopeAccessCheck < Check
-      
-      def interesting_nodes
-        [:if, :unless]
+
+      def interesting_review_nodes
+        [:if]
       end
-      
-      def interesting_files
+
+      def interesting_review_files
         CONTROLLER_FILES
       end
-      
-      def evaluate_start(node)
+
+      # check if node in review process.
+      #
+      # if it is a method call compared with current_user or current_user.id,
+      # and there is a redirect_to method call in the block body, like
+      #
+      #     unless @post.user == current_user
+      #       falsh[:error] = "Access Denied"
+      #       redirect_to posts_url
+      #     end
+      #
+      # then it should be replaced by using scope access.
+      def review_start_if(node)
         add_error "use scope access" if current_user_redirect?(node)
       end
-      
+
       private
-      
-      def current_user_redirect?(node)
-        condition_node = node.call
-        
-        condition_node.message == :== and 
-        (current_user?(condition_node.arguments.call) or current_user?(condition_node.subject)) and 
-        (node.false_node.body.any? {|n| n.message == :redirect_to} or node.true_node.method_body.any? {|n| n.message == :redirect_to})
-      end
-      
-      def current_user?(call_node)
-        call_node.node_type == :call and (call_node.message == :current_user or (call_node.subject.message == :current_user and call_node.message == :id))
-      end
-      
+        # check a if node to see
+        #
+        # if the conditional statement is compared with current_user or current_user.id,
+        # and there is a redirect_to method call in the block body, like
+        #
+        #     s(:if,
+        #       s(:call,
+        #         s(:call, s(:ivar, :@post), :user, s(:arglist)),
+        #         :==,
+        #         s(:arglist, s(:call, nil, :current_user, s(:arglist)))
+        #       ),
+        #       nil,
+        #       s(:block,
+        #         s(:attrasgn,
+        #           s(:call, nil, :flash, s(:arglist)),
+        #           :[]=,
+        #           s(:arglist, s(:lit, :warning), s(:str, "Access Denied"))
+        #         ),
+        #         s(:call, nil, :redirect_to,
+        #           s(:arglist, s(:call, nil, :posts_url, s(:arglist)))
+        #         )
+        #       )
+        #     )
+        #
+        # then it should be replaced by using scope access.
+        def current_user_redirect?(node)
+          condition_node = node.conditional_statement
+
+          condition_node.message == :== &&
+          (current_user?(condition_node.arguments[1]) || current_user?(condition_node.subject)) &&
+          (node.false_node.grep_node(:message => :redirect_to) || node.true_node.grep_node(:message => :redirect_to))
+        end
+
+        # check a call node to see if it uses current_user, or current_user.id.
+        #
+        # the expected call node may be
+        #
+        #     s(:call, nil, :current_user, s(:arglist))
+        #
+        # or
+        #
+        #     s(:call, s(:call, nil, :current_user, s(:arglist)), :id, s(:arglist))
+        def current_user?(call_node)
+          call_node.message == :current_user || (call_node.subject.message == :current_user && call_node.message == :id)
+        end
     end
   end
 end

data/lib/rails_best_practices/command.rb

@@ -1,11 +1,20 @@
 # encoding: utf-8
 require 'optparse'
-require 'progressbar'
-require 'colored'
 
+# Usage: rails_best_practices [options] path
+#     -d, --debug                      Debug mode
+#         --vendor                     include vendor files
+#         --spec                       include spec files
+#         --test                       include test files
+#         --features                   include features files
+#     -x, --exclude PATTERNS           Don't analyze files matching a pattern
+#                                      (comma-separated regexp list)
+#     -g, --generate                   Generate configuration yaml
+#     -v, --version                    Show this version
+#     -h, --help                       Show this message
 options = {}
 OptionParser.new do |opts|
-  opts.banner = "Usage: rails_best_practices [options]"
+  opts.banner = "Usage: rails_best_practices [options] path"
 
   opts.on("-d", "--debug", "Debug mode") do
     options['debug'] = true
@@ -36,39 +45,15 @@ OptionParser.new do |opts|
     end
   end
 
-  opts.parse!
-end
-
-runner = RailsBestPractices::Core::Runner.new
-runner.set_debug if options['debug']
-
-prepare_files = RailsBestPractices::prepare_files(ARGV)
-files = RailsBestPractices::analyze_files(ARGV, options)
-
-if runner.checks.find { |check| check.is_a? RailsBestPractices::Checks::AlwaysAddDbIndexCheck } &&
-   !files.find { |file| file.index "db\/schema.rb" }
-  puts "AlwaysAddDbIndexCheck is disabled as there is no db/schema.rb file in your rails project.".blue
-end
-
-bar = ProgressBar.new('Analyzing', prepare_files.size + files.size)
-
-prepare_files.each do |file|
-  runner.prepare_file(file)
-  bar.inc unless options['debug']
-end
+  opts.on("-g", "--generate", "Generate configuration yaml") do
+    options[:generate] = true
+  end
 
-files.each do |file|
-  runner.check_file(file)
-  bar.inc unless options['debug']
+  opts.parse!
 end
-bar.finish
 
-runner.errors.each { |error| puts error.to_s.red }
-puts "\nPlease go to http://rails-bestpractices.com to see more useful Rails Best Practices.".green
-if runner.errors.empty?
-  puts "\nNo error found. Cool!".green
+if options[:generate]
+  RailsBestPractices.generate(ARGV.first)
 else
-  puts "\nFound #{runner.errors.size} errors.".red
+  RailsBestPractices.start(ARGV.first, options)
 end
-
-exit runner.errors.size

data/lib/rails_best_practices/core.rb

@@ -1,6 +1,8 @@
 # encoding: utf-8
-require 'rails_best_practices/core/core_ext'
 require 'rails_best_practices/core/runner'
 require 'rails_best_practices/core/checking_visitor'
 require 'rails_best_practices/core/error'
-require 'rails_best_practices/core/visitable_sexp'
+require 'rails_best_practices/core/visitable_sexp'
+
+require 'rails_best_practices/core_ext/enumerable'
+require 'rails_best_practices/core_ext/nil_class'

data/lib/rails_best_practices/core/checking_visitor.rb

@@ -1,32 +1,62 @@
 # encoding: utf-8
 module RailsBestPractices
   module Core
+    # CheckingVisitor is a visitor class.
+    #
+    # it remembers all the checks for prepare and review processes according to interesting_prepare_nodes and interesting_review_nodes,
+    # then recursively iterate all sexp nodes,
+    #
+    # for prepare process
+    # if the node_type and the node filename match the interesting_prepare_nodes and interesting_prepare_files,
+    # then run the prepare for that node.
+    #
+    # for review process
+    # if the node_type and the node filename match the interesting_review_nodes and interesting_review_files,
+    # then run the reivew for that node.
     class CheckingVisitor
+      # remember all the checks for prepare and review processes according to interesting_prepare_nodes and interesting_review_nodes,
       def initialize(checks)
-        @checks ||= {}
-        checks.each do |check|
-          nodes = check.interesting_nodes
-          nodes.each do |node|
-            @checks[node] ||= []
-            @checks[node] << check
-            @checks[node].uniq!
+        [:prepare, :review].each do |process|
+          instance_variable_set("@#{process}_checks", {})                  # @review_checks = {}
+          checks.each do |check|                                           # checks.each do |check|
+            check.send("interesting_#{process}_nodes").each do |node|      # check.interesting_review_nodes.each do |node|
+              instance_variable_get("@#{process}_checks")[node] ||= []     #   @review_checks[node] ||= []
+              instance_variable_get("@#{process}_checks")[node] << check   #   @review_checks[node] << check
+              instance_variable_get("@#{process}_checks")[node].uniq!      #   @review_checks[node].uniq!
+            end                                                            # end
           end
         end
       end
 
-      def prepare(node)
-        checks = @checks[node.node_type]
-        checks.each {|check| check.prepare_node_start(node) if node.file =~ check.interesting_prepare_files} unless checks.nil?
-        node.visitable_children.each {|sexp| sexp.prepare(self)}
-        checks.each {|check| check.prepare_node_end(node) if node.file =~ check.interesting_prepare_files} unless checks.nil?
+      # for prepare process
+      # if the node_type and the node filename match the interesting_prepare_nodes and interesting_prepare_files,
+      # then run the prepare for that node.
+      #
+      # for review process
+      # if the node_type and the node filename match the interesting_review_nodes and interesting_review_files,
+      # then run the reivew for that node.
+      [:prepare, :review].each do |process|
+        class_eval <<-EOS
+          def #{process}(node)                                         # def review(node)
+            checks = @#{process}_checks[node.node_type]                #   checks = @review_checks[node.node_type]
+            if checks                                                  #   if checks
+              checks.each { |check|                                    #     checks.each { |check|
+                if node.file =~ check.interesting_#{process}_files     #      if node.file =~ check.interesting_review_files
+                  check.#{process}_node_start(node)                    #         check.review_node_start(node)
+                end                                                    #       end
+              }                                                        #     }
+            end                                                        #   end
+            node.children.each {|sexp| sexp.#{process}(self)}          #   node.children.each {|sexp| sexp.review(self)}
+            if checks                                                  #   if checks
+              checks.each { |check|                                    #     checks.each { |check|
+                if node.file =~ check.interesting_#{process}_files     #       if node.file =~ check.interesting_review_files
+                  check.#{process}_node_end(node)                      #         check.review_node_end(node)
+                end                                                    #       end
+              }                                                        #     }
+            end                                                        #   end
+          end                                                          # end
+        EOS
       end
-
-    	def visit(node)
-        checks = @checks[node.node_type]
-        checks.each {|check| check.evaluate_node_start(node) if node.file =~ check.interesting_files} unless checks.nil?
-    		node.visitable_children.each {|sexp| sexp.accept(self)}
-        checks.each {|check| check.evaluate_node_end(node) if node.file =~ check.interesting_files} unless checks.nil?
-    	end
     end
   end
 end

data/lib/rails_best_practices/core/error.rb

@@ -1,15 +1,18 @@
 # encoding: utf-8
 module RailsBestPractices
   module Core
+    # Error is the violation to rails best practice.
+    #
+    # it indicates the filenname, line number and error message for the violation.
     class Error
       attr_reader :filename, :line_number, :message
-      
+
       def initialize(filename, line_number, message)
         @filename = filename
         @line_number = line_number
         @message = message
       end
-      
+
       def to_s
         "#{@filename}:#{@line_number} - #{@message}"
       end

data/lib/rails_best_practices/core/runner.rb

@@ -7,45 +7,62 @@ require 'active_support/inflector'
 
 module RailsBestPractices
   module Core
+    # Runner is the main class, it can check source code of a filename with all checks (according to the configuration).
+    #
+    # the check process is partitioned into two parts,
+    #
+    # 1. prepare process, it will do some preparations for further checking, such as remember the model associations.
+    # 2. review process, it does real check, if the source code violates some best practices, the violations will be notified.
     class Runner
       attr_reader :checks
+      attr_accessor :debug
 
-      DEFAULT_CONFIG = File.join(File.dirname(__FILE__), "..", "..", "..", "rails_best_practices.yml")
-      CUSTOM_CONFIG = File.join('config', 'rails_best_practices.yml')
+      # set the base path.
+      #
+      # @param [String] path the base path
+      def self.base_path=(path)
+        @base_path = path
+      end
+
+      # get the base path, by default, the base path is current path.
+      #
+      # @return [String] the base path
+      def self.base_path
+        @base_path || "."
+      end
 
       def initialize(*checks)
-        @config = File.exists?(CUSTOM_CONFIG) ? CUSTOM_CONFIG : DEFAULT_CONFIG
+        custom_config = File.join(Runner.base_path, 'config/rails_best_practices.yml')
+        @config = File.exists?(custom_config) ? custom_config : RailsBestPractices::DEFAULT_CONFIG
         @checks = checks unless checks.empty?
         @checks ||= load_checks
         @checker ||= CheckingVisitor.new(@checks)
         @debug = false
       end
 
-      def set_debug
-        @debug = true
-      end
-
-      def check(filename, content)
-        puts filename if @debug
-        content = parse_erb_or_haml(filename, content)
-        node = parse_ruby(filename, content)
-        node.accept(@checker) if node
-      end
-
-      def prepare(filename, content)
-        puts filename if @debug
-        node = parse_ruby(filename, content)
-        node.prepare(@checker) if node
-      end
-
-      def check_file(filename)
-        check(filename, File.read(filename))
-      end
-
-      def prepare_file(filename)
-        prepare(filename, File.read(filename))
+      # prepare and review a file's content with filename.
+      # the file may be a ruby, erb or haml file.
+      #
+      # filename is the filename of the code.
+      # content is the source code.
+      [:prepare, :review].each do |process|
+        class_eval <<-EOS
+          def #{process}(filename, content)                      # def review(filename, content)
+            puts filename if @debug                              #   puts filename if @debug
+            content = parse_erb_or_haml(filename, content)       #   content = parse_erb_or_haml(filename, content)
+            node = parse_ruby(filename, content)                 #   node = parse_ruby(filename, content)
+            node.#{process}(@checker) if node                    #   node.review(@checker) if node
+          end                                                    # end
+                                                                 #
+          def #{process}_file(filename)                          # def review_file(filename)
+            #{process}(filename, File.read(filename))            #   review(filename, File.read(filename))
+          end                                                    # end
+        EOS
       end
 
+      # get all errors from checks.
+      #
+      # @return [Array] all errors from checks
       def errors
         @checks ||= []
         all_errors = @checks.collect {|check| check.errors}
@@ -53,41 +70,48 @@ module RailsBestPractices
       end
 
       private
-
-      def parse_ruby(filename, content)
-        begin
-          RubyParser.new.parse(content, filename)
-        rescue Exception => e
-          puts "#{filename} looks like it's not a valid Ruby file.  Skipping..." if @debug
-          nil
+        # parse ruby code.
+        #
+        # filename is the filename of the ruby code.
+        # content is the source code of ruby file.
+        def parse_ruby(filename, content)
+          begin
+            RubyParser.new.parse(content, filename)
+          rescue Exception => e
+            puts "#{filename} looks like it's not a valid Ruby file.  Skipping...".red if @debug
+            nil
+          end
         end
-      end
 
-      def parse_erb_or_haml(filename, content)
-        if filename =~ /.*\.erb$/
-          content = Erubis::Eruby.new(content).src
-        end
-        if filename =~ /.*\.haml$/
-          begin
-            require 'haml'
-            content = Haml::Engine.new(content).precompiled
-            # remove \xxx characters
-            content.gsub!(/\\\d{3}/, '')
-          rescue Haml::SyntaxError
+        # parse erb or html code.
+        #
+        # filename is the filename of the erb or haml code.
+        # content is the source code of erb or haml file.
+        def parse_erb_or_haml(filename, content)
+          if filename =~ /.*\.erb$/
+            content = Erubis::Eruby.new(content).src
+          elsif filename =~ /.*\.haml$/
+            begin
+              require 'haml'
+              content = Haml::Engine.new(content).precompiled
+              # remove \xxx characters
+              content.gsub!(/\\\d{3}/, '')
+            rescue Haml::SyntaxError
+            end
           end
+          content
         end
-        content
-      end
 
-      def load_checks
-        check_objects = []
-        checks = YAML.load_file @config
-        checks.each do |check|
-          klass = eval("RailsBestPractices::Checks::#{check[0]}")
-          check_objects << (check[1].empty? ? klass.new : klass.new(check[1]))
+        # load all checks according to configuration.
+        def load_checks
+          check_objects = []
+          checks = YAML.load_file @config
+          checks.each do |check|
+            klass = RailsBestPractices::Checks.const_get(check[0])
+            check_objects << (check[1].empty? ? klass.new : klass.new(check[1]))
+          end
+          check_objects
         end
-        check_objects
-      end
     end
   end
 end