gritano 1.0.0 → 2.0.0

data/lib/gritano/core/key.rb

@@ -0,0 +1,18 @@
+module Gritano
+  module Core
+    class Key
+      after_create :update_authorized_keys
+
+      def update_authorized_keys
+        authorized_keys = File.join(Etc.getpwuid.dir, '.ssh/authorized_keys')
+        File.open(authorized_keys, "w").write(Key.authorized_keys)
+      end
+
+      def self.authorized_keys
+        Key.all.map do |key|
+          "command=\"gritano-remote #{key.user.login}\" #{key.key}"
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/gritano/core/user.rb

@@ -0,0 +1,12 @@
+module Gritano
+  module Core
+    class User
+      def access(repo)
+        access = []
+        access << 'read' if check_access(repo, :read)
+        access << 'write' if check_access(repo, :write)
+        "#{access.join('+')}"
+      end
+    end
+  end
+end

data/lib/gritano/helpers.rb

@@ -0,0 +1,52 @@
+module Gritano
+  module CLI
+    module Helpers
+      def create_model(model, params)
+        instance = model.new(params)
+        if instance.save
+          render_text "#{model.name.split(':')[-1].downcase} was successfully created."
+        else
+          render_text "an error occurred."
+        end
+      end
+
+      def update_model(instance, params)
+        if instance.update_attributes(params)
+          render_text "#{instance.class.name.split(':')[-1].downcase} was successfully updated."
+        else
+          render_text "an error occurred."
+        end
+      end
+
+      def destroy_model(model, params)
+        instance = model.where(params).first
+        if instance
+          instance.destroy
+          render_text "#{model.name.split(':')[-1].downcase} was successfully destroyed."
+        else
+          render_text "#{model.name.split(':')[-1].downcase} doens't exist."
+        end
+      end
+
+      def use_if_not_nil(*variables, &block)
+        unless variables.index(nil)
+          block.call(*variables)
+        else
+          render_text "an error occurred"
+        end
+      end
+
+      def try_change_access(user, repo, add_or_rm, read_or_write)
+        if user.send("#{add_or_rm}_access", repo, read_or_write)
+          render_text "done"
+        else
+          render_text "an error occurred"
+        end
+      end
+
+      def valid_options?(options)
+        true unless options.empty?
+      end
+    end
+  end
+end

data/lib/gritano/renderer.rb

@@ -0,0 +1,36 @@
+module Gritano
+  module CLI
+    module Renderer
+      def render_text(text)
+        puts text
+      end
+
+      def render_table(elements, *attributes)
+        attributes_hash = {}
+        attributes.each do |a|
+          if a.respond_to?(:keys)
+            attributes_hash = attributes_hash.merge(a)
+          else
+            attributes_hash[a] = nil
+          end
+        end
+        table = Terminal::Table.new do |t|
+          t << attributes_hash.map { |key, value| key }
+          t << :separator
+          elements.each do |element|
+            row = []
+            attributes_hash.each do |attribute, params|
+              if params
+                row << element.send(attribute, params)
+              else
+                row << element.send(attribute)
+              end
+            end
+            t.add_row row
+          end
+        end
+        render_text table
+      end
+    end
+  end
+end

data/lib/gritano/thor.rb

@@ -0,0 +1,27 @@
+require 'thor'
+
+module Gritano
+  module CLI
+    class Thor < Thor
+      def self.define_task(name, description="", &block)
+        params = block.parameters.map { |type, name| name.upcase }.join(' ')
+        desc("#{name} #{params}".rstrip, description)
+        bf = before_filters
+        define_method(name.to_sym) do |*params|
+          instance_eval(&bf[name]) if bf[name]
+          instance_exec(*params, &block)
+        end
+      end
+
+      def self.before(methods, &block)
+        methods.each do |method|
+          before_filters[method] = block
+        end
+      end
+
+      def self.before_filters
+        @before_filters ||= {}
+      end
+    end
+  end
+end

data/spec/data/development.yml

@@ -0,0 +1,2 @@
+adapter: sqlite3
+database: tmp/development.sqlite3

