gritano 1.0.0 → 2.0.0

data/lib/gritano/console/executor.rb

@@ -1,298 +0,0 @@
-require "terminal-table"
-require 'io/console'
-
-module Gritano
-  module Console
-    class Executor < Gritano::Console::Base
-
-      def initialize(stdin = STDIN, home_dir = Etc.getpwuid.dir, repo_path = Etc.getpwuid.dir)
-        @stdin = stdin
-        @home_dir = home_dir
-        @repo_path = repo_path
-        @ssh_path = File.join(@home_dir, '.ssh')
-        super(@stdin, @home_dir)
-      end
-
-      before_each_command do
-        check_git
-        check_gritano
-        ActiveRecord::Base.establish_connection(
-          YAML::load(File.open(File.join(@home_dir, '.gritano', 'database.yml'))))
-      end
-    
-      add_command "user:list" do |argv|
-        users = User.all
-        msg = Terminal::Table.new do |t|
-          t << ['user', 'admin']
-          t << :separator
-          users.each do |user|
-            t.add_row [user.login, user.admin]
-          end
-        end
-        msg = "there is no user registered" if users.count == 0
-        return [true, msg]
-      end
-
-      add_command "user:key:list", "username" do |argv|
-        login, = argv
-        user = User.find_by_login(login)
-        if user
-          keys = user.keys
-          msg = Terminal::Table.new do |t|
-            t << ['keys']
-            t << :separator
-            keys.each do |key|
-              t.add_row [key.name]
-            end
-          end
-          msg = "there is no key registered" if keys.count == 0
-          return [true, msg]
-        else
-          return [false, "User #{login} is not registered"]
-        end
-      end
-
-      add_command "user:repo:list", "username" do |argv|
-        login, = argv
-        user = User.find_by_login(login)
-        if user
-          repos = user.repositories
-          msg = Terminal::Table.new do |t|
-            t << ['repositories']
-            t << :separator
-            repos.each do |repo|
-              t.add_row [repo.name]
-            end
-          end
-          msg = "there is no repository registered" if repos.count == 0
-          return [true, msg]
-        else
-          return [false, "User #{login} is not registered"]
-        end
-      end
-
-      add_command "user:add", "username [admin]*" do |argv|
-        login, admin = argv
-        if admin == 'true'
-          admin = true
-        else
-          admin = false
-        end
-        user = User.new(login: login, admin: admin)
-        return [true, "User #{login} added."] if user.save
-        return [false, "#{user.errors.full_messages.join(", ")}."]
-      end
-
-      add_command "user:rm", "username" do |argv|
-        login, = argv
-        user = User.find_by_login(login)
-        if user
-          if user.destroy
-            return [true, "User #{login} removed."] 
-          end
-        end
-        return [false, "User #{login} could not be removed."]
-      end
-
-      add_command "user:key:add", "username keyname < key.pub" do |argv|
-        login, key_name, key_file = argv
-        
-        if File.exist?(File.join(@home_dir, '.gritano', 'config.yml'))
-          Key.config = YAML::load(File.open(File.join(@home_dir, '.gritano', 'config.yml')))
-        end
-        
-        user = User.find_by_login(login)
-        if user
-          begin
-            key_str = "#{@stdin.read.scan(/^ssh-(?:dss|rsa) .* /)[0][0..-2]}"
-          rescue
-            return [false, "Key could not be added."]
-          end
-          key = user.keys.create(name: key_name, key: key_str)
-          if key.valid?
-            File.open(File.join(@ssh_path, 'authorized_keys'), 'w').write(Key.authorized_keys)
-            return [true, "Key added successfully."]
-          end
-        end
-        return [false, "Key could not be added."]
-      end
-
-      add_command "user:key:rm", "username keyname" do |argv|
-        login, key_name = argv
-        key = Key.where(name: key_name).includes(:user).where("users.login" => login).limit(1)[0]
-        if key
-          if key.destroy
-            File.open(File.join(@ssh_path, 'authorized_keys'), 'w').write(Key.authorized_keys)
-            return [true, "Key removed successfully."]
-          end
-        end
-        return [false, "Key could not be removed."]
-      end
-
-      add_command "user:admin:add", "username" do |argv|
-        login, = argv
-        user = User.find_by_login(login)
-        if user
-          user.admin = true
-          if user.save
-            return [true, "Now, user #{login} is an administrator"]
-          end
-        end
-        return [false, "User #{login} could not be modified"]
-      end
-
-      add_command "user:admin:rm", "username" do |argv|
-        login, = argv
-        user = User.find_by_login(login)
-        if user
-          user.admin = false
-          if user.save
-            return [true, "Now, user #{login} is not an administrator"]
-          end
-        end
-        return [false, "User #{login} could not be modified"]
-      end
-
-      add_command "user:admin", "username" do |argv|
-        login, = argv
-        user = User.find_by_login(login)
-        if user
-          return [true, user.admin]
-        end
-        return [false, "User #{login} does not exist"]
-      end
-
-      add_command "repo:list" do |argv|
-        repos = Repository.all
-        msg = Terminal::Table.new do |t|
-          t << ['repositories']
-          t << :separator
-          repos.each do |repo|
-            t.add_row [repo.name]
-          end
-        end
-        msg = "there is no repository registered" if repos.count == 0
-        return [true, msg]
-      end
-
-      add_command "repo:add", "reponame.git [username1 username2 ...]*" do |argv|
-        name, user_login = argv
-        repo = Repository.new(name: name, path: @repo_path)
-        if repo.save
-          if user_login
-            argv[1..-1].each do |login|
-              user = User.find_by_login(login)
-              if user
-                user.add_access(repo, :read)
-                user.add_access(repo, :write)
-              end
-            end
-          end
-          return [true, "Repository #{name} created successfully."]
-        end
-        return [false, "Repository #{name} could not be created."]
-      end
-
-      add_command "repo:user:list", "reponame.git" do |argv|
-        name, = argv
-        repo = Repository.find_by_name(name)
-        if repo
-          users = repo.users
-          msg = Terminal::Table.new do |t|
-            t << ['user', 'permission']
-            t << :separator
-            users.each do |user|
-              permissions = ""
-              user.permissions.find_by_repository_id(repo.id) do |p|
-                permissions += "r" if p.is(:read)
-                permissions += "w" if p.is(:write)
-              end
-              t.add_row [user.login, permissions]
-            end
-          end
-          msg = "No user have access to this repository" if users.count == 0
-          return [true, msg]
-        end
-        return [false, "Repository #{name} doesn't exist."]
-      end
-
-      add_command "repo:rm", "reponame.git" do |argv|
-        name, = argv
-        repo = Repository.find_by_name(name)
-        if repo
-          if repo.destroy
-            return [true, "Repository #{name} removed successfully."]
-          end
-        end
-        return [false, "Repository #{name} could not be removed."]
-      end
-
-      add_command "repo:read:add", "reponame.git username" do |argv|
-        repo_name, login = argv
-        user = User.find_by_login(login)
-        repo = Repository.find_by_name(repo_name)
-        if repo and user
-          return [true, "User #{login} has read access to #{repo_name}."] if user.add_access(repo, :read)
-        end
-        return [false, "An error occurred. Permissions was not modified."]
-      end
-
-      add_command "repo:write:add", "reponame.git username" do |argv|
-        repo_name, login = argv
-        user = User.find_by_login(login)
-        repo = Repository.find_by_name(repo_name)
-        if repo and user
-          return [true, "User #{login} has write access to #{repo_name}."] if user.add_access(repo, :write)
-        end
-        return [false, "An error occurred. Permissions was not modified."]
-      end
-
-      add_command "repo:read:rm", "reponame.git username" do |argv|
-        repo_name, login = argv
-        user = User.find_by_login(login)
-        repo = Repository.find_by_name(repo_name)
-        if repo and user
-          return [true, "User #{login} has not read access to #{repo_name}."] if user.remove_access(repo, :read)
-        end
-        return [false, "An error occurred. Permissions was not modified."]
-      end
-
-      add_command "repo:write:rm", "reponame.git username" do |argv|
-        repo_name, login = argv
-        user = User.find_by_login(login)
-        repo = Repository.find_by_name(repo_name)
-        if repo and user
-          return [true, "User #{login} has not write access to #{repo_name}."] if user.remove_access(repo, :write)
-        end
-        return [false, "An error occurred. Permissions was not modified."]
-      end
-
-      add_command "config:host_url:set", "url" do |argv|
-        url, = argv
-        config = Config.new(File.join(@home_dir, '.gritano', 'config.yml'))
-        config.host_url = url
-        config.save
-        return [true, "done!"]
-      end
-
-      add_command "config:host_url:get" do |argv|
-        config = Config.new(File.join(@home_dir, '.gritano', 'config.yml'))
-        return [true, config.host_url]
-      end
-
-      add_command "config:ssh_user:set", "user" do |argv|
-        user, = argv
-        config = Config.new(File.join(@home_dir, '.gritano', 'config.yml'))
-        config.ssh_user = user
-        config.save
-        return [true, "done!"]
-      end
-
-      add_command "config:ssh_user:get" do |argv|
-        config = Config.new(File.join(@home_dir, '.gritano', 'config.yml'))
-        return [true, config.ssh_user]
-      end
-      
-    end
-  end
-end

