--- a/app/models/repository.rb
+++ b/app/models/repository.rb
@@ -5,130 +5,121 @@ class Repository < ActiveRecord::Base
   has_many    :committerships, :dependent => :destroy
   has_many    :committers, :through => :committerships, :source => :user
   has_many    :comments, :dependent => :destroy
-  has_many    :merge_requests, :foreign_key => 'target_repository_id', 
+  has_many    :merge_requests, :foreign_key => 'target_repository_id',
     :order => "status, id desc", :dependent => :destroy
-  has_many    :proposed_merge_requests, :foreign_key => 'source_repository_id', 
+  has_many    :proposed_merge_requests, :foreign_key => 'source_repository_id',
                 :class_name => 'MergeRequest', :order => "id desc", :dependent => :destroy
-  has_many    :cloners, :dependent => :destroy
-  
+
   validates_presence_of :user_id, :project_id, :name
   validates_format_of :name, :with => /^[a-z0-9_\-]+$/i,
     :message => "is invalid, must match something like /[a-z0-9_\\-]+/"
   validates_uniqueness_of :name, :scope => :project_id, :case_sensitive => false
-  
+
   before_save :set_as_mainline_if_first
   after_create :add_user_as_committer, :create_new_repos_task
   after_destroy :create_delete_repos_task
-  
+
   def self.new_by_cloning(other, username=nil)
     suggested_name = username ? "#{username}s-clone" : nil
     new(:parent => other, :project => other.project, :name => suggested_name)
   end
-  
+
   def self.find_by_name!(name)
     find_by_name(name) || raise(ActiveRecord::RecordNotFound)
   end
