webmat-git_remote_branch 0.2.4 → 0.2.6

data/lib/version.rb

@@ -0,0 +1,14 @@
+module GitRemoteBranch  
+  module VERSION #:nodoc:
+    MAJOR    = 0
+    MINOR    = 2
+    TINY     = 6
+    
+    STRING   = [MAJOR, MINOR, TINY].join('.').freeze
+  end
+  
+  NAME          = 'git_remote_branch'.freeze
+  COMPLETE_NAME = "#{NAME} #{VERSION::STRING}".freeze  
+  COMMAND_NAME  = 'grb'.freeze
+  SHORT_NAME    = COMMAND_NAME
+end

data/tasks/gem.rake

@@ -0,0 +1,73 @@
+require 'yaml'
+
+require 'rake/gempackagetask'
+
+task :clean => :clobber_package
+
+spec = Gem::Specification.new do |s|
+  s.name                  = GitRemoteBranch::NAME
+  s.version               = GitRemoteBranch::VERSION::STRING
+  s.summary               = "git_remote_branch eases the interaction with remote branches"
+  s.description           = "git_remote_branch is a learning tool to ease the interaction with " +
+                            "remote branches in simple situations."
+
+  s.authors               = ['Mathieu Martin', 'Carl Mercier']
+  s.email                 = "webmat@gmail.com"
+  s.homepage              = "http://github.com/webmat/git_remote_branch"
+  s.rubyforge_project     = 'grb'
+
+  s.has_rdoc              = false
+  
+  s.test_files            = Dir['test/**/*']
+  s.files                 = Dir['**/*'].reject{|f| f =~ /\Apkg|\Acoverage|\.gemspec\Z/}
+  
+  s.executable            = 'grb'
+  s.bindir                = "bin"
+  s.require_path          = "lib"
+  
+  s.add_dependency( 'colored', '>= 1.1' )
+end
+
+#Creates clobber_package, gem, package and repackage tasks
+#Note on clobber_package: fortunately, this will clobber the CODE package
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+end
+
+TAG_COMMAND = "git tag -m 'Tagging version #{GitRemoteBranch::VERSION::STRING}' -a v#{GitRemoteBranch::VERSION::STRING}"
+task :tag_warn do
+  puts  "*" * 40,
+        "Don't forget to tag the release:",
+        '',
+        "  " + TAG_COMMAND,
+        '',
+        "or run rake tag",
+        "*" * 40
+end
+task :tag do
+  sh TAG_COMMAND
+end
+task :gem => :tag_warn
+
+namespace :gem do
+  desc "Update the gemspec for GitHub's gem server"
+  task :github do
+    File.open("#{GitRemoteBranch::NAME}.gemspec", 'w'){|f| f.puts YAML::dump(spec) }
+    puts "gemspec generated here: #{GitRemoteBranch::NAME}.gemspec"
+  end
+  
+  desc 'Upload gem to rubyforge.org'
+  task :rubyforge => :gem do
+    sh 'rubyforge login'
+    sh "rubyforge add_release grb grb 'release #{GitRemoteBranch::VERSION::STRING}' pkg/#{spec.full_name}.gem"
+    sh "rubyforge add_file grb grb #{GitRemoteBranch::VERSION::STRING} pkg/#{spec.full_name}.gem"
+  end
+end
+
+task :install => [:clean, :gem] do
+  sh "#{SUDO} gem install pkg/#{spec.full_name}.gem"
+end
+
+task :uninstall do
+  sh "#{SUDO} gem uninstall -v #{GitRemoteBranch::VERSION::STRING} -x #{GitRemoteBranch::NAME}"
+end

data/tasks/test.rake

@@ -0,0 +1,21 @@
+require 'rake/testtask'
+
+desc "Run all tests"
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+namespace :test do
+  desc "Run functional tests"
+  Rake::TestTask.new(:functional) do |t|
+    t.pattern = 'test/functional/**/*_test.rb'
+    t.verbose = true
+  end
+
+  desc "Run unit tests"
+  Rake::TestTask.new(:unit) do |t|
+    t.pattern = 'test/unit/**/*_test.rb'
+    t.verbose = true
+  end
+end

