init commit

app/controllers/notes_controller.rb

+class NotesController < ApplicationController
+  before_filter :project 
+
+  # Authorize
+  before_filter :add_project_abilities
+  before_filter :authorize_write_note!, :only => [:create] 
+  before_filter :authorize_admin_note!, :only => [:destroy] 
+
+  respond_to :js
+
+  def create
+    @note = @project.notes.new(params[:note])
+    @note.author = current_user
+
+    if @note.save
+      notify if params[:notify] == '1'
+    end
+
+
+    respond_to do |format|
+      format.html {redirect_to :back}
+      format.js  
+    end
+  end
+
+  def destroy
+    @note = @project.notes.find(params[:id])
+    @note.destroy
+
+    respond_to do |format|
+      format.js { render :nothing => true }  
+    end
+  end
+
+  protected 
+
+  def notify
+    @project.users.reject { |u| u.id == current_user.id } .each do |u|
+      case @note.noteable_type
+      when "Commit" then
+        Notify.note_commit_email(u, @note).deliver
+      when "Issue" then
+        Notify.note_issue_email(u, @note).deliver
+      else
+        Notify.note_wall_email(u, @note).deliver
+      end
+    end
+  end
+end

app/controllers/profile_controller.rb

+class ProfileController < ApplicationController
+  def show
+    @user = current_user
+  end
+
+  def password
+    @user = current_user
+  end
+
+  def password_update
+    params[:user].reject!{ |k, v| k != "password" && k != "password_confirmation"} 
+    @user = current_user
+
+    if @user.update_attributes(params[:user])
+      flash[:notice] = "Password was successfully updated. Please login with it"
+      redirect_to new_user_session_path
+    else
+      render :action => "password"
+    end
+  end
+end

app/controllers/projects_controller.rb

