rugs 0.0.1 → 0.1.0

data/README.markdown

@@ -1,6 +1,6 @@
 # RUGS - RUby Git Setup
 
-A helper script that makes setting up git repositories a snap.  
+A helper script that makes setting up remote git repositories a snap.  
 
 RUGS has three main functions:  
 
@@ -8,7 +8,7 @@ RUGS has three main functions:
 * Sets up a remote repository to mirror your local one.
 * Adds a framework of git hooks allowing you to store and run your own hooks in directly from the repo.
 
-RUGS makes creating remote repos as simple as `rugs create repo_name on server_name`. If you have a default server set you don't even have to specify the server you can just run `rugs create repo_name`.  
+RUGS makes creating remote repos as simple as `rugs create repo_name on server_name`.
 
 RUGS even allows you to automatically embed your Git hooks in the repo itself. No more jumping through hoops to make sure your hooks are maintained with your project; with RUGS you just store your hook scripts in the `git_hooks` directory and they're automatically updated and run.  
 
@@ -16,5 +16,31 @@ Once you've set up your project using RUGS you just use Git as you normally woul
 
 ## Status
 
-**In Development**  
-Beginning development.
+**Alpha**  
+Basic functionality done:
+
+* Stores config info for remotes
+* Sets up local repos
+* Sets up remote repos
+* Automatically adds default remotes to repos
+
+## To do
+
+Lots...
+
+* Add setup templates
+* Add hook framework to store and run hooks from the repo itself.
+
+
+## Instructions
+
+* Install the gem.
+* Add a remote repo.
+* Create a new project
+
+It might look something like this:
+
+	gem install rugs
+	
+    rugs remote_add origin git@git-server:/srv/repos/git
+    rugs create new_project on origin

data/_spike/psych.rb

@@ -0,0 +1,17 @@
+require 'fileutils'
+require 'psych'
+
+x = {a: "The a", b: "the b"}
+fn = "test.yaml"
+
+File.open(fn, "w+") do |file|
+  file.write(x.to_yaml)
+end
+
+y = Psych.load(File.open(fn))
+
+puts y
+
+z = Psych.load(File.open("no_such_file.yaml"))
+
+puts z

data/_spike/test.yaml

@@ -0,0 +1,3 @@
+---
+:a: The a
+:b: the b

data/lib/rugs.rb

@@ -1,5 +1,4 @@
 require "rugs/version"
+require "rugs/config"
 require "rugs/git"
-require "rugs/client"
-require "rugs/server"
-
+require "rugs/client"

data/lib/rugs/client.rb

@@ -1,11 +1,74 @@
-require 'fileutils'
-
 module RUGS
-  
+
   class Client
+  
+    def remote_list
+      @remote_list ||= Config.load("remotes")
+    end
+ 
+    def default_remotes
+      @default_remotes ||= remote_list.select do |remote, keys|
+        keys[:default]
+      end
+    end
     
-    def self.create(repo_name)
-      Git.init(repo_name) unless Dir.exists?("#{repo_name}/.git")
+    def create(repo_name, *remote)
+      
+      make_local_repo(repo_name)
+      add_defaults(repo_name)
+      make_hooks(repo_name)
+      
+      unless remote.empty?
+        just_name = repo_name.split("/").last
+        make_remote_repo(just_name, remote.last)
+      end
+      
+    end
+    
+    def remote_add(remote, url_path, default=false)
+      url, path = url_path.split(":")
+      
+      default = (remote == 'origin' || default == 'default')
+      
+      remote_list.merge!(remote => {url: url, path: path, default: default})
+      Config.save("remotes", remote_list)
+    end
+
+    def remote_remove(remote)
+      remote_list.delete(remote)
+      Config.save("remotes", remote_list)
+    end
+
+    def default(remote, is_default=true)
+      remote_list[remote][:default] = is_default
+    end
+
+    def undefault(remote)
+      default remote, false
+    end
+
+    private
+    
+    def make_local_repo(repo_name)
+      return if Dir.exists?("#{repo_name}/.git")
+      Git.init(repo_name) 
+    end
+
+    def make_remote_repo(repo_name, remote)
+      url     = remote_list[remote][:url]
+      path    = remote_list[remote][:path]
+      default = remote_list[remote][:default]
+      
+      `ssh #{url} 'git init #{"#{path}/" if path}#{repo_name}.git --bare'`
+    end
+
+    def add_defaults(repo_name)
+      default_remotes.each do |remote, keys|
+        Git.remote_add(repo_name, remote, keys[:url])
+      end
+    end
+
+    def make_hooks(repo_name)
       FileUtils.mkdir_p "#{repo_name}/git_hooks"
     end
     

data/lib/rugs/config.rb

