giternal-digarc 0.1.1Digarc

data/giternal_helper.rb

@@ -0,0 +1,105 @@
+class GiternalHelper
+  @@giternal_base ||= File.expand_path(File.dirname(__FILE__))
+
+  def self.create_main_repo
+    FileUtils.mkdir_p tmp_path
+    Dir.chdir(tmp_path) do
+      FileUtils.mkdir "main_repo"
+      Dir.chdir('main_repo') do
+        `git init`
+        `echo 'first content' > starter_repo`
+        `git add starter_repo`
+        `git commit -m "starter repo"`
+      end
+    end
+  end
+
+  def self.tmp_path
+    "/tmp/giternal_test"
+  end
+
+  def self.giternal_base
+    @@giternal_base
+  end
+
+  def self.base_project_dir
+    tmp_path + '/main_repo'
+  end
+
+  def self.run(*args)
+    `#{giternal_base}/bin/giternal #{args.join(' ')}`
+  end
+
+  def self.create_repo(repo_name)
+    Dir.chdir(tmp_path) do
+      FileUtils.mkdir_p "externals/#{repo_name}"
+      `cd externals/#{repo_name} && git init`
+    end
+    add_content repo_name
+    add_to_config_file repo_name
+  end
+
+  def self.add_to_config_file(repo_name)
+    config_dir = tmp_path + '/main_repo/config'
+    FileUtils.mkdir(config_dir) unless File.directory?(config_dir)
+    Dir.chdir(config_dir) do
+      `echo #{repo_name}: >> giternal.yml`
+      `echo '  repo: #{external_path(repo_name)}' >> giternal.yml`
+      `echo '  path: dependencies' >> giternal.yml`
+    end
+  end
+
+  def self.add_content(repo_name, content=repo_name)
+    Dir.chdir(tmp_path + "/externals/#{repo_name}") do
+      `echo #{content} >> #{content} && git add #{content}`
+      `git commit #{content} -m "added content to #{content}"`
+    end
+  end
+
+  def self.external_path(repo_name)
+    File.expand_path(tmp_path + "/externals/#{repo_name}")
+  end
+
+  def self.checked_out_path(repo_name)
+    File.expand_path(tmp_path + "/main_repo/dependencies/#{repo_name}")
+  end
+
+  def self.clean!
+    FileUtils.rm_rf tmp_path
+    %w(GIT_DIR GIT_WORK_TREE GIT_INDEX_FILE).each {|var| ENV[var] = nil }
+  end
+
+  def self.update_externals(*args)
+    Dir.chdir(tmp_path + '/main_repo') do
+      GiternalHelper.run('update', *args)
+    end
+  end
+
+  def self.freeze_externals(*args)
+    Dir.chdir(tmp_path + '/main_repo') do
+      GiternalHelper.run("freeze", *args)
+    end
+  end
+
+  def self.unfreeze_externals(*args)
+    Dir.chdir(tmp_path + '/main_repo') do
+      GiternalHelper.run("unfreeze", *args)
+    end
+  end
+
+  def self.repo_contents(path)
+    Dir.chdir(path) do
+      contents = `git cat-file -p HEAD`
+      unless contents.include?('tree') && contents.include?('author')
+        raise "something is wrong with the repo, output doesn't contain expected git elements:\n\n #{contents}"
+      end
+      contents
+    end
+  end
+
+  def self.add_external_to_ignore(repo_name)
+    Dir.chdir(tmp_path + '/main_repo') do
+      `echo 'dependencies/#{repo_name}' >> .gitignore`
+    end
+  end
+end

data/lib/giternal.rb

@@ -0,0 +1,10 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+module Giternal
+  
+end
+
+require 'giternal/repository'
+require 'giternal/yaml_config'
+require 'giternal/app'

data/lib/giternal/app.rb

