rails_best_practices 0.1.0

data/lib/rails_best_practices/checks/use_model_callback_check.rb

@@ -0,0 +1,12 @@
+require 'rails_best_practices/checks/check'
+
+module RailsBestPractices
+  module Checks
+    # TODO: unknown how to realize it.
+    class UseModelCallbackCheck < Check
+      
+      def interesting_nodes
+      end
+    end
+  end
+end

data/lib/rails_best_practices/checks/use_scope_access_check.rb

@@ -0,0 +1,38 @@
+require 'rails_best_practices/checks/check'
+
+module RailsBestPractices
+  module Checks
+    # Check a controller to make sure using scope access
+    #
+    # 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
+    class UseScopeAccessCheck < Check
+      
+      def interesting_nodes
+        [:if, :unless]
+      end
+      
+      def interesting_files
+        /_controller.rb$/
+      end
+      
+      def evaluate_start(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.method_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.message == :current_user or (call_node.subject.message == :current_user and call_node.message == :id)
+      end
+      
+    end
+  end
+end

data/lib/rails_best_practices/command.rb

@@ -0,0 +1,32 @@
+require 'optparse'
+
+def expand_dirs_to_files *dirs
+  extensions = ['rb']
+
+  dirs.flatten.map { |p|
+    if File.directory? p
+      Dir[File.join(p, '**', "*.{#{extensions.join(',')}}")]
+    else
+      p
+    end
+  }.flatten.sort
+end
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: rails_best_practices [options]"
+  
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.parse!
+end
+
+runner = RailsBestPractices::Core::Runner.new
+expand_dirs_to_files(ARGV).each.each { |file| runner.check_file(file) }
+runner.errors.each {|error| puts error}
+puts "\nFound #{runner.errors.size} errors."
+
+exit runner.errors.size

data/lib/rails_best_practices/core.rb

@@ -0,0 +1,5 @@
+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'

data/lib/rails_best_practices/core/checking_visitor.rb

@@ -0,0 +1,26 @@
+module RailsBestPractices
+  module Core
+    class CheckingVisitor
+      def initialize(*checks)
+        @checks ||= {}
+        checks.first.each do |check|
+          nodes = check.interesting_nodes
+          nodes.each do |node|
+            @checks[node] ||= []
+            @checks[node] << check
+            @checks[node].uniq!
+          end
+        end
+      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/core_ext.rb

@@ -0,0 +1,11 @@
+module Enumerable
+  def dups
+    inject({}) {|h,v| h[v]=h[v].to_i+1; h}.reject{|k,v| v==1}.keys
+  end
+end
+
+class NilClass
+  def method_missing(method_sym, *arguments, &block)
+    return nil
+  end
+end

data/lib/rails_best_practices/core/error.rb

@@ -0,0 +1,17 @@
+module RailsBestPractices
+  module Core
+    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
+    end
+  end
+end

data/lib/rails_best_practices/core/runner.rb

@@ -0,0 +1,59 @@
+require 'rubygems'
+require 'ruby_parser'
+require 'yaml'
+
+module RailsBestPractices
+  module Core
+    class Runner
+      DEFAULT_CONFIG = File.join(File.dirname(__FILE__), "..", "..", "..", "rails_best_practices.yml")
+      
+      def initialize(*checks)
+        @config = DEFAULT_CONFIG
+        @checks = checks unless checks.empty?
+        @checks ||= load_checks
+        @checker ||= CheckingVisitor.new(@checks)
+        @parser = RubyParser.new
+      end
+
+      def check(filename, content)
+        node = parse(filename, content)
+        node.accept(@checker) if node
+      end
+
+      def check_content(content)
+        check("dummy-file.rb", content)
+      end
+
+      def check_file(filename)
+        check(filename, File.read(filename))
+      end
+
+      def errors
+        @checks ||= []
+        all_errors = @checks.collect {|check| check.errors}
+        all_errors.flatten
+      end
+
+      private
+
+      def parse(filename, content)
+        begin
+          @parser.parse(content, filename)
+        rescue Exception => e
+          puts "#{filename} looks like it's not a valid Ruby file.  Skipping..." if ENV["ROODI_DEBUG"]
+          nil
+        end
+      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]))
+        end
+        check_objects
+      end
+    end
+  end
+end

data/lib/rails_best_practices/core/visitable_sexp.rb

@@ -0,0 +1,102 @@
+require 'rubygems'
+require 'sexp'
+
+class Sexp
+  def accept(visitor)
+    visitor.visit(self)
+  end
+
+  def node_type
+    first
+  end
+
+  def children
+    find_all { | sexp | Sexp === sexp }
+  end
+  
+  def is_language_node?
+    first.class == Symbol
+  end
+  
+  def visitable_children
+    parent = is_language_node? ? sexp_body : self
+    parent.children
+  end
+  
+  def recursive_children(&handler)
+    visitable_children.each do |child|
+      handler.call child
+      child.recursive_children(&handler)
+    end
+  end
+  
+  def grep_nodes(options)
+    return self if options.empty?
+    subject = options[:subject]
+    message = options[:message]
+    arguments = options[:arguments]
+    nodes = []
+    self.recursive_children do |child|
+      if (!subject or subject == child.subject) and (!message or message == child.message) and (!arguments or arguments == child.arguments)
+        nodes << child
+      end
+    end
+    nodes
+  end
+  
+  def subject
+    case node_type
+    when :attrasgn, :call, :iasgn, :lasgn
+      self[1]
+    else
+    end
+  end
+  
+  def message
+    case node_type
+    when :attrasgn, :call
+      self[2]
+    else
+    end
+  end
+  
+  def arguments
+    case node_type
+    when :attrasgn, :call
+      self[3]
+    else
+    end
+  end
+  
+  def call
+    case node_type
+    when :if, :arglist
+      self[1]
+    else
+    end
+  end
+  
+  def true_node
+    case node_type
+    when :if
+      self[2]
+    else
+    end
+  end
+  
+  def false_node
+    case node_type
+    when :if
+      self[3]
+    else
+    end
+  end
+  
+  def method_body
+    case node_type
+    when :block
+      self[1..-1]
+    else
+    end
+  end
+end

