rails_best_practices 0.6.1 → 0.6.5

data/spec/rails_best_practices/checks/use_say_with_time_in_migrations_check_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe RailsBestPractices::Checks::UseSayWithTimeInMigrationsCheck do
+  before :each do
+    @runner = RailsBestPractices::Core::Runner.new(RailsBestPractices::Checks::UseSayWithTimeInMigrationsCheck.new)
+  end
+
+  it "should use say with time in migrations" do
+    content =<<-EOF
+    def self.up
+      User.find_each do |user|
+        user.first_name, user.last_name = user.full_name.split(' ')
+        user.save
+      end
+    end
+    EOF
+    @runner.review('db/migrate/20101010080658_update_users.rb', content)
+    errors = @runner.errors
+    errors.should_not be_empty
+    errors.size.should == 1
+    errors[0].to_s.should == "db/migrate/20101010080658_update_users.rb:2 - use say with time in migrations"
+  end
+
+  it "should use say with time in migrations with create_table" do
+    content =<<-EOF
+    def self.up
+      create_table :users do |t|
+        t.string :login
+        t.timestamps
+      end
+
+      User.find_each do |user|
+        user.first_name, user.last_name = user.full_name.split(' ')
+        user.save
+      end
+    end
+    EOF
+    @runner.review('db/migrate/20101010080658_update_users.rb', content)
+    errors = @runner.errors
+    errors.should_not be_empty
+    errors.size.should == 1
+    errors[0].to_s.should == "db/migrate/20101010080658_update_users.rb:7 - use say with time in migrations"
+  end
+
+  it "should not use say with time in migrations" do
+    content =<<-EOF
+    def self.up
+      say_with_time("Initialize first_name and last_name for users") do
+        User.find_each do |user|
+          user.first_name, user.last_name = user.full_name.split(' ')
+          user.save
+          say(user.id + " was updated.")
+        end
+      end
+    end
+    EOF
+    @runner.review('db/migrate/20101010080658_update_users.rb', content)
+    errors = @runner.errors
+    errors.should be_empty
+  end
+
+  it "should not use say with time when default migration message" do
+    content =<<-EOF
+    def self.up
+      create_table :users do |t|
+        t.string :login
+        t.string :email
+        t.timestamps
+      end
+    end
+    EOF
+    @runner.review('db/migrate/20101010080658_create_users.rb', content)
+    errors = @runner.errors
+    errors.should be_empty
+  end
+
+  it "should not raise an error" do
+    content =<<-EOF
+    class AddAdmin < ActiveRecord::Migration
+
+      class Person < ActiveRecord::Base
+      end
+
+      class Blog < ActiveRecord::Base
+      end
+
+      def self.up
+        add_column :people, :admin, :boolean, :default => false, :null => false
+        add_column :people, :deactivated, :boolean,
+                            :default => false, :null => false
+
+        key = Crypto::Key.from_file("\#{RAILS_ROOT}/rsa_key.pub")
+        person = Person.new(:email => "admin@example.com",
+                            :name => "admin",
+                            :crypted_password => key.encrypt("admin"),
+                            :description => "")
+        person.admin = true
+        person.save!
+        Blog.create(:person_id => person.id)
+      end
+
+      def self.down
+        remove_column :people, :deactivated
+        Person.delete(Person.find_by_name("admin"))
+        remove_column :people, :admin
+      end
+    end
+    EOF
+    @runner.review('db/migrate/20101010080658_create_users.rb', content)
+    errors = @runner.errors
+    errors.should be_empty
+  end
+end

