rails_best_practices 1.1.0 → 1.2.0

data/lib/rails_best_practices/core/model_associations.rb

@@ -1,21 +1,38 @@
 # encoding: utf-8
 module RailsBestPractices
   module Core
+    # Model associations container.
     class ModelAssociations
       def initialize
         @associations = {}
       end
 
+      # Add a model association.
+      #
+      # @param [String] model name
+      # @param [String] association name
+      # @param [String] association meta, has_many, has_one, belongs_to and has_and_belongs_to_many
+      # @param [String] association class name
       def add_association(model_name, association_name, association_meta, association_class=nil)
         @associations[model_name] ||= {}
         @associations[model_name][association_name] = {"meta" => association_meta, "class_name" => association_class || association_name.classify}
       end
 
+      # Get a model association.
+      #
+      # @param [String] model name
+      # @param [String] association name
+      # @return [Hash] {"meta" => association_meta, "class_name" => association_class}
       def get_association(model_name, association_name)
         associations = @associations[model_name]
         associations and associations[association_name]
       end
 
+      # If it is a model's association.
+      #
+      # @param [String] model name
+      # @param [String] association name
+      # @return [Boolean] true if it is the model's association
       def is_association?(model_name, association_name)
         associations = @associations[model_name]
         associations && associations[association_name]

data/lib/rails_best_practices/core/model_attributes.rb

@@ -1,21 +1,37 @@
 # encoding: utf-8
 module RailsBestPractices
   module Core
+    # Model attributes container.
     class ModelAttributes
       def initialize
         @attributes = {}
       end
 
+      # Add a model attribute.
+      #
+      # @param [String] model name
+      # @param [String] attribute name
+      # @param [String] attribute type
       def add_attribute(model_name, attribute_name, attribute_type)
         @attributes[model_name] ||= {}
         @attributes[model_name][attribute_name] = attribute_type
       end
 
+      # Get attribute type.
+      #
+      # @param [String] model name
+      # @param [String] attribute name
+      # @return [String] attribute type
       def get_attribute_type(model_name, attribute_name)
         @attributes[model_name] ||= {}
         @attributes[model_name][attribute_name]
       end
 
+      # If it is a model's attribute.
+      #
+      # @param [String] model name
+      # @param [String] attribute name
+      # @return [Boolean] true if it is the model's attribute
       def is_attribute?(model_name, attribute_name)
         @attributes[model_name] ||= {}
         !!@attributes[model_name][attribute_name]

data/lib/rails_best_practices/core/models.rb

@@ -1,7 +1,8 @@
 # encoding: utf-8
 module RailsBestPractices
   module Core
-    class Models < Array
+    # Model classes.
+    class Models < Klasses
     end
   end
-end
+end

data/lib/rails_best_practices/core/nil.rb

@@ -1,16 +1,24 @@
 # encoding: utf-8
 module RailsBestPractices
   module Core
+    # Fake nil.
     class Nil
+      # hash_size is 0.
       def hash_size
         0
       end
 
+      # array_size is 0.
+      def array_size
+        0
+      end
+
+      # return self for to_s.
       def to_s
         self
       end
 
-      # return self
+      # return self.
       def method_missing(method_sym, *arguments, &block)
         self
       end

data/lib/rails_best_practices/core/runner.rb

@@ -38,9 +38,10 @@ module RailsBestPractices
         custom_config = File.join(Runner.base_path, 'config/rails_best_practices.yml')
         @config = File.exists?(custom_config) ? custom_config : RailsBestPractices::DEFAULT_CONFIG
 
+        lexicals = Array(options[:lexicals])
         prepares = Array(options[:prepares])
         reviews = Array(options[:reviews])
-        @lexicals = load_lexicals
+        @lexicals = lexicals.empty? ? load_lexicals : lexicals
         @prepares = prepares.empty? ? load_prepares : prepares
         @reviews = reviews.empty? ? load_reviews : reviews
 
@@ -64,28 +65,48 @@ module RailsBestPractices
       #
       # @param [String] filename
       def lexical_file(filename)
-        lexical(filename, File.open(filename, "r:UTF-8") { |f| f.read })
+        lexical(filename, read_file(filename))
       end
 
-      # prepare and review a file's content with filename.
-      # the file may be a ruby, erb or haml file.
+      # parepare a file's content with filename.
       #
