lib/gitauth/repo.rb in brownbeagle-gitauth-0.0.1 vs lib/gitauth/repo.rb in brownbeagle-gitauth-0.0.2

@@ -16,91 +16,94 @@
 #   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #++
 
 require 'fileutils'
 module GitAuth
-  class Repo
-    REPOS_PATH = File.join(GitAuth::GITAUTH_DIR, "repositories.yml")
+  class Repo < SaveableClass(:repositories)
+    NAME_RE    = /^([\w\_\-\.\+]+(\.git)?)$/i
     
-    def self.all
-      @@all_repositories ||= nil
-    end
-    
-    def self.load!
-      self.all = YAML.load_file(REPOS_PATH) rescue nil if File.exist?(REPOS_PATH)
-      self.all = [] unless self.all.is_a?(Array)
-    end
-    
-    def self.save!
-      load! if self.all.nil?
-      File.open(REPOS_PATH, "w+") do |f|
-        f.write self.all.to_yaml
-      end
-    end
-    
-    def self.all=(value)
-      @@all_repositories = value
-    end
-    
     def self.get(name)
       GitAuth.logger.debug "Getting Repo w/ name: '#{name}'"
       self.all.detect { |r| r.name == name }
     end
     
     def self.create(name, path = name)
-      return false unless self.get(name).nil?
+      return false if name.nil? || path.nil?
+      return false if self.get(name) || self.all.any? { |r| r.path == path } || name !~ NAME_RE || path !~ NAME_RE
       repository = self.new(name, path)
-      if repository.create_repo!
-        self.load!
-        self.all << repository
-        self.save!
-        return true
-      else
-        return false
-      end
+      return false unless repository.create_repo!
+      self.add_item(repository)
+      return true
     end
     
-    attr_accessor :name, :path
+    attr_accessor :name, :path, :permissions
     
     def initialize(name, path, auto_create = false)
       @name, @path = name, path
       @permissions = {}
     end
     
-    def writeable_by(user)
+    def ==(other)
+      other.is_a?(Repo) && other.name == name && other.path == path
+    end
+    
+    def writeable_by(user_or_group)
       @permissions[:write] ||= []
-      @permissions[:write] << user.name
+      @permissions[:write] << user_or_group.to_s
       @permissions[:write].uniq!
     end
     
-    def readable_by(user)
+    def readable_by(user_or_group)
       @permissions[:read] ||= []
-      @permissions[:read] << user.name
+      @permissions[:read] << user_or_group.to_s
       @permissions[:read].uniq!
     end
     
-    def writeable_by?(user)
-      (@permissions[:write] || []).include? user.name
+    def writeable_by?(user_or_group)
+      !(@permissions[:write] || []).detect do |writer|
+        writer = GitAuth.get_user_or_group(writer)
+        writer == user_or_group || (writer.is_a?(Group) && writer.member?(user_or_group, true))
+      end.nil?
     end
     
-    def readable_by?(user)
-      (@permissions[:read] || []).include? user.name
+    def readable_by?(user_or_group)
+      !(@permissions[:read] || []).detect do |reader|
+        reader = GitAuth.get_user_or_group(reader)
+        reader == user_or_group || (reader.is_a?(Group) && reader.member?(user_or_group, true))
+      end.nil?
     end
     
+    def remove_permissions_for(user_or_group)
+      @permissions.each_value do |val|
+        val.reject! { |m| m == user_or_group.to_s }
+      end
+    end
+    
     def real_path
       File.join(GitAuth.settings.base_path, @path)
     end
     
     def create_repo!
+      return false if !self.class.has_git?
       path = self.real_path
       unless File.exist?(path) && File.directory?(path)
         FileUtils.mkdir_p(path)
         output = ""
         Dir.chdir(path) do
           IO.popen("git init --bare") { |f| output << f.read }
         end
         return !!(output =~ /Initialized empty Git repository/)
       end
+    end
+    
+    def destroy!
+      FileUtils.rm_rf(self.real_path) if File.exist?(self.real_path)
+      self.class.all.reject! { |r| r == self }
+      self.class.save!
+    end
+    
+    def self.has_git?
+      !`which git`.strip.empty?
     end
     
   end
 end
\ No newline at end of file