data/spec/rails_best_practices/checks/use_scope_access_check_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+describe RailsBestPractices::Checks::UseScopeAccessCheck do
+  before(:each) do
+    @runner = RailsBestPractices::Core::Runner.new(RailsBestPractices::Checks::UseScopeAccessCheck.new)
+  end
+
+  context "if" do
+    it "shoud use scope access" do
+      content = <<-EOF
+      class PostsController < ApplicationController
+
+        def edit
+          @post = Post.find(params[:id])
+
+          if @post.user != current_user
+            flash[:warning] = 'Access Denied'
+            redirect_to posts_url
+          end
+        end
+      end
+      EOF
+      @runner.review('app/controllers/posts_controller.rb', content)
+      errors = @runner.errors
+      errors.should_not be_empty
+      errors[0].to_s.should == "app/controllers/posts_controller.rb:7 - use scope access"
+    end
+
+    it "shoud use scope access by comparing with id" do
+      content = <<-EOF
+      class PostsController < ApplicationController
+
+        def edit
+          @post = Post.find(params[:id])
+
+          if @post.user_id != current_user.id
+            flash[:warning] = 'Access Denied'
+            redirect_to posts_url
+          end
+        end
+      end
+      EOF
+      @runner.review('app/controllers/posts_controller.rb', content)
+      errors = @runner.errors
+      errors.should_not be_empty
+      errors[0].to_s.should == "app/controllers/posts_controller.rb:7 - use scope access"
+    end
+
+    it "shoud use scope access with current_user ==" do
+      content = <<-EOF
+      class PostsController < ApplicationController
+
+        def edit
+          @post = Post.find(params[:id])
+
+          if current_user != @post.user
+            flash[:warning] = 'Access Denied'
+            redirect_to posts_url
+          end
+        end
+      end
+      EOF
+      @runner.review('app/controllers/posts_controller.rb', content)
+      errors = @runner.errors
+      errors.should_not be_empty
+      errors[0].to_s.should == "app/controllers/posts_controller.rb:7 - use scope access"
+    end
+
+    it "shoud use scope access by current_user.id ==" do
+      content = <<-EOF
+      class PostsController < ApplicationController
+
+        def edit
+          @post = Post.find(params[:id])
+
+          if current_user.id != @post.user_id
+            flash[:warning] = 'Access Denied'
+            redirect_to posts_url
+          end
+        end
+      end
+      EOF
+      @runner.review('app/controllers/posts_controller.rb', content)
+      errors = @runner.errors
+      errors.should_not be_empty
+      errors[0].to_s.should == "app/controllers/posts_controller.rb:7 - use scope access"
+    end
+  end
+
+  context "unless" do
+    it "shoud use scope access" do
+      content = <<-EOF
+      class PostsController < ApplicationController
+
+        def edit
+          @post = Post.find(params[:id])
+
+          unless @post.user == current_user
+            flash[:warning] = 'Access Denied'
+            redirect_to posts_url
+          end
+        end
+      end
+      EOF
+      @runner.review('app/controllers/posts_controller.rb', content)
+      errors = @runner.errors
+      errors.should_not be_empty
+      errors[0].to_s.should == "app/controllers/posts_controller.rb:6 - use scope access"
+    end
+
+    it "shoud use scope access by comparing with id" do
+      content = <<-EOF
+      class PostsController < ApplicationController
+
+        def edit
+          @post = Post.find(params[:id])
+
+          unless @post.user_id == current_user.id
+            flash[:warning] = 'Access Denied'
+            redirect_to posts_url
+          end
+        end
+      end
+      EOF
+      @runner.review('app/controllers/posts_controller.rb', content)
+      errors = @runner.errors
+      errors.should_not be_empty
+      errors[0].to_s.should == "app/controllers/posts_controller.rb:6 - use scope access"
+    end
+
+    it "shoud use scope access with current_user ==" do
+      content = <<-EOF
+      class PostsController < ApplicationController
+
+        def edit
+          @post = Post.find(params[:id])
+
+          unless current_user == @post.user
+            flash[:warning] = 'Access Denied'
+            redirect_to posts_url
+          end
+        end
+      end
+      EOF
+      @runner.review('app/controllers/posts_controller.rb', content)
+      errors = @runner.errors
+      errors.should_not be_empty
+      errors[0].to_s.should == "app/controllers/posts_controller.rb:6 - use scope access"
+    end
+
+    it "shoud use scope access by current_user.id ==" do
+      content = <<-EOF
+      class PostsController < ApplicationController
+
+        def edit
+          @post = Post.find(params[:id])
+
+          unless current_user.id == @post.user_id
+            flash[:warning] = 'Access Denied'
+            redirect_to posts_url
+          end
+        end
+      end
+      EOF
+      @runner.review('app/controllers/posts_controller.rb', content)
+      errors = @runner.errors
+      errors.should_not be_empty
+      errors[0].to_s.should == "app/controllers/posts_controller.rb:6 - use scope access"
+    end
+
+    it "should no error in use_scope_access_review" do
+      content = <<-EOF
+      class CommentsController < ApplicationController
+
+        def add_comment
+          @current_user = User.find_by_id(session[:user_id])
+          @id = params[:post_id]
+          @error = ""
+          if (@text = params[:text]) == ""
+            @error = "Please enter a comment!"
+          else
+            @comment = Comment.create_object(@text,  @id, @current_user.id)
+          end
+          unless @comment
+            @error = "Comment could not be saved."
+          end
+        end
+      end
+      EOF
+      @runner.review('app/controllers/comments_controller.rb', content)
+    end
+  end
+end