data/spec/gritano/console/git_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+module Gritano::CLI::Console
+  describe Git do
+    before(:each) do
+      $stdout.stub(:puts)
+      $stdin.stub(:readlines).and_return(['some pubkey'])
+      ActiveRecord::Base.stub(:establish_connection)
+      YAML.stub(:load)
+      Gritano::CLI::Config.remote_user = 'user_login'
+    end
+
+    it "should execute git-receive-pack if the user has write access" do
+      user = double('User')
+      repo = double('Repository')
+      Gritano::Core::User.should_receive(:where).with(login: 'user_login').and_return([user])
+      Gritano::Core::Repository.should_receive(:where).with(name: 'repo.git').and_return([repo])
+      user.should_receive(:check_access).with(repo, :write).and_return(true)
+      repo.should_receive(:full_path).and_return('folder/repo.git')
+      Kernel.should_receive(:exec).with("git-receive-pack 'folder/repo.git'")
+      Gritano::CLI::Console::Git.start %w{git:receive:pack repo.git}
+    end
+
+    it "should not execute git-receive-pack if the user has not write access" do
+      user = double('User')
+      repo = double('Repository')
+      Gritano::Core::User.should_receive(:where).with(login: 'user_login').and_return([user])
+      Gritano::Core::Repository.should_receive(:where).with(name: 'repo.git').and_return([repo])
+      user.should_receive(:check_access).with(repo, :write).and_return(false)
+      Kernel.should_not_receive(:exec).with("git-receive-pack 'folder/repo.git'")
+      Gritano::CLI::Console::Git.start %w{git:receive:pack repo.git}
+    end
+
+    it "should execute git-upload-pack if the user has read access" do
+      user = double('User')
+      repo = double('Repository')
+      Gritano::Core::User.should_receive(:where).with(login: 'user_login').and_return([user])
+      Gritano::Core::Repository.should_receive(:where).with(name: 'repo.git').and_return([repo])
+      user.should_receive(:check_access).with(repo, :read).and_return(true)
+      repo.should_receive(:full_path).and_return('folder/repo.git')
+      Kernel.should_receive(:exec).with("git-upload-pack 'folder/repo.git'")
+      Gritano::CLI::Console::Git.start %w{git:upload:pack repo.git}
+    end
+
+    it "should not execute git-upload-pack if the user has not read access" do
+      user = double('User')
+      repo = double('Repository')
+      Gritano::Core::User.should_receive(:where).with(login: 'user_login').and_return([user])
+      Gritano::Core::Repository.should_receive(:where).with(name: 'repo.git').and_return([repo])
+      user.should_receive(:check_access).with(repo, :read).and_return(false)
+      Kernel.should_not_receive(:exec).with("git-upload-pack 'folder/repo.git'")
+      Gritano::CLI::Console::Git.start %w{git:upload:pack repo.git}
+    end
+  end
+end

data/spec/gritano/console/local_spec.rb

