rails_best_practices 0.10.1 → 1.0.0

data/lib/rails_best_practices/prepares/mailer_prepare.rb

@@ -15,17 +15,16 @@ module RailsBestPractices
       end
 
       def initialize
-        @mailers = Core::Mailers.new
+        @mailers = Prepares.mailers
       end
 
       # check class node.
       #
       # if it is a subclass of ActionMailer::Base,
       # then remember its class name.
-      def start_class(class_node)
-        if s(:colon2, s(:const, :ActionMailer), :Base) == class_node.base_class
-          @mailers << class_node.class_name.to_s
-          Prepares.mailers = @mailers
+      def start_class(node)
+        if "ActionMailer::Base" == node.base_class.to_s
+          @mailers << node.class_name.to_s
         end
       end
     end

data/lib/rails_best_practices/prepares/model_prepare.rb

@@ -5,9 +5,10 @@ module RailsBestPractices
   module Prepares
     # Remember the model associations.
     class ModelPrepare < Core::Check
+      ASSOCIATION_METHODS = %w(belongs_to has_one has_many has_and_belongs_to_many)
 
       def interesting_nodes
-        [:class, :call]
+        [:class, :command]
       end
 
       def interesting_files
@@ -15,23 +16,17 @@ module RailsBestPractices
       end
 
       def initialize
-        @models = Core::Models.new
-        @model_associations = Core::ModelAssociations.new
+        @models = Prepares.models
+        @model_associations = Prepares.model_associations
       end
 
       # check class node to remember the last class name.
-      def start_class(class_node)
-        @last_klazz = class_node.class_name.to_s
+      def start_class(node)
+        @last_klazz= node.class_name.to_s
         @models << @last_klazz
       end
 
-      # assign @model_associations to Prepares.model_associations.
-      def end_class(class_node)
-        Prepares.models = @models
-        Prepares.model_associations = @model_associations
-      end
-
-      # check call node to remember all assoications.
+      # check command node to remember all assoications.
       #
       # the remembered association names (@associations) are like
       #     {
@@ -42,26 +37,21 @@ module RailsBestPractices
       #         "milestones => {:has_many" => "Milestone"}
       #       }
       #     }
-      def start_call(node)
-        remember_association(node) if association_methods.include? node.message
+      def start_command(node)
+        remember_association(node) if ASSOCIATION_METHODS.include? node.message.to_s
       end
 
       # remember associations, with class to association names.
-      def remember_association(association_node)
-        association_meta = association_node.message
-        association_name = association_node.arguments[1].to_s
-        arguments_node = association_node.arguments[2]
-        if arguments_node && :hash == arguments_node.node_type
-          index = arguments_node.index(s(:lit, :class_name))
-          association_class = arguments_node[index + 1].to_s if index
+      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(@last_klazz, association_name, association_meta, association_class)
       end
-
-      # default rails association methods.
-      def association_methods
-        [:belongs_to, :has_one, :has_many, :has_and_belongs_to_many]
-      end
     end
   end
 end

data/lib/rails_best_practices/prepares/schema_prepare.rb

@@ -6,10 +6,10 @@ module RailsBestPractices
     # Remember the model attributes.
     class SchemaPrepare < Core::Check
       # all attribute types
-      ATTRIBUTE_TYPES = [:integer, :float, :boolean, :string, :text, :date, :time, :datetime, :binary]
+      ATTRIBUTE_TYPES = %w(integer float boolean string text date time datetime binary)
 
       def interesting_nodes
-        [:call]
+        [:command, :command_call]
       end
 
       def interesting_files
@@ -17,26 +17,20 @@ module RailsBestPractices
       end
 
       def initialize
-        @model_attributes = Core::ModelAttributes.new
+        @model_attributes = Prepares.model_attributes
       end
 
-      # check call node to remember the model attributes.
-      def start_call(call_node)
-        case call_node.message
-        when :create_table
-          @last_klazz = call_node.arguments[1].to_s.classify
-        when *ATTRIBUTE_TYPES
-          attribute_name = call_node.arguments[1].to_s
-          @model_attributes.add_attribute(@last_klazz, attribute_name, call_node.message)
-        else
-          # nothing to do
+      def start_command(node)
+        if "create_table" == node.message.to_s
+          @last_klazz = node.arguments.all[0].to_s.classify
         end
       end
 
-      # assign @model_attributes to Prepares.model_attributes.
-      def end_call(call_node)
-        if :create_table == call_node.message
-          Prepares.model_attributes = @model_attributes
+      # check command_call node to remember the model attributes.
+      def start_command_call(node)
+        if ATTRIBUTE_TYPES.include? node.message.to_s
+          attribute_name = node.arguments.all[0].to_s
+          @model_attributes.add_attribute(@last_klazz, attribute_name, node.message.to_s)
         end
       end
     end

