gritano 1.0.0 → 2.0.0

data/lib/gritano.rb

@@ -1,8 +1,14 @@
-ROOT_PATH = File.expand_path(File.dirname(__FILE__))
+root_path = File.expand_path(File.dirname(__FILE__))
 
-require "fileutils"
+require "gritano-core"
+require 'terminal-table'
 
-require File.join(ROOT_PATH, '/gritano/models')
-require File.join(ROOT_PATH, '/gritano/console')
-require File.join(ROOT_PATH, '/gritano/cli')
-require File.join(ROOT_PATH, '/gritano/config')
+require File.join(root_path, 'gritano/thor')
+require File.join(root_path, 'gritano/renderer')
+require File.join(root_path, 'gritano/helpers')
+require File.join(root_path, 'gritano/console/remote')
+require File.join(root_path, 'gritano/console/local')
+require File.join(root_path, 'gritano/console/git')
+require File.join(root_path, 'gritano/config')
+require File.join(root_path, 'gritano/core/user')
+require File.join(root_path, 'gritano/core/key')

data/lib/gritano/config.rb

@@ -1,38 +1,18 @@
 module Gritano
-  class Config
-    def initialize(config_file)
-      @config_file = config_file
-      load
+  module CLI
+    def CLI.configure(&block)
+      Config.database_connection = File.open(File.join(Etc.getpwuid.dir, '.gritano/database.yml'))
+      Config.repository_path = File.join(Etc.getpwuid.dir)
+      Config.remote_ssh_prefix = 'ssh git@server.com'
+      yield Config
     end
 
-    def load
-      unless File.exist?(@config_file)
-        File.open(@config_file, "w").close
-      end
-      @config = YAML::load(File.open(@config_file))
-      unless @config
-        @config = Hash.new
-      end
-    end
-
-    def remove(parameter)
-      @config.delete(parameter.to_s)
-    end
-
-    def save
-      File.open(@config_file, "w") do |f|
-        f.write(@config.to_yaml)
-      end
-    end
-
-    def method_missing(name, *args, &block)
-      if name[-1] == '='
-        @config[name.to_s[0..-2]] = args[0]
-      else
-        if @config[name.to_s]
-          @config[name.to_s]
+    class Config
+      def self.method_missing(method, *args)
+        if /\=$/.match(method)
+          instance_variable_set("@#{method.to_s.gsub("=", "")}", args[0])
         else
-          "undefined"
+          instance_variable_get("@#{method}")
         end
       end
     end

data/lib/gritano/console/base.rb

@@ -1,78 +1,10 @@
-require "terminal-table"
-
 module Gritano
-  module Console
-    class Base
-
-      def initialize(stdin = STDIN, home_dir = Etc.getpwuid.dir)
-        @home_dir = home_dir
-        @stdin = stdin
-      end
-
-      def self.add_command(command, parameters = "", &block)
-        define_method(command.gsub(':', '_'), &block)
-        commands[command] = parameters
-      end
-
-      def self.before_each_command(&block)
-        define_method(:before_each_command_filter, &block);
-      end
-
-      def self.commands
-        @commands || @commands = Hash.new
-      end
-
-      def self.commands=(cmds)
-        @commands = cmds
-      end
-
-      def self.bin_name
-        @bin_name || "gritano "
-      end
-
-      def self.bin_name=(name)
-        @bin_name = name
-      end
-
-      def self.help
-        msg = "  #{self.bin_name}[command]\n\n"
-        msg += "  Examples:\n"
-        commands.each do |command, parameters|
-          msg += "  #{self.bin_name}#{command} #{parameters}\n"
-        end
-        msg += "\n  --\n  v#{File.open(File.join(File.dirname(__FILE__), '..', '..', '..', 'VERSION')).readlines.join}"
-        msg
-      end
-
-      def execute_without_filters(argv)
-        send(argv[0].gsub(':', '_'), argv[1..-1])
-      end
-
-      def execute(argv)
-        send(:before_each_command_filter)
-        execute_without_filters(argv)
-      end
-
-      def check_gritano
-        unless File.exist?(File.join(@home_dir, '.gritano'))
-          puts "Error: First run 'gritano setup:prepare && gritano setup:install'"
-          exit
-        end
-      end
-
-      def check_git
-        if unknown_command('git')
-          puts "Error: git must be installed on the local system"
-          exit
-        end
-      end
-      
-      def unknown_command(command)
-        `which #{command}` == ""
-      end
-
-      def before_each_command_filter
+  module CLI
+    module Console
+      class Base < Thor
+        include Gritano::CLI::Renderer
+        include Gritano::CLI::Helpers
       end
     end
   end