@@ -0,0 +1,148 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+module Gritano::CLI::Console
+  describe Local do
+
+    before(:each) do
+      $stdout.stub(:puts)
+      $stdin.stub(:readlines).and_return(['some pubkey'])
+      ActiveRecord::Base.stub(:establish_connection)
+      YAML.stub(:load)
+    end
+
+    describe "#user" do
+      it "should list all users ordered by login" do
+        Gritano::Core::User.should_receive(:order).with(:login).and_return([])
+        Gritano::CLI::Console::Local.start %w{user:list}
+      end
+
+      it "should add a user" do
+        user = double("User")
+        user.should_receive(:save).and_return(true)
+        Gritano::Core::User.should_receive(:new).with(login: 'user_login').and_return(user)
+        Gritano::CLI::Console::Local.start %w{user:add user_login}
+      end
+
+      it "should remove an existing user" do
+        user = double("User")
+        user.should_receive(:destroy)
+        Gritano::Core::User.should_receive(:where).with(login: 'user_login').and_return([user])
+        Gritano::CLI::Console::Local.start %w{user:rm user_login}
+      end
+
+      it "should update the admin attribute of an existing user" do
+        user = double("User")
+        user.should_receive(:update_attributes).with({"admin" => "true"})
+        Gritano::Core::User.should_receive(:where).with(login: 'user_login').and_return([user])
+        Gritano::CLI::Console::Local.start %w{user:update user_login --admin=true}
+      end
+
+      describe "#keys" do
+        it "should list user's keys ordered by name" do
+          user = double("User")
+          keys = double("Key")
+          keys.stub(:count).and_return(10)
+          keys.stub(:each)
+          Gritano::Core::User.should_receive(:where).with(login: 'user_login').and_return([user])
+          user.should_receive(:keys).and_return(keys)
+          keys.should_receive(:order).with(:name).and_return(keys)
+          Gritano::CLI::Console::Local.start %w{user:key:list user_login}
+        end
+
+        it "should add user's key" do
+          user = double("User")
+          keys = double("Key")
+          keys.stub(:name).and_return("Key")
+          key = double("Key")
+          Gritano::Core::User.should_receive(:where).with(login: 'user_login').and_return([user])
+          user.should_receive(:keys).and_return(keys)
+          keys.should_receive(:new).with(name: 'user_key', key: 'some pubkey').and_return(key)
+          key.should_receive(:save).and_return(true)
+          Gritano::CLI::Console::Local.start %w{user:key:add user_login user_key}
+        end
+
+        it "should remove user's key" do
+          user = double("User")
+          keys = [double("Key")]
+          keys.stub(:name).and_return("Key")
+          key = double("Key")
+          Gritano::Core::User.should_receive(:where).with(login: 'user_login').and_return([user])
+          user.should_receive(:keys).and_return(keys)
+          keys.should_receive(:where).with(name: 'user_key').and_return([key])
+          key.should_receive(:destroy)
+          Gritano::CLI::Console::Local.start %w{user:key:rm user_login user_key}
+        end
+      end
+    end
+
+    describe "#repo" do
+      it "should list repositories ordered by name" do
+        Gritano::Core::Repository.should_receive(:order).with(:name).and_return([])
+        Gritano::CLI::Console::Local.start %w{repo:list}
+      end
+
+      it "should add a new repository" do
+        repo = double("Repository")
+        repo.should_receive(:save).and_return(true)
+        Gritano::CLI::Config.repository_path = "tmp"
+        Gritano::Core::Repository.should_receive(:new).with(name: 'repo.git', path: 'tmp').and_return(repo)
+        Gritano::CLI::Console::Local.start %w{repo:add repo.git}
+      end
+
+      it "should remove a existing repository" do
+        repo = double("Repository")
+        repo.should_receive(:destroy)
+        Gritano::Core::Repository.should_receive(:where).with(name: 'repo.git').and_return([repo])
+        Gritano::CLI::Console::Local.start %w{repo:rm repo.git}
+      end
+
+      it "should add read access to a repository" do
+        repo = double("Repository")
+        user = double("User")
+        Gritano::Core::Repository.should_receive(:where).with(name: 'repo.git').and_return([repo])
+        Gritano::Core::User.should_receive(:where).with(login: 'user_login').and_return([user])
+        user.should_receive(:add_access).with(repo, :read).and_return(true)
+        Gritano::CLI::Console::Local.start %w{repo:read:add repo.git user_login}
+      end
+
+      it "should remove read access from a repository" do
+        repo = double("Repository")
+        user = double("User")
+        Gritano::Core::Repository.should_receive(:where).with(name: 'repo.git').and_return([repo])
+        Gritano::Core::User.should_receive(:where).with(login: 'user_login').and_return([user])
+        user.should_receive(:remove_access).with(repo, :read).and_return(true)
+        Gritano::CLI::Console::Local.start %w{repo:read:rm repo.git user_login}
+      end
+
+      it "should add write access to a repository" do
+        repo = double("Repository")
+        user = double("User")
+        Gritano::Core::Repository.should_receive(:where).with(name: 'repo.git').and_return([repo])
+        Gritano::Core::User.should_receive(:where).with(login: 'user_login').and_return([user])
+        user.should_receive(:add_access).with(repo, :write).and_return(true)
+        Gritano::CLI::Console::Local.start %w{repo:write:add repo.git user_login}
+      end
+
+      it "should remove write access from a repository" do
+        repo = double("Repository")
+        user = double("User")
+        Gritano::Core::Repository.should_receive(:where).with(name: 'repo.git').and_return([repo])
+        Gritano::Core::User.should_receive(:where).with(login: 'user_login').and_return([user])
+        user.should_receive(:remove_access).with(repo, :write).and_return(true)
+        Gritano::CLI::Console::Local.start %w{repo:write:rm repo.git user_login}
+      end
+
+      it "should list repository's users ordered by login" do
+        repo = double("Repository")
+        users = [double("User")]
+        user = double("User")
+        Gritano::Core::Repository.should_receive(:where).with(name: 'repo.git').and_return([repo])
+        repo.should_receive(:users).and_return(users)
+        users.should_receive(:order).with(:login).and_return([user])
+        user.should_receive(:access).with(repo)
+        user.stub(:login)
+        Gritano::CLI::Console::Local.start %w{repo:user:list repo.git}
+      end
+    end
+  end
+end

