v1.0

app/models/ability.rb

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

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

@@ -0,0 +1,58 @@
+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)
+#
+

app/models/note.rb

@@ -0,0 +1,41 @@
+require 'carrierwave/orm/activerecord'
+require 'file_size_validator'
+
+class Note < ActiveRecord::Base
+  belongs_to :project
+  belongs_to :noteable, :polymorphic => true
+  belongs_to :author,
+    :class_name => "User"
+
+  attr_protected :author, :author_id 
+
+  validates_presence_of :project
+
+  validates :note,
+            :presence => true,
+            :length   => { :within => 0..255 }
+
+  validates :attachment, 
+            :file_size => { 
+              :maximum => 10.megabytes.to_i 
+            } 
+
+  scope :common, where(:noteable_id => nil)
+
+  mount_uploader :attachment, AttachmentUploader
+end
+# == Schema Information
+#
+# Table name: notes
+#
+#  id            :integer         not null, primary key
+#  note          :string(255)
+#  noteable_id   :string(255)
+#  noteable_type :string(255)
+#  author_id     :integer
+#  created_at    :datetime
+#  updated_at    :datetime
+#  project_id    :integer
+#  attachment    :string(255)
+#
+

app/models/project.rb

@@ -0,0 +1,164 @@
+require "grit"
+
+class Project < ActiveRecord::Base
+  belongs_to :owner, :class_name => "User"
+
+  has_many :issues, :dependent => :destroy
+  has_many :users_projects, :dependent => :destroy
+  has_many :users, :through => :users_projects
+  has_many :notes, :dependent => :destroy
+
+  validates :name,
+            :uniqueness => true,
+            :presence => true,
+            :length   => { :within => 0..255 }
+
+  validates :path,
+            :uniqueness => true,
+            :presence => true,
+            :length   => { :within => 0..255 }
+  
+  validates :description,
+            :length   => { :within => 0..2000 }
+
+  validates :code,
+            :presence => true,
+            :uniqueness => true,
+            :length   => { :within => 3..12 }
+
+  validates :owner,
+            :presence => true
+
+  validate :check_limit
+  
+  before_save :format_code
+  after_destroy :destroy_gitosis_project
+  after_save :update_gitosis_project
+
+  attr_protected :private_flag, :owner_id
+
+  scope :public_only, where(:private_flag => false)
+
+  def to_param
+    code
+  end
+
+  def common_notes
+    notes.where(:noteable_type => ["", nil])
+  end
+
+  def format_code
+    read_attribute(:code).downcase.strip.gsub(' ', '')
+  end
+
+  def update_gitosis_project
+    Gitosis.new.configure do |c|
+      c.update_project(path, gitosis_writers)
+    end
+  end
+  
+  def destroy_gitosis_project
+    Gitosis.new.configure do |c|
+      c.destroy_project(self)
+    end
+  end
+  
+  def add_access(user, *access)
+    opts = { :user => user }
+    access.each { |name| opts.merge!(name => true) }
+    users_projects.create(opts)
+  end
+
+  def reset_access(user)
+    users_projects.where(:project_id => self.id, :user_id => user.id).destroy if self.id
+  end
+
+  def writers
+    @writers ||= users_projects.includes(:user).where(:write => true).map(&:user)
+  end
+
+  def gitosis_writers
+    keys = Key.joins({:user => :users_projects}).where("users_projects.project_id = ? AND users_projects.write = ?", id, true)
+    keys.map(&:identifier)
+  end
+
+  def readers
+    @readers ||= users_projects.includes(:user).where(:read => true).map(&:user)
+  end
+
+  def admins
+    @admins ||=users_projects.includes(:user).where(:admin => true).map(&:user)
+  end
+
+  def public?
+    !private_flag
+  end
+
+  def private?
+    private_flag
+  end
+
+  def url_to_repo
+    "#{GITOSIS["git_user"]}@#{GITOSIS["host"]}:#{path}.git"
+  end
+  
+  def path_to_repo
+    GITOSIS["base_path"] + path + ".git"
+  end
+
+  def repo 
+    @repo ||= Grit::Repo.new(path_to_repo)
+  end
+
+  def tags
+    repo.tags.map(&:name).sort.reverse
+  end
+
+  def repo_exists?
+    repo rescue false
+  end
+
+  def commit(commit_id = nil)
+    if commit_id
+      repo.commits(commit_id).first
+    else 
+      repo.commits.first
+    end
+  end
+
+  def tree(fcommit, path = nil)
+    fcommit = commit if fcommit == :head
+    tree = fcommit.tree
+    path ? (tree / path) : tree
+  end
+
+  def check_limit
+    unless owner.can_create_project?
+      errors[:base] << ("Your own projects limit is #{owner.projects_limit}! Please contact administrator to increase it")
+    end
+  rescue 
+    errors[:base] << ("Cant check your ability to create project")
+  end
+
+  def valid_repo?
+    repo
+  rescue
+    errors.add(:path, "Invalid repository path")
+    false
+  end
+end
+# == Schema Information
+#
+# Table name: projects
+#
+#  id           :integer         not null, primary key
+#  name         :string(255)
+#  path         :string(255)
+#  description  :text
+#  created_at   :datetime
+#  updated_at   :datetime
+#  private_flag :boolean         default(TRUE), not null
+#  code         :string(255)
+#  owner_id     :integer
+#
+