data/lib/rails_best_practices/reviews/add_model_virtual_attribute_review.rb

@@ -13,15 +13,7 @@ module RailsBestPractices
     #   check method define nodes in all controller files,
     #   if there are more than one [] method calls with the same subject and arguments,
     #   but assigned to one model's different attribute.
-    #   and after these method calls, there is a save method call for that model, like
-    #
-    #       def create
-    #         @user = User.new(params[:user])
-    #         @user.first_name = params[:full_name].split(' ', 2).first
-    #         @user.last_name = params[:full_name].split(' ', 2).last
-    #         @user.save
-    #       end
-    #
+    #   and after these method calls, there is a save method call for that model,
     #   then the model needs to add a virtual attribute.
     class AddModelVirtualAttributeReview < Review
       def url
@@ -29,7 +21,7 @@ module RailsBestPractices
       end
 
       def interesting_nodes
-        [:defn]
+        [:def]
       end
 
       def interesting_files
@@ -40,89 +32,46 @@ module RailsBestPractices
       #
       # it will check every attribute assignment nodes and call node of message :save or :save!, if
       #
-      # 1. there are more than one arguments who contain call node with messages :[] in attribute assignment nodes, e.g.
-      #     @user.first_name = params[:full_name].split(' ').first
-      #     @user.last_name = params[:full_name].split(' ').last
+      # 1. there are more than one arguments who contain array reference node in the right value of assignment nodes,
       # 2. the messages of attribute assignment nodes housld be different (:first_name= , :last_name=)
       # 3. the argument of call nodes with message :[] should be same (:full_name)
       # 4. there should be a call node with message :save or :save! after attribute assignment nodes
-      #     @user.save
       # 5. and the subject of save or save! call node should be the same with the subject of attribute assignment nodes
       #
       # then the attribute assignment nodes can add model virtual attribute instead.
-      def start_defn(node)
-        @attrasgns = {}
+      def start_def(node)
+        @assignments = {}
         node.recursive_children do |child|
-          case child.node_type
-          when :attrasgn
-            attribute_assignment(child)
+          case child.sexp_type
+          when :assign
+            assign(child)
           when :call
             call_assignment(child)
-          else
           end
         end
       end
 
       private
-        # check an attribute assignment node, if there is a :[] message of call node in the attribute assignment node,
+        # check an attribute assignment node, if there is a array reference node in the right value of assignment node,
         # then remember this attribute assignment.
-        #
-        #     s(:attrasgn, s(:ivar, :@user), :first_name=,
-        #       s(:arglist,
-        #         s(:call,
-        #           s(:call,
-        #             s(:call, s(:call, nil, :params, s(:arglist)), :[], s(:arglist, s(:lit, :full_name))),
-        #             :split,
-        #             s(:arglist, s(:str, " "), s(:lit, 2))
-        #           ),
-        #           :first,
-        #           s(:arglist)
-        #         )
-        #       )
-        #     )
-        #
-        # The remember attribute assignments (@attrasgns) are as follows
-        #
-        #     {
-        #       s(:ivar, :@user) =>
-        #         [{
-        #           :message=>:first_name=,
-        #           :arguments=>s(:call, s(:call, nil, :params, s(:arglist)), :[], s(:arglist, s(:lit, :full_name)))
-        #         }]
-        #     }
-        def attribute_assignment(node)
-          subject = node.subject
-          arguments_node = node.arguments.grep_node(:message => :[])
-          return if subject.nil? or arguments_node.nil?
-          attrasgns(subject) << {:message => node.message, :arguments => arguments_node}
+        def assign(node)
+          left_value = node.left_value
+          right_value = node.right_value
+          return unless :field == left_value.sexp_type && :call == right_value.sexp_type
+          aref_node = right_value.grep_node(:sexp_type => :aref)
+          if aref_node
+            assignments(left_value.subject.to_s) << {:message => left_value.message.to_s, :arguments => aref_node.to_s}
+          end
         end
 
-        # check a call node with message :save or :save!,
+        # check a call node with message "save" or "save!",
         # if there exists an attribute assignment for the subject of this call node,
         # and if the arguments of this attribute assignments has duplicated entries (different message and same arguments),
         # then this node needs to add a virtual attribute.