-end
+end

data/lib/gritano/console/git.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), 'base')
+
+module Gritano
+  module CLI
+    module Console
+      class Git < Base
+        before %w{ git:receive:pack
+                   git:upload:pack
+                } do
+          ActiveRecord::Base.establish_connection(YAML::load(Config.database_connection))
+        end
+
+        define_task("git:receive:pack", "") do |repo_name|
+          use_if_not_nil Gritano::Core::User.where(login: Config.remote_user).first do |user|
+            repo = Gritano::Core::Repository.where(name: repo_name.gsub("'", "")).first
+            Kernel.exec "git-receive-pack '#{repo.full_path}'" if user.check_access(repo, :write)
+          end
+        end
+
+        define_task("git:upload:pack", "") do |repo_name|
+          use_if_not_nil Gritano::Core::User.where(login: Config.remote_user).first do |user|
+            repo = Gritano::Core::Repository.where(name: repo_name.gsub("'", "")).first
+            Kernel.exec "git-upload-pack '#{repo.full_path}'" if user.check_access(repo, :read)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gritano/console/local.rb

@@ -0,0 +1,131 @@
+require File.join(File.dirname(__FILE__), 'base')
+
+module Gritano
+  module CLI
+    module Console
+      class Local < Base
+
+        before %w{ user:list user:add user:rm user:update 
+                   user:key:list user:key:add user:key:rm
+                   repo:list repo:add repo:rm 
+                   repo:read:add repo:read:rm
+                   repo:write:add repo:write:rm
+                   repo:user:list
+                } do
+          ActiveRecord::Base.establish_connection(YAML::load(Config.database_connection)) unless ActiveRecord::Base.connected?
+        end
+
+        define_task("init", "create a .gritano folder in your home directory which will store gritano configuration files.") do
+          unless File.exist? File.join(Etc.getpwuid.dir, '.gritano')
+            create_gritano_dirs
+            create_database_config_file
+            create_command_scripts
+            render_text "config files were successfully created."
+          end
+        end
+
+        define_task("db:migrate", "create database tables") do
+          Gritano::Core::Migration.migrate(YAML::load(File.open(File.join(Etc.getpwuid.dir, '.gritano/database.yml'))))
+          render_text "done!"
+        end
+
+        define_task("user:list", "list all gritano users") do
+          render_table(Gritano::Core::User.order(:login), :login, :admin)
+        end
+
+        define_task("user:add", "add a gritano user") do |login|
+          create_model(Gritano::Core::User, login: login)
+        end
+
+        define_task("user:rm", "remove a gritano user") do |login|
+          destroy_model(Gritano::Core::User, login: login)
+        end
+
+        method_option :admin, :aliases => "-a", :desc => "change admin status of a user"
+        define_task("user:update", "update user information") do |login|
+          use_if_not_nil Gritano::Core::User.where(login: login).first, valid_options?(options) do |user|
+            update_model(user, options)
+          end
+        end
+
+        define_task("user:key:list", "list all user's keys") do |login|
+          use_if_not_nil Gritano::Core::User.where(login: login).first do |user|
+            render_table(user.keys.order(:name), :name)
+          end
+        end
+
+        define_task("user:key:add", "add a user's key") do |login, key_name|
+          use_if_not_nil Gritano::Core::User.where(login: login).first do |user|
+            create_model(user.keys, name: key_name, key: $stdin.readlines.join)
+          end
+        end
+
+        define_task("user:key:rm", "remove a user's key") do |login, key_name|
+          use_if_not_nil Gritano::Core::User.where(login: login).first do |user|
+            destroy_model(user.keys, name: key_name)
+          end
+        end
+
+        define_task("repo:list", "list all repositories") do
+          render_table(Gritano::Core::Repository.order(:name), :name)
+        end
+
+        define_task("repo:add", "add a new repository") do |name|
+          create_model(Gritano::Core::Repository, name: name, path: Config.repository_path)
+        end
+
+        define_task("repo:rm", "remove a repository") do |name|
+          destroy_model(Gritano::Core::Repository, name: name)
+        end
+
+        define_task("repo:read:add", "add read access to a repository") do |repo_name, user_login|
+          use_if_not_nil Gritano::Core::User.where(login: user_login).first, Gritano::Core::Repository.where(name: repo_name).first do |user, repo|
+            try_change_access(user, repo, :add, :read)
+          end
+        end
+
+        define_task("repo:read:rm", "remove read access to a repository") do |repo_name, user_login|
+          use_if_not_nil Gritano::Core::User.where(login: user_login).first, Gritano::Core::Repository.where(name: repo_name).first do |user, repo|
+            try_change_access(user, repo, :remove, :read)
+          end
+        end
+
+        define_task("repo:write:add", "add write access to a repository") do |repo_name, user_login|
+          use_if_not_nil Gritano::Core::User.where(login: user_login).first, Gritano::Core::Repository.where(name: repo_name).first do |user, repo|
+            try_change_access(user, repo, :add, :write)
+          end
+        end
+
+        define_task("repo:write:rm", "remove write access to a repository") do |repo_name, user_login|
+          use_if_not_nil Gritano::Core::User.where(login: user_login).first, Gritano::Core::Repository.where(name: repo_name).first do |user, repo|
+            try_change_access(user, repo, :remove, :write)
+          end
+        end
+
+        define_task("repo:user:list", "list all user that have access to a repository") do |repo_name|
+          use_if_not_nil Gritano::Core::Repository.where(name: repo_name).first do |repo|
+            render_table(repo.users.order(:login), :login, :access => repo)
+          end
+        end
+
+        private
+        def create_gritano_dirs
+          Dir.mkdir(File.join(Etc.getpwuid.dir, '.gritano')) unless File.exist? File.join(Etc.getpwuid.dir, '.gritano')
+          Dir.mkdir(File.join(Etc.getpwuid.dir, '.ssh')) unless File.exist? File.join(Etc.getpwuid.dir, '.ssh')
+        end
+
+        def create_database_config_file
+          File.open(File.join(Etc.getpwuid.dir, '.gritano/database.yml'), "w").write(
+              {'adapter' => 'sqlite3', 'database' => File.join(Etc.getpwuid.dir, '.gritano/database.sqlite3')}.to_yaml)
+        end
+
+        def create_command_scripts
+          File.open(File.join(Etc.getpwuid.dir, '.gritano/local.gritano'), "w").write(
+              File.open(File.join(File.dirname(__FILE__), '../../../templates/local.gritano')).readlines.join)
+          File.open(File.join(Etc.getpwuid.dir, '.gritano/remote.gritano'), "w").write(
+              File.open(File.join(File.dirname(__FILE__), '../../../templates/remote.gritano')).readlines.join)
+        end
+      end
+    end
+  end
+end