@@ -0,0 +1,69 @@
+module Giternal
+  class App
+    def initialize(base_dir)
+      @base_dir = base_dir
+    end
+
+    def update(*dirs)
+      if dirs.empty?
+        config.each_repo {|r| r.update }
+      else
+        dirs.each do |dir|
+          if repo = config.find_repo(dir)
+            repo.update
+          end
+        end
+      end
+    end
+
+    def freezify(*dirs)
+      if dirs.empty?
+        config.each_repo {|r| r.freezify }
+      else
+        dirs.each do |dir|
+          if repo = config.find_repo(dir)
+            repo.freezify
+          end
+        end
+      end
+    end
+
+    def unfreezify(*dirs)
+      if dirs.empty?
+        config.each_repo {|r| r.unfreezify }
+      else
+        dirs.each do |dir|
+          if repo = config.find_repo(dir)
+            repo.unfreezify
+          end
+        end
+      end
+    end
+
+    def run(action, *args)
+      case action
+      when "freeze"
+        freezify(*args)
+      when "unfreeze"
+        unfreezify(*args)
+      else
+        send(action, *args)
+      end
+    end
+
+    def config
+      return @config if @config
+
+      config_file = ['config/giternal.yml', '.giternal.yml'].detect do |file|
+        File.file? File.expand_path(@base_dir + '/' + file)
+      end
+
+      if config_file.nil?
+        $stderr.puts "config/giternal.yml is missing"
+        exit 1
+      end
+
+      @config = YamlConfig.new(@base_dir, File.read(config_file))
+    end
+  end
+end

data/lib/giternal/repository.rb

@@ -0,0 +1,109 @@
+require 'fileutils'
+
+module Giternal
+  class Repository
+    class << self
+      attr_accessor :verbose
+    end
+    attr_accessor :verbose
+
+    def initialize(base_dir, name, repo_url, rel_path, branch=nil)
+      @base_dir = base_dir
+      @name = name
+      @repo_url = repo_url
+      @rel_path = rel_path
+      if branch != nil
+        @branch = branch
+      else
+        @branch = "master"
+      end
+      @verbose = self.class.verbose
+    end
+
+    def update
+      git_ignore_self
+
+      return true if frozen?
+      FileUtils.mkdir_p checkout_path unless File.exist?(checkout_path)
+      if checked_out?
+        if !File.exist?(repo_path + '/.git')
+          raise "Directory '#{@name}' exists but is not a git repository"
+        else
+          current_branch = (`cd #{repo_path} && git branch`).split[1]
+          if current_branch != @branch
+            `cd #{repo_path} && git checkout #{@branch}`
+          end
+          update_output { `cd #{repo_path} && git pull 2>&1` }
+        end
+      else
+        update_output { `cd #{checkout_path} && git clone #{@repo_url} #{@name} -b #{@branch}` }
+      end
+      true
+    end
+
+    def freezify
+      return true if frozen? || !checked_out?
+
+      Dir.chdir(repo_path) do
+        `find .git | sort | xargs tar czf .git.frozen.tgz`
+        FileUtils.rm_r('.git')
+      end
+      `cd #{@base_dir} && git add -f #{rel_repo_path}`
+      true
+    end
+
+    def unfreezify
+      return true unless frozen?
+
+      Dir.chdir(repo_path) do
+        `tar xzf .git.frozen.tgz`
+        FileUtils.rm('.git.frozen.tgz')
+      end
+      `cd #{@base_dir} && git rm -r --cached #{rel_repo_path}`
+      true
+    end
+
+    def frozen?
+      File.exist?(repo_path + '/.git.frozen.tgz')
+    end
+
+    def checked_out?
+      File.exist?(repo_path)
+    end
+
+    private
+    def checkout_path
+      File.expand_path(File.join(@base_dir, @rel_path))
+    end
+
+    def repo_path
+      File.expand_path(checkout_path + '/' + @name)
+    end
+
+    def rel_repo_path
+      @rel_path + '/' + @name
+    end
+
+    def update_output(&block)
+      puts "Updating #{@name}" if verbose
+      block.call
+      puts " ..updated\n" if verbose
+    end
+
+    def git_ignore_self
+      Dir.chdir(@base_dir) do
+        contents = File.read('.gitignore') if File.exist?('.gitignore')
+
+        unless contents.to_s.include?(rel_repo_path)
+          File.open('.gitignore', 'w') do |file|
+            if contents
+              file << contents
+              file << "\n" unless contents[-1] == 10 # ascii code for \n
+            end
+            file << rel_repo_path << "\n"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/giternal/version.rb