-        #
-        # e.g. this is @attrasgns
-        #     {
-        #       s(:ivar, :@user)=>
-        #         [{
-        #           :message=>:first_name=,
-        #           :arguments=>s(:call, s(:call, nil, :params, s(:arglist)), :[], s(:arglist, s(:lit, :full_name)))
-        #         }, {
-        #           :message=>:last_name=,
-        #           :arguments=>s(:call, s(:call, nil, :params, s(:arglist)), :[], s(:arglist, s(:lit, :full_name)))
-        #         }]
-        #     }
-        # and this is the call node
-        #     s(:call, s(:ivar, :@user), :save, s(:arglist))
-        #
-        # The message of call node is :save,
-        # and the key of @attrasgns is the same as the subject of call node,
-        # and the value of @aatrasgns has different message and same arguments.
         def call_assignment(node)
-          if [:save, :save!].include? node.message
-            subject = node.subject
-            add_error "add model virtual attribute (for #{subject})" if params_dup?(attrasgns(subject).collect {|h| h[:arguments]})
+          if ["save", "save!"].include? node.message.to_s
+            subject = node.subject.to_s
+            add_error "add model virtual attribute (for #{subject})" if params_dup?(assignments(subject).collect {|h| h[:arguments]})
           end
         end
 
@@ -132,9 +81,9 @@ module RailsBestPractices
           !nodes.dups.empty?
         end
 
-        # get the attrasgns of subject, or empty array.
-        def attrasgns(subject)
-          @attrasgns[subject] ||= []
+        # get the assignments of subject.
+        def assignments(subject)
+          @assignments[subject] ||= []
         end
     end
   end

data/lib/rails_best_practices/reviews/always_add_db_index_review.rb

@@ -10,12 +10,12 @@ module RailsBestPractices
     # Implementation:
     #
     # Review process:
-    #   only check the call nodes and at the end of iter node in db/schema file,
-    #   if the subject of call node is :create_table, then remember the table names
-    #   if the subject of call node is :integer, then remember it as foreign key
-    #   if the sujbect of call node is :string, the name of it is _type suffixed and there is an integer column _id suffixed, then remember it as polymorphic foreign key
-    #   if the subject of call node is :add_index, then remember the index columns
-    #   after all of these, at the end of iter node
+    #   only check the command and command_calls nodes and at the end of program node in db/schema file,
+    #   if the subject of command node is "create_table", then remember the table names
+    #   if the subject of command_call node is "integer" and suffix with id, then remember it as foreign key
+    #   if the sujbect of command_call node is "string", the name of it is _type suffixed and there is an integer column _id suffixed, then remember it as polymorphic foreign key
+    #   if the subject of command node is "add_index", then remember the index columns
+    #   after all of these, at the end of program node
     #
     #       ActiveRecord::Schema.define(:version => 20101201111111) do
     #         ......
@@ -29,7 +29,7 @@ module RailsBestPractices
       end
 
       def interesting_nodes
-        [:call, :iter]
+        [:command, :command_call, :program]
       end
 
       def interesting_files
@@ -43,83 +43,46 @@ module RailsBestPractices
         @table_nodes = {}
       end
 
-      # check call node.
+      # check command_call node.
       #
-      # if the message of call node is :create_table,
-      # then remember the table name (@table_nodes) like
-      #     {
-      #       "comments" =>
-      #         s(:call, nil, :create_table, s(:arglist, s(:str, "comments"), s(:hash, s(:lit, :force), s(:true))))
-      #     }
+      # if the message of command_call node is "create_table", then remember the table name.
+      # if the message of command_call node is "add_index", then remember it as index columns.
+      def start_command_call(node)
+        case node.message.to_s
+        when "integer", "string"
+          remember_foreign_key_columns(node)
+        else
+        end
+      end
+
+      # check command node.
       #
-      # if the message of call node is :integer,
+      # if the message of command node is "integer",
       # then remember it as a foreign key of last create table name.
       #
-      # if the message of call node is :type and the name of argument is _type suffixed,
+      # if the message of command node is "type" and the name of argument is _type suffixed,
       # then remember it with _id suffixed column as polymorphic foreign key.
-      #
-      # the remember foreign keys (@foreign_keys) like
-      #
-      #   {
-      #     "taggings" =>
-      #       ["tag_id", ["taggable_id", "taggable_type"]]
-      #   }
-      #
-      # if the message of call node is :add_index,
-      # then remember it as index columns (@index_columns) like
-      #
-      #   {
-      #     "comments" =>
-      #       ["post_id", "user_id"]
-      #   }
-      def start_call(node)
-        case node.message
-        when :create_table
+      def start_command(node)
+        case node.message.to_s
+        when "create_table"
           remember_table_nodes(node)
-        when :integer, :string
-          remember_foreign_key_columns(node)
-        when :add_index
+        when "add_index"
           remember_index_columns(node)