data/spec/gritano/console/remote_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+module Gritano::CLI::Console
+  describe Remote do
+
+    before(:each) do
+      $stdout.stub(:puts)
+      $stdin.stub(:readlines).and_return(['some pubkey'])
+      ActiveRecord::Base.stub(:establish_connection)
+      YAML.stub(:load)
+      Gritano::CLI::Config.remote_user = "user_login"
+    end
+
+    it "should list user's repositories" do
+      user = double('User')
+      repos = double('Repositories')
+      user.should_receive(:repositories).and_return(repos)
+      repos.should_receive(:order).with(:name).and_return([])
+      Gritano::Core::User.should_receive(:where).with(login: 'user_login').and_return([user])
+      Gritano::CLI::Console::Remote.start %w{repo:list}
+    end
+
+    it "should list user's keys ordered by name" do
+      user = double('User')
+      keys = double('Keys')
+      user.should_receive(:keys).and_return(keys)
+      keys.should_receive(:order).with(:name).and_return([])
+      Gritano::Core::User.should_receive(:where).with(login: 'user_login').and_return([user])
+      Gritano::CLI::Console::Remote.start %w{key:list}
+    end
+
+    it "should add user's key" do
+      user = double("User")
+      keys = double("Key")
+      keys.stub(:name).and_return("Key")
+      key = double("Key")
+      Gritano::Core::User.should_receive(:where).with(login: 'user_login').and_return([user])
+      user.should_receive(:keys).and_return(keys)
+      keys.should_receive(:new).with(name: 'user_key', key: 'some pubkey').and_return(key)
+      key.should_receive(:save).and_return(true)
+      Gritano::CLI::Console::Remote.start %w{key:add user_key}
+    end
+
+    it "should remove user's key" do
+      user = double("User")
+      keys = [double("Key")]
+      keys.stub(:name).and_return("Key")
+      key = double("Key")
+      Gritano::Core::User.should_receive(:where).with(login: 'user_login').and_return([user])
+      user.should_receive(:keys).and_return(keys)
+      keys.should_receive(:where).with(name: 'user_key').and_return([key])
+      key.should_receive(:destroy)
+      Gritano::CLI::Console::Remote.start %w{key:rm user_key}
+    end
+  end
+end

data/spec/gritano/core/key_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+module Gritano::Core
+  describe Key do
+    before(:all) do
+      ActiveRecord::Base.establish_connection(YAML::load(File.open('spec/data/development.yml')))
+    end
+
+    it "should generate the authorized_keys file" do
+      user = double("User")
+      user.stub(:login).and_return('user_login')
+      keys = [double("Key#1"), double("key#2")]
+      keys[0].stub(:user).and_return(user)
+      keys[0].stub(:key).and_return("some_key")
+      keys[1].stub(:user).and_return(user)
+      keys[1].stub(:key).and_return("some_key")
+      Key.stub(:all).and_return(keys)
+      Key.authorized_keys.should be == "command=\"gritano-remote user_login\" some_key\ncommand=\"gritano-remote user_login\" some_key"
+    end
+  end
+end

data/spec/gritano/core/user_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+module Gritano::Core
+  describe User do
+    before(:all) do
+      ActiveRecord::Base.establish_connection(YAML::load(File.open('spec/data/development.yml')))
+    end
+
+    describe "#access" do
+      it "should return a string that represents a read access" do
+        repo = double("Repo")
+        user = User.new
+        user.should_receive(:check_access).with(repo, :read).and_return(true)
+        user.should_receive(:check_access).with(repo, :write).and_return(false)
+        user.access(repo).should be == "read"
+      end
+
+      it "should return a string that represents a write access" do
+        repo = double("Repo")
+        user = User.new
+        user.should_receive(:check_access).with(repo, :read).and_return(false)
+        user.should_receive(:check_access).with(repo, :write).and_return(true)
+        user.access(repo).should be == "write"
+      end
+
+      it "should return a string that represents a read and write access" do
+        repo = double("Repo")
+        user = User.new
+        user.should_receive(:check_access).with(repo, :read).and_return(true)
+        user.should_receive(:check_access).with(repo, :write).and_return(true)
+        user.access(repo).should be == "read+write"
+      end
+
+      it "should return a null string when user doens't have access to the repository" do
+        repo = double("Repo")
+        user = User.new
+        user.should_receive(:check_access).with(repo, :read).and_return(false)
+        user.should_receive(:check_access).with(repo, :write).and_return(false)
+        user.access(repo).should be == ""
+      end
+    end
+  end
+end