data/lib/gritano/console/remote.rb

@@ -1,104 +1,58 @@
+require File.join(File.dirname(__FILE__), 'base')
+
 module Gritano
-  module Console
-    class Remote < Base
+  module CLI
+    module Console
+      class Remote < 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')
-        @executor = Gritano.new(@stdin, @home_dir, @repo_path)
-        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 "version" do |argv|
-        version = "v#{File.open(File.join(File.dirname(__FILE__), '..', '..', '..', 'VERSION')).readlines.join}"
-        [true, version]
-      end
-      
-      add_command "help" do |args|
-        [true, Remote.help]
-      end
+        def self.basename
+          Gritano::CLI::Config.remote_ssh_prefix
+        end
 
-      add_command "username" do |args|
-        login, = args
-        [true, login]
-      end
-      
-      add_command "repo:list" do |args|
-        login, = args
-        @executor.execute(["user:repo:list"] + [login])
-      end
-      
-      add_command "key:list" do |args|
-        login, = args
-        @executor.execute(["user:key:list"] + [login])
-      end
-      
-      add_command "key:add", "keyname < key.pub" do |args|
-        keyname, login = args
-        @executor.execute(["user:key:add"] + [login, keyname])
-      end
-      
-      add_command "key:rm", "keyname" do |args|
-        keyname, login = args
-        @executor.execute(["user:key:rm"] + [login, keyname])
-      end
-      
-      add_command "admin:help" do |args|
-        gritano = Gritano.new(@stdin)
-        gritano.execute(["help"])
-      end
-      
-      def admin_command(meth, params)
-        @executor.execute([meth] + params)
-      end
-      
-      def git_receive_pack(repo, login)
-        user = ::Gritano::User.find_by_login(login)
-        if user
-          Kernel.exec "git-receive-pack #{repo(repo).full_path}" if user.check_access(repo(repo), :read)
+        before %w{ repo:list
+                   key:list key:add key:rm
+                   admin
+                } do
+          ActiveRecord::Base.establish_connection(YAML::load(Config.database_connection)) unless ActiveRecord::Base.connected?
         end