data/lib/gritano/console/gritano.rb

@@ -1,35 +0,0 @@
-module Gritano
-  module Console
-    class Gritano < Gritano::Console::Base
-
-      def initialize(stdin = STDIN, home_dir = Etc.getpwuid.dir, repo_path = Etc.getpwuid.dir)
-        @stdin = stdin
-        @home_dir = home_dir
-        @repo_path = repo_path
-        @ssh_path = File.join(@home_dir, '.ssh')
-        super(@stdin, @home_dir)
-      end
-
-      add_command "help" do |argv|
-        Gritano.commands = Gritano.commands.merge(Installer.commands).merge(Executor.commands)
-        [true, Gritano.help]
-      end
-
-      add_command "version" do |argv|
-        version = "v#{File.open(File.join(File.dirname(__FILE__), '..', '..', '..', 'VERSION')).readlines.join}"
-        [true, version]
-      end
-
-      def method_missing(meth, *args, &block)
-        params = [meth.to_s.gsub("_", ":")] + args[0]
-        begin
-          installer = Installer.new(@stdin, @home_dir)
-          installer.execute(params)
-        rescue
-          executor = Executor.new(@stdin, @home_dir, @repo_path)
-          executor.execute(params)
-        end
-      end
-    end
-  end
-end

data/lib/gritano/console/installer.rb