data/rails_best_practices.yml

@@ -0,0 +1,7 @@
+MoveFinderToNamedScopeCheck: { }
+UseModelAssociationCheck: { }
+UseScopeAccessCheck: { }
+AddModelVirtualAttributeCheck: { }
+# UseModelCallbackCheck: { }
+ReplaceComplexCreationWithFactoryMethodCheck: { attribute_assignment_count: 2 }
+MoveModelLogicIntoModelCheck: { called_count: 4 }

data/spec/rails_best_practices/checks/add_model_virtual_attribute_check_spec.rb

@@ -0,0 +1,60 @@
+require File.join(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe RailsBestPractices::Checks::AddModelVirtualAttributeCheck do
+  before(:each) do
+    @runner = RailsBestPractices::Core::Runner.new(RailsBestPractices::Checks::AddModelVirtualAttributeCheck.new)
+  end
+  
+  it "should add model virtual attribute" do
+    content = <<-EOF
+    class UsersController < ApplicationController
+      
+      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
+    end
+    EOF
+    @runner.check('app/controller/users_controller.rb', content)
+    errors = @runner.errors
+    errors.should_not be_empty
+    errors[0].to_s.should == "app/controller/users_controller.rb:3 - add model virtual attribute"
+  end
+
+  it "should not add model virtual attribute with differen param" do
+    content = <<-EOF
+    class UsersController < ApplicationController
+
+      def create
+        @user = User.new(params[:user])
+        @user.first_name = params[:first_name]
+        @user.last_name = params[:last_name]
+        @user.save
+      end
+    end
+    EOF
+    @runner.check('app/controller/users_controller.rb', content)
+    errors = @runner.errors
+    errors.should be_empty
+  end
+  
+  it "should not add model virtual attribute with read" do
+    content = <<-EOF
+    class UsersController < ApplicationController
+      
+      def show
+        if params[:id]
+          @user = User.find(params[:id])
+        else
+          @user = current_user
+        end
+      end
+    end
+    EOF
+    @runner.check('app/controller/users_controller.rb', content)
+    errors = @runner.errors
+    errors.should be_empty
+  end
+end

data/spec/rails_best_practices/checks/many_to_many_collection_check_spec.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe RailsBestPractices::Checks::ManyToManyCollectionCheck do
+  before(:each) do
+    @runner = RailsBestPractices::Core::Runner.new(RailsBestPractices::Checks::ManyToManyCollectionCheck.new)
+  end
+  
+  it "should many to many collection check" do
+    pending
+  end
+end

data/spec/rails_best_practices/checks/move_finder_to_named_scope_check_spec.rb

@@ -0,0 +1,82 @@
+require File.join(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe RailsBestPractices::Checks::MoveFinderToNamedScopeCheck do
+  before(:each) do
+    @runner = RailsBestPractices::Core::Runner.new(RailsBestPractices::Checks::MoveFinderToNamedScopeCheck.new)
+  end
+  
+  it "should move finder to named_scope" do
+    content = <<-EOF
+    class PostsController < ActionController::Base
+
+      def index
+        @public_posts = Post.find(:all, :conditions => { :state => 'public' },
+                                        :limit => 10,
+                                        :order => 'created_at desc')
+
+        @draft_posts  = Post.find(:all, :conditions => { :state => 'draft' },
+                                        :limit => 10,
+                                        :order => 'created_at desc')
+      end
+    end
+    EOF
+    @runner.check('app/controller/posts_controller.rb', content)
+    errors = @runner.errors
+    errors.size.should == 2
+    errors[0].to_s.should == "app/controller/posts_controller.rb:4 - move finder to named_scope"
+    errors[1].to_s.should == "app/controller/posts_controller.rb:8 - move finder to named_scope"
+  end
+  
+  it "should not move simple finder" do
+    content = <<-EOF
+    class PostsController < ActionController::Base
+
+      def index
+        @all_posts = Post.find(:all)
+        @another_all_posts = Post.all
+        @first_post = Post.find(:first)
+        @another_first_post = Post.first
+        @last_post = Post.find(:last)
+        @another_last_post = Post.last
+      end
+    end
+    EOF
+    @runner.check('app/controller/posts_controller.rb', content)
+    @runner.errors.should be_empty
+  end
+  
+  it "should not move namd_scope" do
+    content = <<-EOF
+    class PostsController < ActionController::Base
+
+      def index
+        @public_posts = Post.published
+        @draft_posts  = Post.draft
+      end
+    end
+    EOF
+    @runner.check('app/controller/posts_controller.rb', content)
+    @runner.errors.should be_empty
+  end
+  
+  it "should not check model file" do
+    content = <<-EOF
+    class Post < ActiveRecord::Base
+      
+      def published
+        Post.find(:all, :conditions => { :state => 'public' },
+                        :limit => 10, :order => 'created_at desc')
+      end
+
+      def published
+        Post.find(:all, :conditions => { :state => 'draft' },
+                        :limit => 10, :order => 'created_at desc')
+      end
+                          
+    end
+    EOF
+    @runner.check('app/model/post.rb', content)
+    @runner.errors.should be_empty
+    
+  end
+end