@@ -0,0 +1,9 @@
+module Giternal
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 2
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/giternal/yaml_config.rb

@@ -0,0 +1,30 @@
+require 'yaml'
+
+module Giternal
+  class YamlConfig
+    def initialize(base_dir, yaml_string)
+      @base_dir = base_dir
+      @config_hash = YAML.load yaml_string
+    end
+
+    def each_repo
+      repositories.each { |r| yield(r) if block_given? }
+    end
+
+    def find_repo(path)
+      @config_hash.each do |name, attributes|
+        if path == File.join(attributes["path"], name)
+          return Repository.new(@base_dir, name, attributes["repo"], attributes["path"])
+        end
+      end
+      return nil
+    end
+
+    private
+    def repositories
+      @config_hash.map do |name, attributes|
+        Repository.new(@base_dir, name, attributes["repo"], attributes["path"], attributes["branch"])
+      end
+    end
+  end
+end

data/spec/giternal/app_spec.rb

@@ -0,0 +1,64 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))
+
+module Giternal
+  describe App do
+    before(:each) do
+      @app = App.new("some_fake_dir")
+      @mock_config = stub("config", :null_object => true)
+    end
+
+    describe "loading the config file" do
+      before(:each) do
+        File.stub!(:file?).and_return true
+        File.stub!(:read).and_return "yaml config"
+        YamlConfig.stub!(:new).and_return @mock_config
+      end
+
+      it "should look for config/giternal.yml" do
+        File.should_receive(:file?).with(/some_fake_dir\/config\/giternal\.yml/)
+        @app.config
+      end
+
+      it "should look for .giternal.yml if giternal.yml does not exist" do
+        File.should_receive(:file?).with(/some_fake_dir\/config\/giternal\.yml/).and_return false
+        File.should_receive(:file?).with(/some_fake_dir\/\.giternal\.yml/).and_return true
+        @app.config
+      end
+
+      it "should exit with an error when no config file exists" do
+        File.stub!(:file?).and_return false
+        $stderr.should_receive(:puts)
+        @app.should_receive(:exit).with(1)
+        @app.config
+      end
+
+      it "should create a config from the config file" do
+        YamlConfig.should_receive(:new).with('some_fake_dir', "yaml config").and_return @mock_config
+        @app.config
+      end
+    end
+
+    describe "app actions" do
+      before(:each) do
+        @app.stub!(:config).and_return @mock_config
+        @mock_repo = mock("repo")
+        @mock_config.stub!(:each_repo).and_yield(@mock_repo)
+      end
+
+      it "should update each of the repositories" do
+        @mock_repo.should_receive(:update)
+        @app.update
+      end
+
+      it "should freeze each of the repositories" do
+        @mock_repo.should_receive(:freezify)
+        @app.freezify
+      end
+
+      it "should unfreeze each of the repositories" do
+        @mock_repo.should_receive(:unfreezify)
+        @app.unfreezify
+      end
+    end
+  end
+end

data/spec/giternal/repository_spec.rb