-      # 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(content)                                             #   node = parse_ruby(content)
-            node.file = filename                                                   #   node.file = filename
-            node.#{process}(@checker) if node                                      #   node.review(@checker) if node
-          end                                                                      # end
-                                                                                   #
-          def #{process}_file(filename)                                            # def review_file(filename)
-            #{process}(filename, File.open(filename, "r:UTF-8") { |f| f.read })    #   review(filename, File.open(filename, "r:UTF-8") { |f| f.read })
-          end                                                                      # end
-        EOS
+      # @param [String] filename name of the file
+      # @param [String] content content of the file
+      def prepare(filename, content)
+        puts filename if @debug
+        node = parse_ruby(filename, content)
+        if node
+          node.file = filename
+          node.prepare(@checker)
+        end
+      end
+
+      # parapare the file.
+      #
+      # @param [String] filename
+      def prepare_file(filename)
+        prepare(filename, read_file(filename))
+      end
+
+      # review a file's content with filename.
+      #
+      # @param [String] filename name of the file
+      # @param [String] content content of the file
+      def review(filename, content)
+        puts filename if @debug
+        content = parse_erb_or_haml(filename, content)
+        node = parse_ruby(filename, content)
+        if node
+          node.file = filename
+          node.review(@checker)
+        end
+      end
+
+      # review the file.
+      #
+      # @param [String] filename
+      def review_file(filename)
+        review(filename, read_file(filename))
       end
 
       # get all errors from lexicals and reviews.
@@ -95,11 +116,21 @@ module RailsBestPractices
         (@reviews + @lexicals).collect {|check| check.errors}.flatten
       end
 
+      # provide a handler after all files reviewed.
+      def on_complete
+        filename = "rails_best_practices.complete"
+        content = "class RailsBestPractices::Complete; end"
+        node = parse_ruby(filename, content)
+        node.file = filename
+        node.review(@checker)
+      end
+
       private
         # parse ruby code.
         #
-        # content is the source code of ruby file.
-        def parse_ruby(content)
+        # @param [String] filename is the filename of ruby file.
+        # @param [String] content is the source code of ruby file.
+        def parse_ruby(filename, content)
           begin
             Sexp.from_array(Ripper::SexpBuilder.new(content).parse)
           rescue Exception => e
@@ -115,8 +146,8 @@ module RailsBestPractices
 
         # 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.
+        # @param [String] filename is the filename of the erb or haml code.
+        # @param [String] content is the source code of erb or haml file.
         def parse_erb_or_haml(filename, content)
           if filename =~ /.*\.erb|.*\.rhtml$/
             content = Erubis::Eruby.new(content).src
@@ -171,12 +202,12 @@ module RailsBestPractices
         # load all plugin reviews.
         def load_plugin_reviews
           begin
-            plugins = "lib/rails_best_practices/plugins/reviews"
+            plugins = "#{Runner.base_path}lib/rails_best_practices/plugins/reviews"
             if File.directory?(plugins)
               Dir[File.expand_path(File.join(plugins, "*.rb"))].each do |review|
                 require review
               end
-              if RailsBestPractices.constants.include? :Plugins
+              if RailsBestPractices.constants.map(&:to_sym).include? :Plugins
                 RailsBestPractices::Plugins::Reviews.constants.each do |review|
                   @reviews << RailsBestPractices::Plugins::Reviews.const_get(review).new
                 end
@@ -189,6 +220,14 @@ module RailsBestPractices
         def checks_from_config
           @checks ||= YAML.load_file @config
         end
+
+        # read the file content.
+        #
+        # @param [String] filename
+        # @return [String] file conent
+        def read_file(filename)
+          File.open(filename, "r:UTF-8") { |f| f.read }
+        end
     end
   end
 end

data/lib/rails_best_practices/core_ext/sexp.rb

@@ -593,6 +593,39 @@ class Sexp
     end
   end
 