@@ -0,0 +1,36 @@
+require 'psych'
+
+module RUGS
+  
+  class Config
+    
+    
+    def self.load(name)
+      return {} unless File.exist?(config_file(name))
+      Psych.load(File.open(config_file(name)))
+    end
+    
+    def self.save(name, hash)
+      File.open(config_file(name), "w") do |file|
+        file.write(hash.to_yaml)
+      end
+    end
+    
+    private
+    
+    def self.config_file(name)
+      build_path(PATH, "#{name}.yaml")
+    end
+
+    def self.build_path(root, append)
+      File.expand_path(File.join(root, "/#{append}"))
+    end
+
+    public 
+    
+    PATH = build_path(File.dirname(__FILE__), "../../config")
+    #File.expand_path(File.join(File.dirname(__FILE__), "/../config"))
+
+  end 
+
+end

data/lib/rugs/git.rb

@@ -2,11 +2,24 @@ require 'open3'
 
 module RUGS
   
-  # a very dumb wrapper for git
+  # a very simple wrapper for git, only wraps what I nee
   class Git
     
-    def self.method_missing(meth, args)    
-      out, status = Open3.capture2e("git", meth.to_s, args)
+    def self.init(repo_name)
+      exec 'init', repo_name
+    end
+    
+    def self.remote_add(repo_name, server, url)
+      pwd = FileUtils.pwd
+      FileUtils.cd repo_name
+      exec 'remote', 'add', server, url
+      FileUtils.cd pwd
+    end
+
+    private
+    
+    def self.exec(cmd, *args)
+      out, status = Open3.capture2e("git", cmd, *args)
       raise Object::Exception(out) if status.exitstatus != 0
       out
     end

data/lib/rugs/version.rb

@@ -1,3 +1,3 @@
 module RUGS
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/rugs.gemspec

@@ -8,16 +8,32 @@ Gem::Specification.new do |s|
   s.authors     = ["Mike Bethany"]
   s.email       = ["mikbe.tk@gmail.com"]
   s.homepage    = "http://mikbe.tk"
-  s.summary     = %q{Place holder gem}
-  s.description = %q{Nothing to see here, move along.}
+  s.summary     = %q{A helper script that makes setting up remote git repositories a snap.}
+  s.description = 
+"""
+== RUGS - RUby Git Setup
+
+A helper script that makes setting up remote git repositories a snap.  
+
+RUGS has three main functions:  
+
+* Creates a local git repository using default templates or ones you create.
+* Sets up a remote repository to mirror your local one.
+* Adds a framework of git hooks allowing you to store and run your own hooks in directly from the repo.
+
+RUGS makes creating remote repos as simple as `rugs create repo_name on server_name`.
+
+RUGS even allows you to automatically embed your Git hooks in the repo itself. No more jumping through hoops to make sure your hooks are maintained with your project; with RUGS you just store your hook scripts in the `git_hooks` directory and they're automatically updated and run.  
+
+Once you've set up your project using RUGS you just use Git as you normally would with the exception of your hooks being the in `git_hooks` directory.  
+  
+"""
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  # specify any dependencies here; for example:
-  # s.add_development_dependency "rspec"
   s.add_development_dependency "rspec"
   
   # s.add_runtime_dependency "rest-client"

data/spec/rugs/client_spec.rb

@@ -1,26 +1,160 @@
 require 'spec_helper'
-require 'fileutils'
+require 'psych'
 
 describe RUGS::Client do
   
-  let(:client) {RUGS::Client}
+  let(:client) {RUGS::Client.new}
+
+  let(:remote){'test'}
+  let(:url){'root@git-test'}
+  let(:path){'/srv/repos/git'}
+  
+  let(:repo_name){random_name}
+  let(:local_repo){"#{TEMP_DIR}/#{repo_name}"}
+  
+  let(:test_hash){
+    {"test"=>{:url=>url, path: nil, :default=>true}}
+  }
+  let(:another_hash){
+    {"another"=>{:url=>"git@another_server.org", path: nil, :default=>true}}
+  }
   
-  context 'When creating repos' do
+  context 'when managing remote server settings' do
+
+    context "and adding or removing servers" do
+    
+      it "should remember remote servers" do
+        client.remote_add(remote, url)
+
+        client.remote_list.should include(remote)
+      end
+    
+      it "should forget remote servers" do
+        client.remote_add(remote, url)
+
+        client.remote_remove(remote)
+        client.remote_list.should be_empty
+      end
+    
+    end
+    
+    context "and configuring defaults" do
+      
+      it "should remember default remotes" do
+        client.remote_add(remote, url, "default")
+        client.default_remotes.should include(test_hash)
+      end
+
+      it "should set origin remots as defaults" do
+        client.remote_add('origin', url)
+        client.default_remotes.should include(
+          {"origin"=>{:url=>"root@git-test", :path=>nil, :default=>true}}
+        )
+      end
 