app/models/user.rb

@@ -0,0 +1,62 @@
+class User < ActiveRecord::Base
+  # Include default devise modules. Others available are:
+  # :token_authenticatable, :encryptable, :confirmable, :lockable, :timeoutable and :omniauthable
+  devise :database_authenticatable,
+         :recoverable, :rememberable, :trackable, :validatable
+
+  # Setup accessible (or protected) attributes for your model
+  attr_accessible :email, :password, :password_confirmation, :remember_me, :name, :projects_limit
+
+  has_many :users_projects, :dependent => :destroy
+  has_many :projects, :through => :users_projects
+  has_many :my_own_projects, :class_name => "Project", :foreign_key => :owner_id
+  has_many :keys, :dependent => :destroy
+  has_many :issues,
+    :foreign_key => :author_id,
+    :dependent => :destroy
+
+  has_many :assigned_issues,
+    :class_name => "Issue",
+    :foreign_key => :assignee_id,
+    :dependent => :destroy
+
+  scope :not_in_project, lambda { |project|  where("id not in (:ids)", :ids => project.users.map(&:id) ) }
+
+  def identifier
+    email.gsub "@", "_"
+  end
+
+  def is_admin?
+    admin
+  end
+
+  def can_create_project?
+    projects_limit >= my_own_projects.count
+  end
+
+  def last_activity_project
+    projects.first
+  end
+end
+# == Schema Information
+#
+# Table name: users
+#
+#  id                     :integer         not null, primary key
+#  email                  :string(255)     default(""), not null
+#  encrypted_password     :string(128)     default(""), not null
+#  reset_password_token   :string(255)
+#  reset_password_sent_at :datetime
+#  remember_created_at    :datetime
+#  sign_in_count          :integer         default(0)
+#  current_sign_in_at     :datetime
+#  last_sign_in_at        :datetime
+#  current_sign_in_ip     :string(255)
+#  last_sign_in_ip        :string(255)
+#  created_at             :datetime
+#  updated_at             :datetime
+#  name                   :string(255)
+#  admin                  :boolean         default(FALSE), not null
+#  projects_limit         :integer
+#
+

app/models/users_project.rb

@@ -0,0 +1,35 @@
+class UsersProject < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :project
+
+  attr_protected :project_id, :project
+
+  after_commit :update_gitosis_project
+
+  validates_uniqueness_of :user_id, :scope => [:project_id]
+  validates_presence_of :user_id
+  validates_presence_of :project_id
+ 
+  delegate :name, :email, :to => :user, :prefix => true
+
+  def update_gitosis_project
+    Gitosis.new.configure do |c|
+      c.update_project(project.path, project.gitosis_writers)
+    end
+  end
+
+end
+# == Schema Information
+#
+# Table name: users_projects
+#
+#  id         :integer         not null, primary key
+#  user_id    :integer         not null
+#  project_id :integer         not null
+#  read       :boolean         default(FALSE)
+#  write      :boolean         default(FALSE)
+#  admin      :boolean         default(FALSE)
+#  created_at :datetime
+#  updated_at :datetime
+#
+