+  # Get the hash values.
+  #
+  #     s(:hash,
+  #       s(:assoclist_from_args,
+  #         s(
+  #           s(:assoc_new, s(:@label, "first_name:", s(1, 1)), s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "Richard", s(1, 14))))),
+  #           s(:assoc_new, s(:@label, "last_name:", s(1, 24)), s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "Huang", s(1, 36)))))
+  #         )
+  #       )
+  #     )
+  #         => [
+  #              s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "Richard", s(1, 14)))),
+  #              s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "Huang", s(1, 36))))
+  #            ]
+  #
+  # @return [Array] hash values
+  def hash_values
+    pair_nodes = case sexp_type
+                 when :bare_assoc_hash
+                   self[1]
+                 when :hash
+                   self[1][1]
+                 else
+                 end
+    if pair_nodes
+      values = []
+      pair_nodes.size.times do |i|
+        values << pair_nodes[i][2]
+      end
+      values
+    end
+  end
+
   # Get the array size.
   #
   #     s(:array,
@@ -624,6 +657,30 @@ class Sexp
     end
   end
 
+  # Get the array values.
+  #
+  #     s(:array,
+  #       s(:args_add,
+  #         s(:args_add, s(:args_new), s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "first_name", s(1, 2))))),
+  #         s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "last_name", s(1, 16))))
+  #       )
+  #     )
+  #         => [
+  #              s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "first_name", s(1, 2)))),
+  #              s(:string_literal, s(:string_add, s(:string_content), s(:@tstring_content, "last_name", s(1, 16))))
+  #            ]
+  #
+  # @return [Array] array values
+  def array_values
+    if :array == sexp_type
+      if nil == self[1]
+        []
+      else
+        arguments.all
+      end
+    end
+  end
+
   # To object.
   #
   #     s(:array,

data/lib/rails_best_practices/prepares.rb

@@ -9,6 +9,10 @@ module RailsBestPractices
     class <<self
       attr_writer :models, :model_associations, :model_attributes, :mailers
 
+      def klasses
+        models + mailers + controllers
+      end
+
       def models
         @models ||= Core::Models.new
       end
@@ -21,6 +25,10 @@ module RailsBestPractices
         @model_attributes ||= Core::ModelAttributes.new
       end
 
+      def model_methods
+        @model_methods ||= Core::Methods.new
+      end
+
       def mailers
         @mailers ||= Core::Mailers.new
       end
@@ -33,8 +41,11 @@ module RailsBestPractices
         @controller_methods ||= Core::Methods.new
       end
 
+      # Clear all prepare objects.
       def clear
-        @models = @model_associations = @model_attributes = @mailers = @controllers = @controller_methods = nil
+        instance_variables.each do |instance_variable|
+          instance_variable_set(instance_variable, nil)
+        end
       end
     end
   end

data/lib/rails_best_practices/prepares/controller_prepare.rb

@@ -5,7 +5,8 @@ module RailsBestPractices
   module Prepares
     # Remember controllers and controller methods
     class ControllerPrepare < Core::Check
-      include Core::Check::Classable
+      include Core::Check::Klassable
+      include Core::Check::Accessable
 
       DEFAULT_ACTIONS = %w(index show new create edit update destroy)
 
@@ -26,9 +27,8 @@ module RailsBestPractices
       # check class node to remember the class name.
       # also check if the controller is inherit from InheritedResources::Base.
       def start_class(node)
-        @class_name = class_name(node)
-        @controllers << @class_name
-        if "InheritedResources::Base" == node.base_class.to_s
+        @controllers << @klass
+        if "InheritedResources::Base" == current_extend_class_name
           @inherited_resources = true
           @actions = DEFAULT_ACTIONS
         end
@@ -38,7 +38,7 @@ module RailsBestPractices
       def end_class(node)
         if @inherited_resources
           @actions.each do |action|
-            @methods.add_method(@class_name, action)
+            @methods.add_method(current_class_name, action)
           end
         end
       end
@@ -62,12 +62,17 @@ module RailsBestPractices
       #
       # the remembered methods (@methods) are like
       #     {
-      #       "Post" => ["create", "destroy"],
-      #       "Comment" => ["create"]
+      #       "PostsController" => {
+      #         "save" => {"file" => "app/controllers/posts_controller.rb", "line" => 10, "unused" => false},
+      #         "find" => {"file" => "app/controllers/posts_controller.rb", "line" => 10, "unused" => false}
+      #       },
+      #       "CommentsController" => {
+      #         "create" => {"file" => "app/controllers/comments_controller.rb", "line" => 10, "unused" => false},
+      #       }
       #     }
       def start_def(node)
         method_name = node.method_name.to_s
-        @methods.add_method(@class_name, method_name)
+        @methods.add_method(current_class_name, method_name, {"file" => node.file, "line" => node.line}, current_access_control)
       end
     end
   end