-        else
         end
       end
 
-      # check at the end of iter node, like
-      #
-      #     s(:iter,
-      #       s(:call,
-      #         s(:colon2, s(:const, :ActiveRecord), :Schema),
-      #         :define,
-      #         s(:arglist, s(:hash, s(:lit, :version), s(:lit, 20100603080629)))
-      #       ),
-      #       nil,
-      #       s(:iter,
-      #         s(:call, nil, :create_table,
-      #           s(:arglist, s(:str, "comments"), s(:hash, s(:lit, :force), s(:true)))
-      #         ),
-      #         s(:lasgn, :t),
-      #         s(:block,
-      #           s(:call, s(:lvar, :t), :string, s(:arglist, s(:str, "content")))
-      #         )
-      #       )
-      #     )
-      #
-      # if the subject of iter node is with subject ActiveRecord::Schema,
-      # it means we have completed the foreign keys and index columns parsing,
-      # then we compare foreign keys and index columns.
+      # check at the end of program node.
       #
+      # compare foreign keys and index columns,
       # if there are any foreign keys not existed in index columns,
       # then we should add db index for that foreign keys.
-      def end_iter(node)
-        first_node = node.subject
-        if :call == first_node.node_type && s(:colon2, s(:const, :ActiveRecord), :Schema) == first_node.subject
-          remove_only_type_foreign_keys
-          @foreign_keys.each do |table, foreign_key|
-            table_node = @table_nodes[table]
-            foreign_key.each do |column|
-              if indexed?(table, column)
-                add_error "always add db index (#{table} => [#{Array(column).join(', ')}])", table_node.file, table_node.line
-              end
+      def end_program(node)
+        remove_only_type_foreign_keys
+        @foreign_keys.each do |table, foreign_key|
+          table_node = @table_nodes[table]
+          foreign_key.each do |column|
+            if indexed?(table, column)
+              add_error "always add db index (#{table} => [#{Array(column).join(', ')}])", table_node.file, table_node.line
             end
           end
         end
@@ -127,62 +90,25 @@ module RailsBestPractices
 
       private
         # remember the node as index columns
-        #
-        #     s(:call, nil, :add_index,
-        #       s(:arglist,
-        #         s(:str, "comments"),
-        #         s(:array, s(:str, "post_id")),
-        #         s(:hash, s(:lit, :name), s(:str, "index_comments_on_post_id"))
-        #       )
-        #     )
-        #
-        # the remember index columns are like
-        #     {
-        #       "comments" =>
-        #         ["post_id", "user_id"]
-        #     }
         def remember_index_columns(node)
-          table_name = node.arguments[1].to_s
-          index_column = eval(node.arguments[2].to_s)
+          table_name = node.arguments.all[0].to_s
+          index_column = node.arguments.all[1].to_object
 
           @index_columns[table_name] ||= []
-          @index_columns[table_name] << (index_column.size == 1 ? index_column[0] : index_column)
+          @index_columns[table_name] << index_column
         end
 
         # remember table nodes
-        #
-        # if the node is
-        #
-        #     s(:call, nil, :create_table,
-        #       s(:arglist, s(:str, "comments"), s(:hash, s(:lit, :force), s(:true))))
-        #
-        # then the table nodes will be
-        #
-        #     {
-        #       "comments" =>
-        #         s(:call, nil, :create_table, s(:arglist, s(:str, "comments"), s(:hash, s(:lit, :force), s(:true))))
-        #     }
         def remember_table_nodes(node)
-          @table_name = node.arguments[1].to_s
+          @table_name = node.arguments.all[0].to_s
           @table_nodes[@table_name] = node
         end
 
 
         # remember foreign key columns
-        #
-        # if the message of node is :integer,
-        # then it is a foreign key, like
-        #
-        #     s(:call, s(:lvar, :t), :integer, s(:arglist, s(:str, "post_id")))
-        #
-        # if the message of node is :string, with _type suffixed and there is a _id suffixed column,
-        # then they are polymorphic foreign key
-        #
-        #     s(:call, s(:lvar, :t), :integer, s(:arglist, s(:str, "taggable_id")))
-        #     s(:call, s(:lvar, :t), :string, s(:arglist, s(:str, "taggable_type")))
         def remember_foreign_key_columns(node)
           table_name = @table_name
-          foreign_key_column = node.arguments[1].to_s
+          foreign_key_column = node.arguments.all[0].to_s
           @foreign_keys[table_name] ||= []
           if foreign_key_column =~ /(.*?)_id$/
             if @foreign_keys[table_name].delete("#{$1}_type")