+class ProjectsController < ApplicationController
+  before_filter :project, :except => [:index, :new, :create] 
+
+  # Authorize
+  before_filter :add_project_abilities
+  before_filter :authorize_read_project!, :except => [:index, :new, :create] 
+  before_filter :authorize_admin_project!, :only => [:edit, :update, :destroy] 
+
+  def index
+    @projects = current_user.projects.all
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.json { render json: @projects }
+    end
+  end
+
+  def show
+    @repo = project.repo
+    @commit = @repo.commits.first
+    @tree = @commit.tree
+    @tree = @tree / params[:path] if params[:path]
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.json { render json: project }
+    end
+  rescue Grit::NoSuchPathError => ex
+    respond_to do |format|
+      format.html {render "projects/empty"}
+    end
+  end
+
+  def tree
+    @repo = project.repo
+    @branch = if !params[:branch].blank?
+                params[:branch]
+              elsif !params[:tag].blank?
+                params[:tag]
+              else
+                "master"
+              end
+
+    if params[:commit_id]
+      @commit = @repo.commits(params[:commit_id]).first
+    else 
+      @commit = @repo.commits(@branch || "master").first
+    end
+    @tree = @commit.tree
+    @tree = @tree / params[:path] if params[:path]
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.js do 
+        # temp solution
+        response.headers["Cache-Control"] = "no-cache, no-store, max-age=0, must-revalidate"
+        response.headers["Pragma"] = "no-cache"
+        response.headers["Expires"] = "Fri, 01 Jan 1990 00:00:00 GMT"
+      end
+      format.json { render json: project }
+    end
+  end
+
+  def blob
+    @repo = project.repo
+    @commit = project.commit(params[:commit_id])
+    @tree = project.tree(@commit, params[:path])
+
+    if @tree.is_a?(Grit::Blob)
+      send_data(@tree.data, :type => @tree.mime_type, :disposition => 'inline', :filename => @tree.name)
+    else 
+      head(404)
+    end
+  end
+
+  def new
+    @project = Project.new
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.json { render json: @project }
+    end
+  end
+
+  def edit
+  end
+
+  def create
+    @project = Project.new(params[:project])
+
+    Project.transaction do 
+      @project.save!
+      @project.users_projects.create!(:admin => true, :read => true, :write => true, :user => current_user)
+    end
+
+    respond_to do |format|
+      if @project.valid?
+        format.html { redirect_to @project, notice: 'Project was successfully created.' }
+        format.js 
+        format.json { render json: @project, status: :created, location: @project }
+      else
+        format.html { render action: "new" }
+        format.js
+        format.json { render json: @project.errors, status: :unprocessable_entity }
+      end
+    end
+  rescue StandardError => ex
+    @project.errors.add(:base, "Cant save project. Please try again later")
+    respond_to do |format|
+      format.html { render action: "new" }
+      format.js
+      format.json { render json: @project.errors, status: :unprocessable_entity }
+    end
+  end
+
+  def update
+    respond_to do |format|
+      if project.update_attributes(params[:project])
+        format.html { redirect_to project, notice: 'Project was successfully updated.' }
+        format.js 
+        format.json { head :ok }
+      else
+        format.html { render action: "edit" }
+        format.js 
+        format.json { render json: project.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  def destroy
+    project.destroy
+
+    respond_to do |format|
+      format.html { redirect_to projects_url }
+      format.json { head :ok }
+    end
+  end
+
+  def wall
+    @notes = @project.common_notes
+    @note = Note.new
+  end
+
+  protected 
+
+  def project 
+    @project ||= Project.find_by_code(params[:id])
+  end
+end

app/controllers/team_members_controller.rb

+class TeamMembersController < ApplicationController
+  before_filter :project 
+
+  # Authorize
+  before_filter :add_project_abilities
+  before_filter :authorize_read_team_member!
+  before_filter :authorize_admin_team_member!, :only => [:new, :create, :destroy, :update] 
+
+  def show
+    @team_member = project.users_projects.find(params[:id])
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.js
+      format.json { render json: @team_member }
+    end
+  end
+
+  def new
+    @team_member = project.users_projects.new
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.js
+      format.json { render json: @team_member }
+    end
+  end
+
+  def create
+    @team_member = UsersProject.new(params[:team_member])
+    @team_member.project = project
+
+    respond_to do |format|
+      if @team_member.save
+        format.html { redirect_to @team_member, notice: 'Team member was successfully created.' }
+        format.js
+        format.json { render json: @team_member, status: :created, location: @team_member }
+      else
+        format.html { render action: "new" }
+        format.js
+        format.json { render json: @team_member.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  def update
+    @team_member = project.users_projects.find(params[:id])
+    @team_member.update_attributes(params[:team_member])
+
+    respond_to do |format|
+      format.js
+      format.html { redirect_to team_project_path(@project)}
+    end
+  end
+
+  def destroy
+    @team_member = project.users_projects.find(params[:id])
+    @team_member.destroy
+
+    respond_to do |format|
+      format.html { redirect_to root_path }
+      format.json { head :ok }
+      format.js { render :nothing => true }  
+    end
+  end
+end

app/helpers/admin/projects_helper.rb

+module Admin::ProjectsHelper
+end

app/helpers/admin/users_helper.rb

+module Admin::UsersHelper
+end

app/helpers/application_helper.rb

+require 'digest/md5'
+module ApplicationHelper
+  def gravatar_icon(user_email)
+    "http://www.gravatar.com/avatar/#{Digest::MD5.hexdigest(user_email)}?s=40&d=identicon"
+  end
+
+  def commit_name(project, commit)
+    if project.commit.id == commit.id
+      "master"
+    else
+      commit.id
+    end
+  end
+
+  def admin_namespace?
+    controller.class.name.split("::").first=="Admin"
+  end
+
+  def projects_namespace?
+    !current_page?(root_url) &&
+      controller.controller_name != "keys" &&
+      !admin_namespace?
+  end
+
+  def last_commit(project)
+    if project.repo_exists?  
+      time_ago_in_words(project.commit.committed_date) + " ago"
+    else 
+      "Never"
+    end
+  end
+
+  def search_autocomplete_source
+    projects = current_user.projects.map{ |p| { :label => p.name, :url => project_path(p) } }
+    default_nav = [
+      { :label => "Keys", :url => keys_path }, 
+      { :label => "Projects", :url => projects_path }, 
+      { :label => "Admin", :url => admin_root_path }
+    ]
+
+    project_nav = []
+
+    if @project && !@project.new_record?
+      project_nav = [
+        { :label => "#{@project.code} / Issues", :url => project_issues_path(@project) }, 
+        { :label => "#{@project.code} / Wall", :url => wall_project_path(@project) }, 
+        { :label => "#{@project.code} / Tree", :url => tree_project_path(@project) }, 
+        { :label => "#{@project.code} / Commits", :url => project_commits_path(@project) }, 
+        { :label => "#{@project.code} / Team", :url => team_project_path(@project) }
+      ]
+    end
+
+    [projects, default_nav, project_nav].flatten.to_json
+  end
+
+  def handle_file_type(file_name, mime_type)
+    if file_name =~ /(\.rb|\.ru|\.rake|Rakefile|\.gemspec|\.rbx|Gemfile)$/
+      :ruby
+    elsif file_name =~ /\.py$/
+      :python
+    elsif file_name =~ /(\.pl|\.scala|\.c|\.cpp|\.java|\.haml|\.html|\.sass|\.scss|\.xml|\.php|\.erb)$/
+      $1[1..-1].to_sym
+    elsif file_name =~ /\.js$/
+      :javascript
+    elsif file_name =~ /\.sh$/
+      :bash
+    elsif file_name =~ /\.coffee$/
+      :coffeescript
+    elsif file_name =~ /\.yml$/
+      :yaml
+    elsif file_name =~ /\.md$/
+      :minid
+    else
+      :text
+    end
+  end
+end

app/helpers/commits_helper.rb

+module CommitsHelper
+  def diff_line(line, line_new = 0, line_old = 0)
+    full_line = html_escape(line.gsub(/\n/, ''))
+    color = if line[0] == "+" 
+              full_line = "<span class=\"old_line\">&nbsp;</span><span class=\"new_line\">#{line_new}</span> " + full_line
+              "#DFD"
+            elsif line[0] == "-" 
+              full_line = "<span class=\"old_line\">#{line_old}</span><span class=\"new_line\">&nbsp;</span> " + full_line
+              "#FDD"
+            else 
+              full_line = "<span class=\"old_line\">#{line_old}</span><span class=\"new_line\">#{line_new}</span> " + full_line
+              "none"
+            end
+
+    raw "<div style=\"white-space:pre;background:#{color};\">#{full_line}</div>"
+  end
+
+  def more_commits_link
+    offset = params[:offset] || 0
+    limit = params[:limit] || 100
+    link_to "More", project_commits_path(@project, :offset =>  offset.to_i + limit.to_i, :limit => limit),
+      :remote => true, :class => "lite_button vm", :style => "text-align:center; width:930px; ", :id => "more-commits-link"
+  end
+end

app/helpers/dashboard_helper.rb

+module DashboardHelper
+end

app/helpers/issues_helper.rb

+module IssuesHelper
+end

app/helpers/keys_helper.rb

+module KeysHelper
+end

app/helpers/profile_helper.rb

+module ProfileHelper
+end

app/helpers/projects_helper.rb

+module ProjectsHelper
+end

app/helpers/team_members_helper.rb

+module TeamMembersHelper
+end

app/mailers/notify.rb

+class Notify < ActionMailer::Base
+  default_url_options[:host] = "gitlabhq.com"
+  default from: "notify@gitlabhq.com"
+
+  def new_user_email(user, password)
+    @user = user
+    @password = password
+    mail(:to => @user.email, :subject => "gitlab | Account was created for you")
+  end
+
+  def new_issue_email(issue)
+    @user = issue.assignee
+    @project = issue.project
+    @issue = issue
+
+    mail(:to => @user.email, :subject => "gitlab | New Issue was created")
+  end
+
+  def note_wall_email(user, note)
+    @user = user
+    @note = note
+    @project = note.project
+    mail(:to => @user.email, :subject => "gitlab | #{@note.project.name} ")
+  end
+
+  def note_commit_email(user, note)
+    @user = user
+    @note = note
+    @project = note.project
+    @commit = @project.repo.commits(note.noteable_id).first
+    mail(:to => @user.email, :subject => "gitlab | #{@note.project.name} ")
+  end
+
+  def note_issue_email(user, note)
+    @user = user
+    @note = note
+    @project = note.project
+    @issue = note.noteable
+    mail(:to => @user.email, :subject => "gitlab | #{@note.project.name} ")
+  end
+end

app/models/ability.rb

+class Ability
+  def self.allowed(object, subject)
+    case subject.class.name
+    when "Project" then project_abilities(object, subject)
+    else []
+    end
+  end
+
+  def self.project_abilities(user, project)
+    rules = []
+
+    rules << [
+      :read_project,
+      :read_issue,
+      :read_team_member,
+      :read_note 
+    ] if project.readers.include?(user)
+
+    rules << [
+      :write_project,
+      :write_issue,
+      :write_note 
+    ] if project.writers.include?(user)
+
+    rules << [
+      :admin_project,
+      :admin_issue,
+      :admin_team_member,
+      :admin_note 
+    ] if project.admins.include?(user)
+
+    rules.flatten
+  end
+end

app/models/issue.rb

+class Issue < ActiveRecord::Base
+  belongs_to :project
+  belongs_to :author, :class_name => "User"
+  belongs_to :assignee, :class_name => "User"
+  has_many :notes, :as => :noteable
+
+  attr_protected :author, :author_id, :project, :project_id
+
+  validates_presence_of :project_id
+  validates_presence_of :assignee_id
+  validates_presence_of :author_id
+
+  validates :title,
+            :presence => true,
+            :length   => { :within => 0..255 }
+  
+  validates :content,
+            :presence => true,
+            :length   => { :within => 0..2000 }
+
+  scope :opened, where(:closed => false)
+  scope :closed, where(:closed => true)
+  scope :assigned, lambda { |u| where(:assignee_id => u.id)}
+end
+# == Schema Information
+#
+# Table name: issues
+#
+#  id          :integer         not null, primary key
+#  title       :string(255)
+#  content     :text
+#  assignee_id :integer
+#  author_id   :integer
+#  project_id  :integer
+#  created_at  :datetime
+#  updated_at  :datetime
+#  closed      :boolean         default(FALSE), not null
+#
+

app/models/key.rb

+class Key < ActiveRecord::Base
+  belongs_to :user
+
+  validates :title,
+            :presence => true,
+            :length   => { :within => 0..255 }
+
+  validates :key,
+            :presence => true,
+            :uniqueness => true,
+            :length   => { :within => 0..555 }
+
+  before_save :set_identifier
+  after_save :update_gitosis
+  after_destroy :gitosis_delete_key
+
+  def set_identifier
+    self.identifier = "#{user.identifier}_#{Time.now.to_i}"
+  end
+  
+  def update_gitosis
+    Gitosis.new.configure do |c|
+      c.update_keys(identifier, key)
+      
+      projects.each do |project|
+        c.update_project(project.path, project.gitosis_writers)
+      end
+    end
+  end
+
+  def gitosis_delete_key
+    Gitosis.new.configure do |c|
+      c.delete_key(identifier)
+
+      projects.each do |project|
+        c.update_project(project.path, project.gitosis_writers)
+      end
+    end
+  end
+
+   #projects that has this key
+  def projects
+    user.projects
+  end
+end
+# == Schema Information
+#
+# Table name: keys
+#
+#  id         :integer         not null, primary key
+#  user_id    :integer         not null
+#  created_at :datetime
+#  updated_at :datetime
+#  key        :text
+#  title      :string(255)
+#  identifier :string(255)
+#
+