cypriss-git_remote_branch 0.3.3

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/constants.rb

@@ -0,0 +1,15 @@
+REGULAR_BRANCH_LISTING = <<-STR
+  other_user/master
+* stubbed_current_branch
+  rubyforge
+STR
+
+BRANCH_LISTING_WHEN_NOT_ON_BRANCH = <<-STR
+* (no branch)
+  other_user/master
+  master
+  rubyforge
+STR
+
+WHEN_NOT_ON_GIT_REPOSITORY = "fatal: Not a git repository\n"
+

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,40 @@
+require File.dirname(__FILE__) + '/in_dir'
+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
+  include InDir
+  GIT = GitRemoteBranch::GIT
+  
+  attr_reader :remote, :local1, :local2
+  
+  def initialize
+    super("#{TEST_DIR}/test_runs")
+    @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_p repo_dir
+      
+      in_dir repo_dir do
+        `#{GIT} init && echo "foo" > file.txt && #{GIT} add . && #{GIT} commit -a -m "dummy file"`
+      end
+      raise "Error setting up repository #{name}" unless $?.exitstatus == 0
+      repo_dir
+    end
+    
+    def clone_repo(origin_path, clone_path, name)
+      in_dir clone_path do
+        `#{GIT} clone #{File.join(origin_path, '.git').path_for_os} #{name}`
+      end
+      return File.join(clone_path, name)
+    end
+end

data/test/helpers/in_dir.rb

@@ -0,0 +1,10 @@
+module InDir
+  def in_dir(dir, &block)
+    prev_dir = Dir.pwd
+    Dir.chdir dir
+    
+    yield
+  ensure
+    Dir.chdir prev_dir
+  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,152 @@
+module ShouldaFunctionalHelpers
+  include CaptureFu
+  include InDir
+  
+  GIT = GitRemoteBranch::GIT
+  
+  def self.ruby_prefix
+    if ENV['RUBY']
+      warn "  Forcing execution of grb with ruby interpreter #{ENV['RUBY']}"
+      ENV['RUBY'] + ' '
+    elsif WINDOWS
+      'ruby '
+    else
+      ''
+    end
+  end
+  
+  # Here we're only prepending with 'ruby'. 
+  # When run as a gem, RubyGems takes care of generating a batch file that does this stuff.
+  GRB_COMMAND = ruby_prefix + 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)
+      in_dir current_dir do
+        errno, returned_string = capture_process_output(command)
+        returned_string
+      end
+    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
+
+        context '' do
+          yield
+        end
+      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
+        
+        context '' do
+          yield
+        end
+      end
+    end
+    
+    def with_env_var(name, value)
+      name = name.to_s
+      
+      context "with environment variable '#{name}' set to '#{value}'" do
+        setup do
+          @env_previous_value = ENV[name] if ENV.keys.include?(name)
+          ENV[name]           = value
+        end
+        
+        teardown do
+          if @env_previous_value
+            ENV[name] = @env_previous_value
+          else
+            ENV.delete(name)
+          end
+        end
+        
+        context '' do
+          yield
+        end
+      end
+    end
+  end
+end

data/test/helpers/shoulda_unit_helpers.rb

@@ -0,0 +1,88 @@
+module ShouldaUnitHelpers
+  def self.included(base)
+    base.extend ClassMethods 
+    add_param_checkers(base)
+  end
+  
+  def self.add_param_checkers(base)
+    # Excuse my french but:
+    %w(action branch origin current_branch silent explain).each do |param|
+      base.instance_eval(%Q!
+        def self.should_set_#{param}_to(#{param}_value)
+          should "set #{param} to #{ '#{' }#{ param }_value}" do
+            assert_equal #{param}_value, @p[:#{param}]
+          end
+        end
+      !)
+    end
+    # In other words, create a bunch of helpers like:
+    # 
+    # def self.should_set_explain_to(explain_value)
+    #   should "set explain to #{explain_value}" do
+    #     assert_equal explain_value, @p[:explain]
+    #   end
+    # end
+    
+  end
+  
+  module ClassMethods
+    def should_return_help_for_parameters(params, context_explanation)
+      context context_explanation do
+        setup do
+          @p = grb.read_params params
+        end
+        
+        should "not even get to checking the current_branch" do
+          grb.expects(:get_current_branch).never
+          grb.read_params ['help']
+        end
+        
+        should "only return a hash specifying the action" do
+          assert_array_content [:action], @p.keys
+        end
+        
+        should_set_action_to :help
+      end
+    end
+    
+    def should_explain_with_current_branch(current_branch_value, current_branch_explanation)
+      context "on an 'explain' command" do
+        context "with no information provided other than the action" do
+          setup do
+            @p = grb.read_params %w{explain create}
+          end
+          
+          should_set_explain_to         true
+          should_set_action_to          :create
+          should_set_origin_to          'origin'
+          
+          context current_branch_explanation do
+            should_set_current_branch_to  current_branch_value
+          end
+          
+          should "set a dummy new branch name" do
+            assert @p[:branch]
+          end
+        end
+        
+        context "with all information provided" do
+          setup do
+            @p = grb.read_params %w{explain create specific_branch specific_origin}
+          end
+          
+          should_set_explain_to         true
+          should_set_action_to          :create
+          should_set_current_branch_to  current_branch_value
+          
+          should "set the origin to 'specific_origin'" do
+            assert_equal 'specific_origin', @p[:origin]
+          end
+          
+          should "set the specified branch name" do
+            assert_equal 'specific_branch', @p[:branch]
+          end
+        end
+      end
+    end
+  end
+end

data/test/helpers/temp_dir_helper.rb

@@ -0,0 +1,38 @@
+require 'fileutils'
+require 'tmpdir'
+
+class TempDirHelper
+  include FileUtils
+  
+  attr_reader :directory
+
+  def initialize(force_temp_dir=nil)
+    @directory = get_temp_dir!(force_temp_dir)
+  end
+  
+  def cleanup
+    rm_rf @directory
+  end
+  
+  def to_s
+    directory
+  end
+  
+  private
+    def get_temp_dir!(parent_dir=nil)
+      temp_root = File.expand_path( File.join( parent_dir || Dir::tmpdir) )
+      mkdir_p temp_root
+      
+      #Create new subdir with a random name
+      new_dir=''
+      begin
+        new_dir = File.join( temp_root, "#{rand(10000)}" )
+        mkdir new_dir
+        
+      rescue
+        retry
+      end
+      
+      new_dir
+    end
+end