data/spec/rails_best_practices/core/error_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe RailsBestPractices::Core::Error do
+  it "should return error with filename, line number and message" do
+    RailsBestPractices::Core::Error.new("app/models/user.rb", 100, "not good").to_s.should == "app/models/user.rb:100 - not good"
+  end
+end

data/spec/rails_best_practices/core/visitable_sexp_spec.rb

@@ -0,0 +1,259 @@
+require 'spec_helper'
+
+describe Sexp do
+  before :each do
+    @parser = RubyParser.new
+  end
+
+  describe "children" do
+    it "should get all child nodes" do
+      node = @parser.parse("puts 'hello ', 'world'")
+      node.children.should == [s(:arglist, s(:str, "hello "), s(:str, "world"))]
+    end
+  end
+
+  describe "recursive_children" do
+    it "should get all recursive child nodes" do
+      node = @parser.parse("puts 'hello', dynamic_output")
+      children = []
+      node.recursive_children { |child| children << child }
+      children.should == [s(:arglist, s(:str, "hello"), s(:call, nil, :dynamic_output, s(:arglist))), s(:str, "hello"), s(:call, nil, :dynamic_output, s(:arglist)), s(:arglist)]
+    end
+  end
+
+  describe "grep_nodes" do
+    before :each do
+      content = <<-EOF
+      def show
+        current_user.posts.find(params[:id])
+      end
+      EOF
+      @node = @parser.parse(content)
+    end
+
+    it "should get the call nodes with empty arguments" do
+      nodes = []
+      @node.grep_nodes(:node_type => :call, :arguments => s(:arglist)) { |node| nodes << node }
+      nodes.should == [s(:call, s(:call, nil, :current_user, s(:arglist)), :posts, s(:arglist)), s(:call, nil, :current_user, s(:arglist)), s(:call, nil, :params, s(:arglist))]
+    end
+
+    it "should get the call nodes with different messages" do
+      nodes = []
+      @node.grep_nodes(:node_type => :call, :message => [:current_user, :params]) { |node| nodes << node }
+      nodes.should == [s(:call, nil, :current_user, s(:arglist)), s(:call, nil, :params, s(:arglist))]
+    end
+  end
+
+  describe "grep_node" do
+    before :each do
+      content = <<-EOF
+      def show
+        current_user.posts.find(params[:id])
+      end
+      EOF
+      @node = @parser.parse(content)
+    end
+
+    it "should get first node with empty argument" do
+      node = @node.grep_node(:node_type => :call, :arguments => s(:arglist))
+      node.should == s(:call, s(:call, nil, :current_user, s(:arglist)), :posts, s(:arglist))
+    end
+  end
+
+  describe "grep_nodes_count" do
+    before :each do
+      content = <<-EOF
+      def show
+        current_user.posts.find(params[:id])
+      end
+      EOF
+      @node = @parser.parse(content)
+    end
+
+    it "should get the count of call nodes" do
+      @node.grep_nodes_count(:node_type => :call).should == 5
+    end
+  end
+
+  describe "subject" do
+    it "should get subject of attrasgn node" do
+      node = @parser.parse("user.name = params[:name]")
+      node.subject.should == s(:call, nil, :user, s(:arglist))
+    end
+
+    it "should get subject of call node" do
+      node = @parser.parse("user.name")
+      node.subject.should == s(:call, nil, :user, s(:arglist))
+    end
+
+    it "should get subject of iter node" do
+      node = @parser.parse("@users.each { |user| p user }")
+      node.subject.should == s(:call, s(:ivar, :@users), :each, s(:arglist))
+    end
+  end
+
+  describe "class_name" do
+    it "should get class name of class node" do
+      node = @parser.parse("class User; end")
+      node.class_name.should == :User
+    end
+  end
+
+  describe "base_class" do
+    it "should get base class of class node" do
+      node = @parser.parse("class User < ActiveRecord::Base; end")
+      node.base_class.should == s(:colon2, s(:const, :ActiveRecord), :Base)
+    end
+  end
+
+  describe "left_value" do
+    it "should get the left value of lasgn" do
+      node = @parser.parse("user = params[:user]")
+      node.left_value.should == :user
+    end
+
+    it "should get the left value of iasgn" do
+      node = @parser.parse("@user = params[:user]")
+      node.left_value.should == :@user
+    end
+  end
+
+  describe "right_value" do
+    it "should get the right value of lasgn" do
+      node = @parser.parse("user = current_user")
+      node.right_value.should == s(:call, nil, :current_user, s(:arglist))
+    end
+
+    it "should get the right value of iasgn" do
+      node = @parser.parse("@user = current_user")
+      node.right_value.should == s(:call, nil, :current_user, s(:arglist))
+    end
+  end
+
+  describe "message" do
+    it "should get the message of attrasgn" do
+      node = @parser.parse("user.name = params[:name]")
+      node.message.should == :name=
+    end
+
+    it "should get the message of call" do
+      node = @parser.parse("has_many :projects")
+      node.message.should == :has_many
+    end
+  end
+
+  describe "arguments" do
+    it "should get the arguments of attrasgn" do
+      node = @parser.parse("post.user = current_user")
+      node.arguments.should == s(:arglist, s(:call, nil, :current_user, s(:arglist)))
+    end
+
+    it "should get the arguments of call" do
+      node = @parser.parse("username == ''")
+      node.arguments.should == s(:arglist, s(:str, ""))
+    end
+  end
+
+  describe "conditional_statement" do
+    it "should get conditional statement of if" do
+      node = @parser.parse("if current_user.present?; puts current_user.login; end")
+      node.conditional_statement.should == s(:call, s(:call, nil, :current_user, s(:arglist)), :present?, s(:arglist))
+    end
+  end
+
+  describe "true_node" do
+    it "should get the true node of if" do
+      content = <<-EOF
+      if current_user.login?
+        current_user.login
+      else
+        current_user.email
+      end
+      EOF
+      node = @parser.parse(content)
+      node.true_node.should == s(:call, s(:call, nil, :current_user, s(:arglist)), :login, s(:arglist))
+    end
+  end
+
+  describe "false_node" do
+    it "should get the false node of if" do
+      content = <<-EOF
+      if current_user.login?
+        current_user.login
+      else
+        current_user.email
+      end
+      EOF
+      node = @parser.parse(content)
+      node.false_node.should == s(:call, s(:call, nil, :current_user, s(:arglist)), :email, s(:arglist))
+    end
+  end
+
+  describe "method_name" do
+    it "should get the method name of defn" do
+      node = @parser.parse("def show; end")
+      node.method_name.should == :show
+    end
+  end
+
+  describe "body" do
+    it "should get body of iter" do
+      node = @parser.parse("resources :posts do; resources :comments; end")
+      node.body.should == s(:call, nil, :resources, s(:arglist, s(:lit, :comments)))
+    end
+
+    it "should get body of class" do
+      node = @parser.parse("class User; def login; end; def email; end; end")
+      node.body.should == s(:block, s(:defn, :login, s(:args), s(:scope, s(:block, s(:nil)))),  s(:defn, :email, s(:args), s(:scope, s(:block, s(:nil)))))
+    end
+
+    it "should get body of defn" do
+      node = @parser.parse("def fullname; first_name + last+name; end")
+      node.body.should == s(:block, s(:call, s(:call, s(:call, nil, :first_name, s(:arglist)), :+, s(:arglist, s(:call, nil, :last, s(:arglist)))), :+, s(:arglist, s(:call, nil, :name, s(:arglist)))))
+    end
+  end
+
+  describe "to_s" do
+    it "should get to_s for lvar" do
+      node = @parser.parse("user = current_user; user")
+      node.children[1].node_type.should == :lvar
+      node.children[1].to_s.should == "user"
+    end
+
+    it "should get to_s for ivar" do
+      node = @parser.parse("@user")
+      node.to_s.should == "@user"
+    end
+
+    it "should get to_s for str" do
+      node = @parser.parse("'user'")
+      node.to_s.should == "user"
+    end
+
+    it "should get to_s for lit" do
+      node = @parser.parse("{:user => 'Richard'}")
+      node[1].to_s.should == "user"
+    end
+
+
+    it "should get to_s for const" do
+      node = @parser.parse("User")
+      node.to_s.should == "User"
+    end
+
+    it "should get to_s for array" do
+      node = @parser.parse("[@user1, @user2]")
+      node.to_s.should == '["@user1", "@user2"]'
+    end
+
+    it "should get to_s for hash" do
+      node = @parser.parse("{:first_name => 'Richard', :last_name => 'Huang'}")
+      node.to_s.should == '{"first_name" => "Richard", "last_name" => "Huang"}'
+    end
+
+    it "should get to_s for colon2" do
+      node = @parser.parse("RailsBestPractices::Core")
+      node.to_s.should == "RailsBestPractices::Core"
+    end
+  end
+end