-    let(:repo_name) {temp_name}
+      it "should remember multiple default remote" do
+        client.remote_add(remote, url, "default")
+        client.remote_add('another', 'git@another_server.org', "default")
+      
+        client.default_remotes.should == {}.merge(test_hash).merge(another_hash)
+      end
 
-    it 'should create a git repo' do
-      client.create repo_name
-      Dir.exists?(repo_name).should be_true
+      it "should set an exisiting remote as a default" do
+        client.remote_add(remote, url)
+        client.default(remote)
+        client.default_remotes.should include(remote)
+      end
+    
+      it "should un-default a remote" do
+        client.remote_add(remote, url, "default")
+        client.undefault(remote)
+        client.default_remotes.should_not include(remote)
+      end
+    
     end
+  
+    context "and setting a path to the git repo" do
+      
+      it "should save the remote path if one is given" do
+        client.remote_add(remote, "#{url}:#{path}")
+        client.remote_list[remote][:path].should == path
+      end
+            
+      it "should not save a remote path if none is given" do
+        client.remote_add(remote, url)
+        client.remote_list[remote][:path].should be_nil
+      end
 
-    it 'should create a git_hooks directory in the local repo' do
-      client.create repo_name
-      Dir.exists?("#{repo_name}/git_hooks").should be_true
     end
     
   end
   
-  after(:all) {FileUtils.rm_rf TEMP}
+  context 'when creating local repos' do
+
+    it 'should create a local git repo' do
+      client.create local_repo
+      Dir.exists?(local_repo).should be_true
+    end
+
+    it 'should set the default remotes automatically' do
+      client.remote_add(remote, url, "default")
+      client.remote_add('some_remote', 'git@server.org', "default")
+      client.create local_repo
+
+      remotes = `git --git-dir="#{local_repo}/.git" --work-tree="#{local_repo}" remote`
+      remotes.should include("test", "some_remote")
+    end
+
+    it "should not set default remotes if there aren't any" do
+      client.remote_add(remote, url)
+      client.remote_add('some_remote', 'git@server.org') 
+      client.create local_repo
+
+      remotes = `git --git-dir="#{local_repo}/.git" --work-tree="#{local_repo}" remote`
+      remotes.should be_empty
+    end
+
+  end
+
+  # It's probably best to set up a git server on a virtual machine for these tests.
+  # These tests are set up with the following system in place...
+  #
+  # You can download a free, ready to run Linux VM from here:
+  #  http://www.turnkeylinux.org/revision-control
+  #
+  # And you can use the free VirtualBox software to run it:
+  #  http://www.virtualbox.org/wiki/Downloads
+  #
+  # You'll also want to set ssh to login without a password, see:
+  #  http://mikbe.tk/2010/09/08/login-to-ssh-without-a-password-easily/
+  #
+  context 'when creating remote repos' do
+    
+    it 'should create a repo on the remote server' do
+      client.remote_add(remote, "#{url}:#{path}")
+      client.create local_repo, remote
+      
+      out, status = Open3.capture2e("ssh", 
+        "#{url}", "ls #{path}/#{repo_name}.git"
+      )
+      `ssh #{url} 'rm -rf #{path}/*.git'`
+      out.should_not include("No such file")
+    end
+
+  end
+
+  context "mit der hooks" do
+
+    # it 'should create a git_hooks directory in the local repo' do
+    #   client.create repo_name
+    #   Dir.exists?("#{repo_name}/git_hooks").should be_true
+    # end
+
+  end
   
+  after(:each) do
+    clean_config
+    clean_temp
+  end
+
 end

data/spec/rugs/config_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'psych'
+
+describe RUGS::Client do
+  
+  let(:config) {RUGS::Config}
+  let(:file_name){random_name}
+  let(:config_file){"#{config::PATH}/#{file_name}.yaml"}
+  let(:data){{some_key: 'some data'}}
+
+  it "should create a config file" do
+    config.save(file_name, data)
+
+    File.exist?(config_file).should be_true
+  end
+
+  it "should save the server's address in the config file" do
+    config.save(file_name, data)
+
+    servers = Psych.load(File.open(config_file))
+    servers.should include(data)
+  end
+  
+  it "should load saved data" do
+    config.save(file_name, data)
+    
+    config.load(file_name).should == data
+  end
+    
+  after(:each) {clean_config}
+
+end

data/spec/rugs/git_spec.rb

@@ -4,18 +4,25 @@ require 'fileutils'
 describe RUGS::Git do
 
   let(:git) {RUGS::Git}