@@ -1,55 +0,0 @@
-module Gritano
-  module Console
-    class Installer < Gritano::Console::Base
-
-      def initialize(stdin = STDIN, home_dir = Etc.getpwuid.dir)
-        @home_dir = home_dir
-        @stdin = stdin
-        @ssh_path = File.join(@home_dir, '.ssh')
-        super(@stdin, @home_dir)
-      end
-
-      before_each_command do
-        check_git
-      end
-
-      def create_gritano_dirs
-        FileUtils.mkdir_p(File.join(@home_dir, '.gritano')) unless File.exist?(File.join(@home_dir, '.gritano'))
-        FileUtils.mkdir_p(File.join(@home_dir, '.ssh')) unless File.exist?(File.join(@home_dir, '.ssh'))
-      end
-      
-      def create_sqlite_config
-        File.open(File.join(@home_dir, '.gritano', 'database.yml'), "w") do |f|
-          f.write("adapter: sqlite3\ndatabase: #{File.join(@home_dir, '.gritano', 'database.db')}\n")
-        end
-        if File.exist?(File.join(@home_dir, '.gritano', 'database.db'))
-          FileUtils.rm(File.join(@home_dir, '.gritano', 'database.db'))
-        end
-      end
-      
-      add_command "setup:prepare" do |argv|
-        create_gritano_dirs
-        create_sqlite_config
-        return [true, "Gritano's configuration has been generated.\nIf you want to customize it, check your '#{File.join(@home_dir, '.gritano')}' directory."]
-      end
-
-      def create_database
-        db_config = YAML::load(File.open(File.join(@home_dir, '.gritano', 'database.yml')))
-        ActiveRecord::Base.establish_connection(db_config)
-        ActiveRecord::Migrator.migrate(
-          File.join(File.dirname(__FILE__),'..', '..', '..', 'db/migrate'), 
-          ENV["VERSION"] ? ENV["VERSION"].to_i : nil )
-      end
-      
-      def create_authorization_keys
-        File.open(File.join(@ssh_path, 'authorized_keys'), 'w').write(Key.authorized_keys)
-      end
-      
-      add_command "setup:install" do |argv|
-        create_database
-        create_authorization_keys
-        [true, "gritano has been installed"]
-      end
-    end
-  end
-end

data/lib/gritano/models.rb

@@ -1,7 +0,0 @@
-require 'active_record'
-require 'grit'
-
-require File.join(ROOT_PATH, 'gritano/models/user')
-require File.join(ROOT_PATH, 'gritano/models/repository')
-require File.join(ROOT_PATH, 'gritano/models/permission')
-require File.join(ROOT_PATH, 'gritano/models/key')

data/lib/gritano/models/key.rb

@@ -1,37 +0,0 @@
-module Gritano
-  class Key < ActiveRecord::Base
-    
-    validates :name, :key, presence: true
-    validates :name, :uniqueness => { :scope => :user_id, :message => "should happen once per user" }
-
-    belongs_to :user
-
-    def self.config=(cfg)
-      @config = cfg
-    end
-
-    def self.authorized_keys
-      if @config
-        unless @config['ssh']
-          return generate_authorized_keys
-        end
-      else
-        return generate_authorized_keys
-      end
-      return ""
-    end
-    
-    def self.generate_authorized_keys
-      authorized_keys = ""
-      keys = Key.find(:all)
-      keys.each do |k|
-        user_key = k.key
-        unless k.key[-1] == "\n"
-          user_key = user_key + "\n"
-        end
-        authorized_keys += "command=\"gritano-remote #{k.user.login}\" #{user_key}\n"
-      end
-      return authorized_keys
-    end
-  end
-end

data/lib/gritano/models/permission.rb

@@ -1,39 +0,0 @@
-module Gritano
-  class Permission < ActiveRecord::Base
-    belongs_to :user
-    belongs_to :repository
-    
-    READ = 1
-    WRITE = 2
-    
-    def add_access(access)
-      if access == :read
-        self.access = READ | (self.access || 0)
-      elsif access == :write
-        self.access = WRITE | (self.access || 0)
-      else
-        return false
-      end
-      return true
-    end
-    
-    def remove_access(access)
-      if access == :read
-        self.access = (self.access || 0) & (~ READ)
-      elsif access == :write
-        self.access = (self.access || 0) & (~ WRITE)
-      else
-        return false
-      end
-      return true
-    end
-    
-    def is(access)
-      if access == :read
-        return (self.access & READ) == READ
-      elsif access == :write
-        return (self.access & WRITE) == WRITE
-      end
-    end
-  end
-end