-  
-  def self.find_by_path(path)
-    base_path = path.gsub(/^#{Regexp.escape(GitoriousConfig['repository_base_path'])}/, "")
-    repo_name, project_name = base_path.split("/").reverse
-    
-    project = Project.find_by_slug!(project_name)
-    project.repositories.find_by_name(repo_name.sub(/\.git/, ""))
-  end
-  
+
   def self.create_git_repository(path)
     git_backend.create(full_path_from_partial_path(path))
   end
-  
+
   def self.clone_git_repository(target_path, source_path)
-    git_backend.clone(full_path_from_partial_path(target_path), 
+    git_backend.clone(full_path_from_partial_path(target_path),
       full_path_from_partial_path(source_path))
   end
-  
+
   def self.delete_git_repository(path)
     git_backend.delete!(full_path_from_partial_path(path))
   end
-  
+
   def gitdir
     File.join(project.slug, "#{name}.git")
   end
-  
+
   def clone_url
     "git://#{GitoriousConfig['gitorious_host']}/#{gitdir}"
   end
-  
+
   def http_clone_url
     "http://git.#{GitoriousConfig['gitorious_host']}/#{gitdir}"
   end
-  
+
   def push_url
     "git@#{GitoriousConfig['gitorious_host']}:#{gitdir}"
   end
-  
+
   def full_repository_path
     self.class.full_path_from_partial_path(gitdir)
   end
-  
+
   def git
     Grit::Repo.new(full_repository_path)
   end
-  
+
   def has_commits?
     return false if new_record? || !ready?
     !git.heads.empty?
   end
-  
+
   def self.git_backend
     RAILS_ENV == "test" ? MockGitBackend : GitBackend
   end
-  
+
   def git_backend
     RAILS_ENV == "test" ? MockGitBackend : GitBackend
   end
-  
+
   def to_param
     name
   end
-  
+
   def to_xml(opts = {})
     super({:methods => [:gitdir, :clone_url, :push_url]}.merge(opts))
   end
-  
+
   def add_committer(user)
     unless user.can_write_to?(self)
       committers << user
     end
   end
-  
+
   def head_candidate
     return nil unless has_commits?
     @head_candidate ||= git.heads.find{|h| h.name == "master"} || git.heads.first
   end
-  
+
   def last_commit
     if has_commits?
       @last_commit ||= git.commits(head_candidate.name, 1).first
     end
     @last_commit
   end
-  
+
   def can_be_deleted_by?(candidate)
     !mainline? && (candidate == user)
   end
-  
+
   def create_new_repos_task
-    Task.create!(:target_class => self.class.name, 
-      :command => parent ? "clone_git_repository" : "create_git_repository", 
-      :arguments => parent ? [gitdir, parent.gitdir] : [gitdir], 
+    Task.create!(:target_class => self.class.name,
+      :command => parent ? "clone_git_repository" : "create_git_repository",
+      :arguments => parent ? [gitdir, parent.gitdir] : [gitdir],
       :target_id => self.id)
   end
-  
+
   def create_delete_repos_task
-    Task.create!(:target_class => self.class.name, 
+    Task.create!(:target_class => self.class.name,
       :command => "delete_git_repository", :arguments => [gitdir])
   end
-  
+
   def paginated_commits(tree_name, page, per_page = 30)
     page    = (page || 1).to_i
     total   = git.commit_count(tree_name)
@@ -136,27 +127,32 @@ class Repository < ActiveRecord::Base
     commits = WillPaginate::Collection.new(page, per_page, total)
     commits.replace git.commits(tree_name, per_page, offset)
   end
-  
+
   def count_commits_from_last_week_by_user(user)
     return 0 unless has_commits?
-    
-    commits_by_email = git.commits_since("master", "last week").collect do |commit| 
-      commit.committer.email == user.email
-    end
+
+    commits_by_email = git.commits_since("master", "last week", user.email)
+    commits_by_email.size
+  end
+
+  def count_commits_from_the_beginning_by_user(user)
+    return 0 unless has_commits?
+
+    commits_by_email = git.commits_since("master", "1970-01-01", user.email)
     commits_by_email.size
   end
-  
+
   # TODO: cache
-  def commit_graph_data(head = "master")    
+  def commit_graph_data(head = "master")
     commits = git.commits_since(head, "24 weeks ago")
     commits_by_week = commits.group_by{|c| c.committed_date.strftime("%W") }
-    
+
     # build an initial empty set of 24 week commit data
-    weeks = [1.day.from_now-1.week] 
+    weeks = [1.day.from_now-1.week]
     23.times{|w| weeks << weeks.last-1.week }
     week_numbers = weeks.map{|d| d.strftime("%W") }
     commits = (0...24).to_a.map{|i| 0 }
-    
+
     commits_by_week.each do |week, commits_in_week|
       if week_pos = week_numbers.index(week)
         commits[week_pos+1] = commits_in_week.size
@@ -165,17 +161,17 @@ class Repository < ActiveRecord::Base
     commits = [] if commits.max == 0
     [week_numbers.reverse, commits.reverse]
   end
-  
+
   # TODO: refactor into simpler approach
   # TODO: caching
-  def commit_graph_data_by_author(head = "master")    
+  def commit_graph_data_by_author(head = "master")
     h = Hash.new
-    
+
     data = self.git.git.rev_list({:pretty => "format:name:%cn", :since => "1 years ago" }, head)
     data.each_line do |line|
       if line =~ /^name:(.*)$/ then
         author = $1
-        
+
         if h[author]
           h[author] += 1
         else
@@ -183,69 +179,65 @@ class Repository < ActiveRecord::Base
         end
       end
     end
-    
+
     sorted = h.sort_by do |author, commits|
       commits
     end
-    
+
     labels = []
     data = []
-    
+
     max = 8
     others = []
     top = sorted
-    
-    
+
+
     if sorted.size > max
       top = sorted[sorted.size-max, sorted.size]
       others = sorted[0, sorted.size-max]
     end
-    
+
     top.each do |entry|
       author = entry.first
       v = entry.last
-      
+
       data << v
       labels << author
     end
-    
+
     unless others.empty?
       others_v = others.inject { |v, acum| [v.last + acum.last] }
       labels << "others"
       data << others_v.last
     end
-    
+
     #[labels, data]
-    labels.inject({}) do |hash, label| 
-      hash[label] = data[labels.index(label)] 
+    labels.inject({}) do |hash, label|
+      hash[label] = data[labels.index(label)]
       hash
     end
   end
-  
+
   # Returns a Hash {email => user}, where email is selected from the +commits+
   def users_by_commits(commits)
     emails = commits.map { |commit| commit.author.email }.uniq
     users = User.find(:all, :conditions => ["email in (?)", emails])
-    
+
     users_by_email = users.inject({}){|hash, user| hash[user.email] = user; hash }
     users_by_email
   end
-  
-  def cloned_from(ip, country_code = "--", country_name = nil)
-    cloners.create(:ip => ip, :date => Time.now.utc, :country_code => country_code, :country => country_name)
-  end
-    
+
   protected
     def set_as_mainline_if_first
       unless project.repositories.size >= 1
         self.mainline = true
       end
     end
-    
+
     def add_user_as_committer
       committers << user
     end
-    
+
     def self.full_path_from_partial_path(path)
       File.expand_path(File.join(GitoriousConfig["repository_base_path"], path))
     end

--- a/app/models/user.rb
+++ b/app/models/user.rb
@@ -6,13 +6,13 @@ class User < ActiveRecord::Base
   has_many :repositories, :through => :committerships
   has_many :ssh_keys, :order => "id desc"
   has_many :comments
-  
+
   # Virtual attribute for the unencrypted password
   attr_accessor :password, :current_password
-  
+
   attr_protected :login
 
-  validates_presence_of     :login, :email
+  validates_presence_of     :login, :email,               :if => :password_required?
   validates_format_of       :login, :with => /^[a-z0-9\-_\.]+$/i
   validates_format_of       :email, :with => /^[^@\s]+@([\-a-z0-9]+\.)+[a-z]{2,}$/i
   validates_presence_of     :password,                   :if => :password_required?
@@ -22,14 +22,14 @@ class User < ActiveRecord::Base
   validates_length_of       :login,    :within => 3..40
   validates_length_of       :email,    :within => 3..100
   validates_uniqueness_of   :login, :email, :case_sensitive => false
-  
+
   before_save :encrypt_password
-  before_create :make_activation_code 
-  
+  before_create :make_activation_code
+
   def self.find_by_login!(name)
     find_by_login(name) || raise(ActiveRecord::RecordNotFound )
   end
-  
+
   # Authenticates a user by their login name and unencrypted password.  Returns the user or nil.
   def self.authenticate(email, password)
     u = find :first, :conditions => ['email = ? and activated_at IS NOT NULL', email] # need to get the salt
@@ -40,7 +40,7 @@ class User < ActiveRecord::Base
   def self.encrypt(password, salt)
     Digest::SHA1.hexdigest("--#{salt}--#{password}--")
   end
-  
+
   def self.generate_random_password(password_size = 12)
     characters = (("a".."z").to_a + ("0".."9").to_a) - %w[0 o i l 1]
     (0...password_size).collect do |char|
@@ -75,7 +75,7 @@ class User < ActiveRecord::Base
   end
 
   def remember_token?
-    remember_token_expires_at && Time.now.utc < remember_token_expires_at 
+    remember_token_expires_at && Time.now.utc < remember_token_expires_at
   end
 
   # These create and unset the fields required for remembering users between browser closes
@@ -98,7 +98,7 @@ class User < ActiveRecord::Base
     self.remember_token            = nil
     save(false)
   end
-  
+
   def reset_password!
     generated = User.generate_random_password
     self.password = generated
@@ -106,32 +106,44 @@ class User < ActiveRecord::Base
     self.save!
     generated
   end
-  
+
   def can_write_to?(repository)
     !!committerships.find_by_repository_id(repository.id)
   end
-  
+
   def to_param
     login
   end
-  
+
   def to_xml(opts = {})
     super({:except => [:activation_code, :crypted_password, :remember_token, :remember_token_expires_at, :salt, :ssh_key_id]}.merge(opts))
   end
 
+  def count_commits_from_last_week
+    repositories.inject(0) { |sum, repo| sum + repo.count_commits_from_last_week_by_user(self)}
+  end
+
+  def count_commits_from_the_beginning
+    repositories.inject(0) { |sum, repo| sum + repo.count_commits_from_the_beginning_by_user(self)}
+  end
+
   protected
-    # before filter 
+    # before filter
     def encrypt_password
       return if password.blank?
       self.salt = Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{login}--") if new_record?
       self.crypted_password = encrypt(password)
     end
-    
+
     def password_required?
-      crypted_password.blank? || !password.blank?
+      not_openid? && (crypted_password.blank? || !password.blank?)
     end
-    
+
+    def not_openid?
+      identity_url.blank?
+    end
+
     def make_activation_code
       self.activation_code = Digest::SHA1.hexdigest( Time.now.to_s.split(//).sort_by {rand}.join )
-    end 
+    end
 end

--- a/vendor/grit/lib/grit/commit.rb
+++ b/vendor/grit/lib/grit/commit.rb
@@ -83,7 +83,7 @@ module Grit
     #
     # Returns Grit::Commit[] (baked)
     def self.find_all(repo, ref, options = {})
-      allowed_options = [:max_count, :skip, :since]
+      allowed_options = [:max_count, :skip, :since, :author]
       
       default_options = {:pretty => "raw"}
       actual_options = default_options.merge(options)

--- a/vendor/grit/lib/grit/repo.rb
+++ b/vendor/grit/lib/grit/repo.rb
@@ -92,9 +92,8 @@ module Grit
     #   +extra_options+ is a hash of extra options
     #
     # Returns Grit::Commit[] (baked)
-    def commits_since(start = 'master', since = '1970-01-01', extra_options = {})
-      options = {:since => since}.merge(extra_options)
-      
+    def commits_since(start = 'master', since = '1970-01-01', author='', extra_options = {})
+      options = {:since => since, :author => author}.merge(extra_options)    
       Commit.find_all(self, start, options)
     end