gritano 0.4.1 → 0.5.0

data/lib/gritano.rb

@@ -2,4 +2,4 @@ ROOT_PATH = File.expand_path(File.dirname(__FILE__))
 
 require File.join(ROOT_PATH, '/gritano/models')
 require File.join(ROOT_PATH, '/gritano/console')
-require File.join(ROOT_PATH, '/gritano/command')
+require File.join(ROOT_PATH, '/gritano/cli')

data/lib/gritano/cli.rb

@@ -0,0 +1,33 @@
+module Gritano
+  module CLI
+    def CLI.execute(cmd, stdin = STDIN, home_dir = Etc.getpwuid.dir, repo_dir = Etc.getpwuid.dir)
+      Gritano::Console.remote_console(false)
+      console = Gritano::Console::Gritano.new(stdin, home_dir, repo_dir)
+      begin
+        output = console.execute(cmd)
+        if output[0]
+          output[1]
+        else
+          "error: #{output[1]}"
+        end
+      rescue
+        console.execute(["help"])[1]
+      end
+    end
+    
+    def CLI.check(cmd, login, stdin = STDIN, home_dir = Etc.getpwuid.dir, repo_dir = Etc.getpwuid.dir)
+      Gritano::Console.remote_console(true)
+      console = Gritano::Console::Check.new(stdin, home_dir, repo_dir)
+      begin
+        output = console.execute(cmd + [login])
+        if output[0]
+          output[1]
+        else
+          "error: #{output[1]}"
+        end
+      rescue
+        console.execute(["help"])[1]
+      end
+    end
+  end
+end

data/lib/gritano/console.rb

@@ -1,242 +1,25 @@
-require "terminal-table"
+require File.join(ROOT_PATH, 'gritano/console/base')
+require File.join(ROOT_PATH, 'gritano/console/executor')
+require File.join(ROOT_PATH, 'gritano/console/installer')
+require File.join(ROOT_PATH, 'gritano/console/gritano')
+require File.join(ROOT_PATH, 'gritano/console/check')
 
 module Gritano
-  class Console
-    
-    attr_accessor :repo_path
-    attr_accessor :ssh_path
-    
-    def initialize(stdin)
-      @repo_path = nil
-      @ssh_path = nil
-      @stdin = stdin
-    end
-    
-    def execute(argv)
-      send(argv[0].gsub(':', '_'), argv[1..-1])
-    end
-    
-    def user_list(argv)
-      users = User.all
-      msg = Terminal::Table.new do |t|
-        t << ['user']
-        t << :separator
-        users.each do |user|
-          t.add_row [user.login]
-        end
-      end
-      msg = "there is no user registered" if users.count == 0
-      return [true, msg]
-    end
-    
-    def user_key_list(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]
+  module Console
+    def Console.remote_console(remote)
+      if remote
+        Base.bin_name = "ssh git@host.com admin:"
+        Check.bin_name = "ssh git@host.com "
+        Executor.bin_name = "ssh git@host.com admin:"
+        Gritano.bin_name = "ssh git@host.com admin:"
+        Installer.bin_name = "ssh git@host.com admin:"
       else
-        return [false, "User #{login} is not registered"]
-      end
-    end
-    
-    def user_repo_list(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
-    
-    def user_add(argv)
-      login, = argv
-      user = User.new(login: login)
-      return [true, "User #{login} added."] if user.save
-      return [false, "#{user.errors.full_messages.join(", ")}."]
-    end
-    
-    def user_rm(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
-    
-    def user_key_add(argv)
-      login, key_name, key_file = argv
-      user = User.find_by_login(login)
-      if user
-        key = user.keys.create(name: key_name, key: @stdin.read)
-        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
-    
-    def user_key_rm(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
-    
-    def user_admin_add(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
-    
-    def user_admin_rm(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
-    
-    def repo_list(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
-    
-    def repo_add(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
-    
-    def repo_user_list(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
-    
-    def repo_rm(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
-    
-    def repo_read_add(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
-    
-    def repo_write_add(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
-    
-    def repo_read_rm(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
-    
-    def repo_write_rm(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)
+        Base.bin_name = "gritano "
+        Check.bin_name = "gritano "
+        Executor.bin_name = "gritano "
+        Gritano.bin_name = "gritano "
+        Installer.bin_name = "gritano "
       end
-      return [false, "An error occurred. Permissions was not modified."]
     end
   end
 end

data/lib/gritano/console/base.rb

@@ -0,0 +1,74 @@
+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 `which git` == ""
+          puts "Error: git must be installed on the local system"
+          exit
+        end
+      end
+
+      def before_each_command_filter
+      end
+    end
+  end
+end

data/lib/gritano/console/check.rb

@@ -0,0 +1,83 @@
+module Gritano
+  module Console
+    class Check < 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 = Executor.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, Check.help]
+      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 method_missing(meth, *args, &block)
+        if meth.to_s =~ /^admin/
+          user = ::Gritano::User.find_by_login(args[0][-1])
+          if user.admin?
+            meth = meth.to_s[6..-1]
+            params = args[0][0..-2]
+            @executor.execute([meth] + params)
+          else
+            [false, "access denied"]
+          end
+        elsif meth.to_s =~ /^git-receive-pack/
+          repo, login = args[0]
+          Kernel.exec "git-receive-pack #{repo(repo).full_path}"
+        elsif meth.to_s =~ /^git-upload-pack/
+          repo, login = args[0]
+          Kernel.exec "git-upload-pack #{repo(repo).full_path}"
+        else
+          super
+        end
+      end
+      
+      def repo(repo)
+        repo = repo.gsub("'", '').strip
+        ::Gritano::Repository.find_by_name(repo)
+      end
+      
+    end
+  end
+end