data/lib/rails_best_practices/prepares/mailer_prepare.rb

@@ -5,7 +5,7 @@ module RailsBestPractices
   module Prepares
     # Remember the mailer names.
     class MailerPrepare < Core::Check
-      include Core::Check::Classable
+      include Core::Check::Klassable
 
       def interesting_nodes
         [:class, :module]
@@ -24,8 +24,8 @@ module RailsBestPractices
       # if it is a subclass of ActionMailer::Base,
       # then remember its class name.
       def start_class(node)
-        if "ActionMailer::Base" == node.base_class.to_s
-          @mailers << class_name(node)
+        if "ActionMailer::Base" == current_extend_class_name
+          @mailers << @klass
         end
       end
     end

data/lib/rails_best_practices/prepares/model_prepare.rb

@@ -5,12 +5,13 @@ module RailsBestPractices
   module Prepares
     # Remember models and model associations.
     class ModelPrepare < Core::Check
-      include Core::Check::Classable
+      include Core::Check::Klassable
+      include Core::Check::Accessable
 
       ASSOCIATION_METHODS = %w(belongs_to has_one has_many has_and_belongs_to_many)
 
       def interesting_nodes
-        [:class, :command, :module]
+        [:module, :class, :def, :command, :var_ref]
       end
 
       def interesting_files
@@ -20,15 +21,36 @@ module RailsBestPractices
       def initialize
         @models = Prepares.models
         @model_associations = Prepares.model_associations
+        @methods = Prepares.model_methods
       end
 
       # check class node to remember the last class name.
       def start_class(node)
-        @class_name= class_name(node)
-        @models << @class_name
+        if "ActionMailer::Base" != current_extend_class_name
+          @models << @klass
+        end
+      end
+
+      # check ref node to remember all methods.
+      #
+      # the remembered methods (@methods) are like
+      #     {
+      #       "Post" => {
+      #         "save" => {"file" => "app/models/post.rb", "line" => 10, "unused" => false, "unused" => false},
+      #         "find" => {"file" => "app/models/post.rb", "line" => 10, "unused" => false, "unused" => false}
+      #       },
+      #       "Comment" => {
+      #         "create" => {"file" => "app/models/comment.rb", "line" => 10, "unused" => false, "unused" => false},
+      #       }
+      #     }
+      def start_def(node)
+        if @klass && "ActionMailer::Base" != current_extend_class_name
+          method_name = node.method_name.to_s
+          @methods.add_method(current_class_name, method_name, {"file" => node.file, "line" => node.line}, current_access_control)
+        end
       end
 
-      # check command node to remember all assoications.
+      # check command node to remember all assoications or named_scope/scope methods.
       #
       # the remembered association names (@associations) are like
       #     {
@@ -40,20 +62,26 @@ module RailsBestPractices
       #       }
       #     }
       def start_command(node)
-        remember_association(node) if ASSOCIATION_METHODS.include? node.message.to_s
+        if %w(named_scope scope).include? node.message.to_s
+          method_name = node.arguments.all[0].to_s
+          @methods.add_method(current_class_name, method_name, {"file" => node.file, "line" => node.line}, current_access_control)
+        elsif ASSOCIATION_METHODS.include? node.message.to_s
+          remember_association(node)
+        end
       end
 
-      # remember associations, with class to association names.
-      def remember_association(node)
-        association_meta = node.message.to_s
-        association_name = node.arguments.all[0].to_s
-        arguments_node = node.arguments.all[1]
-        if arguments_node && :bare_assoc_hash == arguments_node.sexp_type
-          association_class = arguments_node.hash_value("class_name").to_s
+      private
+        # remember associations, with class to association names.
+        def remember_association(node)
+          association_meta = node.message.to_s
+          association_name = node.arguments.all[0].to_s
+          arguments_node = node.arguments.all[1]
+          if arguments_node && :bare_assoc_hash == arguments_node.sexp_type
+            association_class = arguments_node.hash_value("class_name").to_s
+          end
+          association_class ||= association_name.classify
+          @model_associations.add_association(current_class_name, association_name, association_meta, association_class)
         end
-        association_class ||= association_name.classify
-        @model_associations.add_association(@class_name, association_name, association_meta, association_class)
-      end
     end
   end
 end