data/test/functional/grb_test.rb

@@ -0,0 +1,154 @@
+require File.join( File.dirname(__FILE__), '..', 'test_helper')
+
+class GRBTest < Test::Unit::TestCase
+  include ShouldaFunctionalHelpers
+
+  on_a_repository do
+    context "creating a branch in a local clone" do
+      setup do
+        in_directory_for :local1
+        run_grb_with 'create new_branch'
+      end
+      
+      should_have_branch 'new_branch', :local, :remote
+      
+      context "the remote repository" do
+        setup do
+          in_directory_for :remote
+        end
+        
+        should_have_branch 'new_branch', :local
+      end
+      
+      context "the other local clone, tracking the new branch" do
+        setup do
+          in_directory_for :local2
+          run_grb_with 'track new_branch'
+        end
+        
+        should_have_branch 'new_branch', :local, :remote
+      end
+      
+      context "then deleting the branch" do
+        setup do
+          run_grb_with 'delete new_branch'
+        end
+        
+        should_not_have_branch 'new_branch', :local, :remote
+        
+        context "the remote repository" do
+          setup do
+            in_directory_for :remote
+          end
+
+          should_not_have_branch 'new_branch', :local
+        end
+      end
+      
+      context "renaming the branch" do
+        setup do
+          in_directory_for :local1
+          in_branch :new_branch
+          run_grb_with 'rename renamed_branch'
+        end
+
+        should_not_have_branch 'new_branch', :local, :remote
+        should_have_branch 'renamed_branch', :local, :remote
+
+        context "the remote repository" do
+          setup do
+            in_directory_for :remote
+          end
+
+          should_not_have_branch 'new_branch', :local
+          should_have_branch 'renamed_branch', :local
+        end
+      end
+    end
+    
+    context "having a local only branch" do
+      setup do
+        in_directory_for :local1
+        execute "git branch my_branch"
+      end
+      
+      should_have_branch 'my_branch', :local #Sanity check
+      
+      context "remotizing the branch" do
+        setup do
+          run_grb_with 'publish my_branch'
+        end
+        
+        should_have_branch 'my_branch', :remote
+        
+        context "the remote repository" do
+          setup do
+            in_directory_for :remote
+          end
+
+          should_have_branch 'my_branch', :local
+        end
+      end
+    end
+    
+    context "running grb with a detailed explain" do
+      setup do
+        in_directory_for :local1
+        @text = run_grb_with 'explain create teh_branch somewhere'
+      end
+      
+      should "display the commands to run with the user-specified values, including current_branch" do
+        %w{master somewhere refs/heads/teh_branch}.each do |word|
+          assert_match(/#{word}/, @text)
+        end
+      end
+    end
+  end
+
+  in_a_non_git_directory do
+    context "displaying help" do
+      setup do
+        @text = run_grb_with 'help'
+      end
+      
+      should "work" do
+        words_in_help = %w{create delete explain git_remote_branch}
+        words_in_help.each do |word|
+          assert_match(/#{word}/, @text)
+        end
+      end
+      
+      should "not complain" do
+        assert_no_match(/not a git repository/i, @text)
+      end
+    end
+    
+    context "running grb with a generic explain" do
+      setup do
+        @text = run_grb_with 'explain create'
+      end
+      
+      should "display the commands to run with dummy values filled in" do
+        #Not sure if this will turn out to be too precise to my liking...
+        generic_words_in_explain_create = %w{
+          origin current_branch refs/heads/branch_to_create
+          git push fetch checkout}
+        generic_words_in_explain_create.each do |word|
+          assert_match(/#{word}/, @text)
+        end
+      end
+    end
+    
+    context "running grb with a detailed explain" do
+      setup do
+        @text = run_grb_with 'explain create teh_branch somewhere'
+      end
+      
+      should "display the commands to run with the user-specified values (except for current_branch)" do
+        %w{somewhere current_branch refs/heads/teh_branch}.each do |word|
+          assert_match(/#{word}/, @text)
+        end
+      end
+    end
+  end
+end

data/test/helpers/array_extensions.rb

@@ -0,0 +1,14 @@
+# Can be included in any class that responds to #each. 
+# Such as Array.
+module CountDistinct
+  def count_all(purge_smaller_than=0)
+    h={}
+    self.each {|e|
+      h[e] ? h[e] += 1 : h[e] = 1
+    }
+    h.extract{|k,v| v >= purge_smaller_than}
+  end
+end
+
+Array.send :include, CountDistinct
+

data/test/helpers/dir_stack.rb

@@ -0,0 +1,25 @@
+class DirStack
+  attr_reader :dir_stack
+  
+  def current_dir
+    dir_stack.size == 0 ? Dir.pwd : dir_stack.last
+  end
+  
+  def pushd(dirname)
+    dir_stack.push(File.expand_path(dirname))
+  end
+  
+  def popd
+    return [] if dir_stack.size==0
+    dir_stack.pop
+    dir_stack
+  end
+  
+  def to_s
+    dir_stack.inspect
+  end
+  
+  def initialize
+    @dir_stack = []
+  end
+end

data/test/helpers/extractable.rb

@@ -0,0 +1,63 @@
+module Extractable
+  # Hash#extract(*keys) => Hash
+  # Hash#extract([keys]) => Hash
+  # Hash#extract{|k,v| predicate } => Hash
+  # 
+  # Returns a new Hash that contains only the k,v pairs where the k was
+  # specified in the keys array.
+  # If any k in keys is not present in the original Hash, it's simply
+  # not the resulting Hash.
+  # 
+  # This is very useful to check that a Hash contains at least some desired keys
+  # or to get a sanitized Hash out of the one we currently have.
+  # 
+  # Examples:
+  #  h = {:bob=>'Marley',:mom=>'Barley'}
+  #  h.extract(:bob) #=> {:bob=>'Marley'}
+  #  h.extract(:bob, :mom) #=> {:bob=>'Marley',:mom=>'Barley'}
+  #  h.extract([:bob, :mom]) #=> {:bob=>'Marley',:mom=>'Barley'}
+  #  h.extract(:sos) #=> {}
+  
+  def extract(*args, &block)
+    if block_given?
+      extract_block(&block)
+    elsif args[0].is_a? Proc
+      extract_block(&args[0])
+    elsif args.size == 0
+      raise ArgumentError, "extract requires either an array of keys, a block or a proc"
+    else
+      extract_keys(args)
+    end
+  end
+  
+  # Returns two hashes. The first contains all pairs for which the block evaluated to true,
+  # the second contains all the others.
+  def split(&block)
+    trues, falses = self.class.new, self.class.new
+    each_pair do |k,v| 
+      if yield(k,v) 
+        trues[k] = v
+      else
+        falses[k] = v
+      end
+    end
+    #each_pair{ |k,v| (yield(k,v) ? trues : falses)[k] = v }
+    return trues, falses
+  end
+  
+  private
+    def extract_keys(*keys)
+      extracted = self.class.new #Can therefore be included in any hash-like container
+      keys.flatten.each { |k| extracted[k] = self[k] if self.include?(k) }
+      extracted
+    end
+    
+    def extract_block(&block)
+      extracted = self.class.new
+      each_pair{ |k,v| extracted[k] = v if yield(k,v) }
+      extracted
+    end
+end
+
+
+Hash.send :include, Extractable

data/test/helpers/git_helper.rb

@@ -0,0 +1,33 @@
+require 'fileutils'
+require 'tmpdir'
+require File.dirname(__FILE__) + '/temp_dir_helper'
+
+# Instantiating a GitHelper object creates a temp directory containing 3 repos.
+# 1 that's considered the remote repo and 2 peer local repos (local1 and local2).
+# All 3 are synchronized with the same data (they contain a few dummy files).
+# Once instantiated you can access the 3 full repo locations through attribute readers
+# remote, local1 and local2.
+class GitHelper < TempDirHelper
+
+  attr_reader :remote, :local1, :local2
+  
+  def initialize
+    super('grb_test')
+    
+    @remote  = init_repo(directory, 'remote')
+    @local1  = clone_repo(@remote, directory, 'local1')
+    @local2  = clone_repo(@remote, directory, 'local2')
+  end
+  
+  protected
+    def init_repo(path, name)
+      repo_dir = File.join(path, name)
+      `mkdir #{repo_dir}; cd $_; git init; touch file.txt; git add .; git commit -a -m "dummy file"`
+      repo_dir
+    end
+    
+    def clone_repo(origin_path, clone_path, name)
+      `cd #{clone_path}; git clone #{File.join(origin_path, '.git')} #{name}`
+      return File.join(clone_path, name)
+    end
+end

data/test/helpers/more_assertions.rb

@@ -0,0 +1,16 @@
+#require 'test/unit/assertionfailederror'
+module MoreAssertions
+  include Test::Unit
+
+  def assert_false(condition, message = nil)
+    unless condition == false
+      raise AssertionFailedError, message || "assert_false failed"
+    end
+  end
+  
+  def assert_array_content(expected_array, array, message = nil)
+    unless expected_array.count_all == array.count_all
+      raise AssertionFailedError, message || "arrays did not have the same content. Expected #{expected_array.inspect}, got #{array.inspect}"
+    end
+  end
+end

data/test/helpers/shoulda_functional_helpers.rb

@@ -0,0 +1,106 @@
+module ShouldaFunctionalHelpers
+  include CaptureFu
+  GRB_COMMAND = File.expand_path(File.dirname(__FILE__) + '/../../bin/grb') unless defined?(GRB_COMMAND)
+  
+  def self.included(base)
+    base.extend  ClassMethods
+    base.class_eval do
+      include ::ShouldaFunctionalHelpers::InstanceMethods
+    end
+  end
+  
+  module InstanceMethods
+    def current_dir
+      @current_dir || raise("@current_dir is not set. Warning, Will Robinson!")
+    end
+    
+    def current_dir=(value)
+      @current_dir = value
+    end
+    
+    # Switches to one of the directories created by GitHelper:
+    #   :local1, :local2, :non_git or :remote
+    # This affects commands run with ``, system and so on.
+    def in_directory_for(dir)
+      # Just a reminder for my dumb head
+      raise "'in_directory_for' depends on @gh being set" unless @gh
+      
+      @current_dir = eval("@gh.#{dir}")
+    end
+    
+    def in_branch(branch)
+      execute "git checkout #{branch}"
+    end
+    
+    
+    def run_grb_with(params='')
+      execute "#{GRB_COMMAND} #{params}"
+    end
+
+    def execute(command)
+      errno, returned_string = capture_process_output("cd #{current_dir} ; #{command}")
+      returned_string
+    end
+    
+    private
+      def get_branch_location(location)
+        case location.to_sym
+        when :local
+          args = '-l'
+        when :remote
+          args = '-r'
+        else
+          raise ArgumentError, "Unknown branch location: #{location.inspect}"
+        end
+      end
+  end
+
+  module ClassMethods
+    def should_have_branch(what_branch, *wheres)
+      wheres.flatten.each do |where|
+        should "have the branch '#{what_branch}' #{where == :local ? 'locally' : 'remotely'}" do
+          args = get_branch_location(where)
+          assert_match(/#{what_branch}/, execute("git branch #{args}"))
+        end
+      end
+    end
+    
+    def should_not_have_branch(what_branch, *wheres)
+      wheres.flatten.each do |where|
+        should "not have the branch '#{what_branch}' #{where == :local ? 'locally' : 'remotely'}" do
+          args = get_branch_location(where)
+          assert_no_match(/#{what_branch}/, execute("git branch #{args}"))
+        end
+      end
+    end
+    
+    def on_a_repository
+      context "on a new repository" do
+        setup do
+          @gh = GitHelper.new
+        end
+
+        teardown do
+          @gh.cleanup
+        end
+
+        yield
+      end
+    end
+    
+    def in_a_non_git_directory
+      context "on a non-git related directory" do
+        setup do
+          @temp_dir = TempDirHelper.new
+          @current_dir = @temp_dir.directory
+        end
+        
+        teardown do
+          @temp_dir.cleanup
+        end
+        
+        yield
+      end
+    end
+  end
+end