-    
-  it 'should run commands git knows' do
-    repo_name = temp_name
-    git.init(repo_name).should include("Initialized empty Git repository")
-  end
+  let(:file_name) {random_name}
+  let(:repo_path) {"#{Dir.tmpdir}/#{file_name}"}
   
-  it 'should not run commands git does not know' do
-    repo_name = temp_name
-    expect{git.unicorn_and_rainbows(repo_name)}.should 
-      raise_error(Object::Exception)
+  it 'should initialize a local repository' do
+    git.init(repo_path).should include("Initialized empty Git repository")
+  end
+
+  it 'should add remote settings to the repo' do
+    server    = random_name
+    url       = "git@#{random_name}.org"
+     
+    git.init(repo_path)
+    git.remote_add(repo_path, server, url)
+    
+    remotes = `git --git-dir="#{repo_path}/.git" --work-tree="#{repo_path}" remote`
+    remotes.should include(server)
+
   end
   
-  after(:all) {FileUtils.rm_rf TEMP}
-  
+  after(:all) {clean_temp}
+
 end

data/spec/spec_helper.rb

@@ -1,10 +1,21 @@
 $: << '.'
 $:.unshift File.expand_path(File.join(File.dirname(__FILE__), "/../lib"))
+
 require 'rspec'
 require 'rugs'
+require 'fileutils'
+require 'tmpdir'
 
-TEMP = "temp_rspec"
+def random_name
+  12.times.map{('a'..'z').to_a.sample}.join
+end
 
-def temp_name(length=8)
-  "#{TEMP}/" + length.times.map{('a'..'z').to_a.sample}.join
+def clean_config
+  FileUtils.rm Dir["#{RUGS::Config::PATH}/*"]
 end
+
+def clean_temp 
+  FileUtils.rm_rf TEMP_DIR
+end
+
+TEMP_DIR = "#{Dir.tmpdir}/#{random_name}"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rugs
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-23 00:00:00.000000000Z
+date: 2011-09-25 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2152139360 !ruby/object:Gem::Requirement
+  requirement: &2152208160 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,8 +21,19 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152139360
-description: Nothing to see here, move along.
+  version_requirements: *2152208160
+description: ! "\n== RUGS - RUby Git Setup\n\nA helper script that makes setting up
+  remote git repositories a snap.  \n\nRUGS has three main functions:  \n\n* Creates
+  a local git repository using default templates or ones you create.\n* Sets up a
+  remote repository to mirror your local one.\n* Adds a framework of git hooks allowing
+  you to store and run your own hooks in directly from the repo.\n\nRUGS makes creating
+  remote repos as simple as `rugs create repo_name on server_name`.\n\nRUGS even allows
+  you to automatically embed your Git hooks in the repo itself. No more jumping through
+  hoops to make sure your hooks are maintained with your project; with RUGS you just
+  store your hook scripts in the `git_hooks` directory and they're automatically updated
+  and run.  \n\nOnce you've set up your project using RUGS you just use Git as you
+  normally would with the exception of your hooks being the in `git_hooks` directory.
+  \ \n  \n"
 email:
 - mikbe.tk@gmail.com
 executables: []
@@ -33,17 +44,19 @@ files:
 - Gemfile
 - README.markdown
 - Rakefile
+- _spike/psych.rb
+- _spike/test.yaml
 - autotest/discover.rb
 - lib/rugs.rb
 - lib/rugs/client.rb
+- lib/rugs/config.rb
 - lib/rugs/file_events.rb
 - lib/rugs/git.rb
-- lib/rugs/server.rb
 - lib/rugs/version.rb
 - rugs.gemspec
 - spec/rugs/client_spec.rb
+- spec/rugs/config_spec.rb
 - spec/rugs/git_spec.rb
-- spec/rugs/server_spec.rb
 - spec/spec_helper.rb
 homepage: http://mikbe.tk
 licenses: []
@@ -68,9 +81,9 @@ rubyforge_project:
 rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: Place holder gem
+summary: A helper script that makes setting up remote git repositories a snap.
 test_files:
 - spec/rugs/client_spec.rb
+- spec/rugs/config_spec.rb
 - spec/rugs/git_spec.rb
-- spec/rugs/server_spec.rb
 - spec/spec_helper.rb

data/lib/rugs/server.rb

@@ -1,9 +0,0 @@
-require 'fileutils'
-
-module RUGS
-  
-  class Server
- 
-  end
-  
-end

data/spec/rugs/server_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-require 'fileutils'
-
-describe RUGS::Server do
-  let(:server) {RUGS::Server.new}
-  
-  context 'When creating repos' do
-
-  end
-  
-  after(:all) {FileUtils.rm_rf TEMP}
-  
-end