-      end
       
-      def git_upload_pack(repo, login)
-        user = ::Gritano::User.find_by_login(login)
-        if user
-          Kernel.exec "git-upload-pack #{repo(repo).full_path}" if user.check_access(repo(repo), :write)
+        define_task("repo:list", "list all repositories") do
+          use_if_not_nil Gritano::Core::User.where(login: Config.remote_user).first do |user|
+            render_table(user.repositories.order(:name), :name)
+          end
         end
-      end
-      
-      def method_missing(meth, *args, &block)
-        if meth.to_s =~ /^admin/
-          user = ::Gritano::User.find_by_login(args[0][-1])
-          if user.admin?
-            admin_command(meth.to_s[6..-1], args[0][0..-2])
-          else
-            [false, "access denied"]
+
+        define_task("key:list", "list all your keys") do
+          use_if_not_nil Gritano::Core::User.where(login: Config.remote_user).first do |user|
+            render_table(user.keys.order(:name), :name)
+          end
+        end
+
+        define_task("key:add", "add a key") do |key_name|
+          use_if_not_nil Gritano::Core::User.where(login: Config.remote_user).first do |user|
+            create_model(user.keys, name: key_name, key: $stdin.readlines.join)
+          end
+        end
+
+        define_task("key:rm", "remove a user's key") do |key_name|
+          use_if_not_nil Gritano::Core::User.where(login: Config.remote_user).first do |user|
+            destroy_model(user.keys, name: key_name)
+          end
+        end
+
+        define_task("admin", "execute admin commands") do |*command|
+          use_if_not_nil Gritano::Core::User.where(login: Config.remote_user).first do |user|
+            if user.admin?
+              def Local.basename
+                "#{Remote.basename} admin"
+              end
+              Local.start(command)
+            else
+              render_text "you are not an admin!"
+            end
           end
-        elsif meth.to_s =~ /^git-receive-pack/
-          repo, login = args[0]
-          git_receive_pack(repo, login)
-        elsif meth.to_s =~ /^git-upload-pack/
-          repo, login = args[0]
-          git_upload_pack(repo, login)
-        else
-          super
         end
       end
-      
-      def repo(repo)
-        repo = repo.gsub("'", '').strip
-        ::Gritano::Repository.find_by_name(repo)
-      end
-      
     end
   end
-end
+end