@@ -0,0 +1,149 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "spec_helper"))
+
+module Giternal
+  describe Repository do
+    before(:each) do
+      GiternalHelper.create_main_repo
+      GiternalHelper.create_repo 'foo'
+      @repository = Repository.new(GiternalHelper.base_project_dir, "foo",
+                                   GiternalHelper.external_path('foo'),
+                                   'dependencies')
+    end
+
+    it "should check itself out to a dir" do
+      @repository.update
+      File.file?(GiternalHelper.checked_out_path('foo/foo')).should be_true
+      File.read(GiternalHelper.checked_out_path('foo/foo')).strip.
+        should == 'foo'
+    end
+
+    it "should be ignored from git" do
+      @repository.update
+      Dir.chdir(GiternalHelper.base_project_dir) do
+        # TODO: What I really want is to say it shouldn't include 'foo'
+        `git status`.should_not include('dependencies')
+        File.read('.gitignore').should == "dependencies/foo\n"
+      end
+    end
+
+    it "should only add itself to .gitignore if it's not already there" do
+      Dir.chdir(GiternalHelper.base_project_dir) do
+        File.open('.gitignore', 'w') {|f| f << "dependencies/foo\n" }
+      end
+
+      @repository.update
+      
+      Dir.chdir(GiternalHelper.base_project_dir) do
+        File.read('.gitignore').should == "dependencies/foo\n"
+      end
+    end
+
+    it "adds a newline if it needs to" do
+      Dir.chdir(GiternalHelper.base_project_dir) do
+        File.open('.gitignore', 'w') {|f| f << "something/else" }
+      end
+
+      @repository.update
+
+      Dir.chdir(GiternalHelper.base_project_dir) do
+        File.read('.gitignore').should == "something/else\ndependencies/foo\n"
+      end      
+    end
+
+    it "should not show any output when verbose mode is off" do
+      @repository.verbose = false
+      @repository.should_not_receive(:puts)
+      @repository.update
+    end
+
+    it "should not show output when verbose mode is on" do
+      @repository.verbose = true
+      @repository.should_receive(:puts).any_number_of_times
+      @repository.update
+    end
+
+    it "should update the repo when it's already been checked out" do
+      @repository.update
+      GiternalHelper.add_content 'foo', 'newfile'
+      @repository.update
+      File.file?(GiternalHelper.checked_out_path('foo/newfile')).should be_true
+      File.read(GiternalHelper.checked_out_path('foo/newfile')).strip.
+        should == 'newfile'
+    end
+
+    it "should raise an error if the directory exists but there's no .git dir" do
+      FileUtils.mkdir_p(GiternalHelper.checked_out_path('foo'))
+      lambda {
+        @repository.update
+      }.should raise_error(/Directory 'foo' exists but is not a git repository/)
+    end
+
+    describe "freezify" do
+      before(:each) do
+        GiternalHelper.create_repo('external')
+        @repository = Repository.new(GiternalHelper.base_project_dir, 'external',
+                                     GiternalHelper.external_path('external'),
+                                     'dependencies')
+        @repository.update
+      end
+
+      it "should archive the .git dir" do
+        @repository.freezify
+        File.file?(GiternalHelper.checked_out_path('external/.git.frozen.tgz')).should be_true
+      end
+
+      it "should get rid of the .git dir" do
+        File.directory?(GiternalHelper.checked_out_path('external/.git')).should be_true
+        @repository.freezify
+        File.directory?(GiternalHelper.checked_out_path('external/.git')).should be_false
+      end
+    end
+
+    it "should simply return if updated when frozen" do
+      @repository.update
+      @repository.freezify
+      lambda { @repository.update }.should_not raise_error
+    end
+
+    it "should simply return when made to freeze when already frozen" do
+      @repository.update
+      @repository.freezify
+      lambda { @repository.freezify }.should_not raise_error
+    end
+
+    it "should simply return when made to freeze before checked out" do
+      lambda { @repository.freezify }.should_not raise_error
+    end
+
+    it "should simply return when made to unfreeze before checked out" do
+      lambda { @repository.unfreezify }.should_not raise_error
+    end
+
+    it "should simply return when made to unfreeze when already unfrozen" do
+      @repository.update
+      lambda { @repository.unfreezify }.should_not raise_error
+    end
+
+    describe "unfreezify" do
+      before(:each) do
+        GiternalHelper.create_repo('main')
+        GiternalHelper.create_repo('external')
+        @repository = Repository.new(GiternalHelper.base_project_dir, 'external',
+                                     GiternalHelper.external_path('external'),
+                                     'dependencies')
+        @repository.update
+        @repository.freezify
+      end
+
+      it "should unarchive the .git dir" do
+        @repository.unfreezify
+        File.directory?(GiternalHelper.checked_out_path('external/.git')).should be_true
+      end
+
+      it "should remove the archived file" do
+        @repository.unfreezify
+        File.file?(GiternalHelper.checked_out_path('external/.git.frozen.tgz')).should be_false
+      end
+    end
+  end
+end