তার সমস্ত শিশু সহ একটি শাখা মুক্তি


92

আমার কাছে নিম্নলিখিত গিট সংগ্রহস্থল টপোলজি রয়েছে:

A-B-F (master)
   \   D (feature-a)
    \ /
     C (feature)
      \
       E (feature-b)

featureশাখা ছাড় দিয়ে আমি প্রত্যাশা করছিলাম পুরো সাবট্রিটি (শিশু শাখা সহ) পুনরায় চালু করব:

$ git rebase feature master

A-B-F (master)
     \   D (feature-a)
      \ /
       C (feature)
        \
         E (feature-b)

তবে এটিই আসল ফলাফল:

      C' (feature)
     /
A-B-F (master)
   \   D (feature-a)
    \ /
     C
      \
       E (feature-b)

আমি জানি আমি সহজেই সম্পাদন করে ম্যানুয়ালি এটি ঠিক করতে পারি:

$ git rebase --onto feature C feature-a
$ git rebase --onto feature C feature-b

তবে এর সমস্ত শিশু / বংশধর সহ শাখাটি স্বয়ংক্রিয়ভাবে রিবেস করার কোনও উপায় আছে কি?


4
আরও দেখুন আমি কিভাবে একটি সম্পূর্ণ subhistory রি-বেসের ফলে থাকব - তাদের মধ্যে কিছু লিঙ্ক একত্রীকরণ ফলে সঙ্গে বিভিন্ন শাখা, । এই সমাধানের অপ্রীতিকর অংশটি হল নতুন রিবেসড কমিটস এর পরে বিষয় শাখাটিকে পুনরায় সেট করা দরকার।
imz - ইভান জাখারিয়াচেভ

গিট রিবেসের জন্য --onto বিকল্পটি উল্লেখ করার জন্য ধন্যবাদ - এটি আমার সমস্যার সমাধান করেছে
জ্যাকোকনার

7
না করা উচিত $ git rebase feature masterহবে $ git rebase master feature?
hbogert

উত্তর:


40
git branch --contains C | \
xargs -n 1 \
git rebase --committer-date-is-author-date --preserve-merges --onto B C^


4
"গিট শাখা" কমান্ডটি কি বর্তমান শাখার আগে একটি তারা আউটপুট আউট করে না, যদি এই স্ক্রিপ্টটি পুনরায় চালু করার জন্য একটি শাখা বর্তমানে চেক আউট করা হয়?
মার্ক লোদাটো

4
গিট শাখা একটি চীনামাটির বাসন কমান্ড না? এটি করার কোনও উপায় কি এটি ভবিষ্যতের কিছুটা প্রমাণ?
ক্রিস পিফহল

7
অ্যাডাম: নিশ্চিত যে এটাই উপায়, আপনি * এর সাথে লাইন রাখতে চান, আপনি কেবল *টিকেই চান না। এরকম কিছু | টিআর-ডি * আরও উপযুক্ত হবে। যদিও আমার প্রশ্নটি হল: এটি কেন - ওন্টো বি ব্যবহার করছে? আমি ভেবেছিলাম এটি মাস্টারের শীর্ষে রিবেস করা উচিত। এছাড়াও সি B বি এর মতো নয়? সুতরাং আমরা বি থেকে বাদ দিয়ে (বাদ দিয়ে?) সি এর উপরে থাকা প্রতিটি শাখায় ছাড়িয়ে যাচ্ছি ... বি ফলাফল কি ঠিক আগের মতো হবে না?
মারেঞ্জ

4
এর --onto Fপরিবর্তে --onto Bএমনটি হওয়া উচিত নয় , যেমন এই সমস্ত কমিটগুলি বি এর উপর আধ্যাত্মিক, এবং আমরা তাদের এফ এ স্থানান্তর করি ?
বিজ্ঞাপন এন

12

কয়েক বছর আগে আমি এই ধরণের জিনিস পরিচালনা করতে কিছু লিখেছিলাম। (উন্নতির জন্য মন্তব্য অবশ্যই স্বাগত, তবে খুব বেশি বিচার করবেন না - এটি অনেক দিন আগে! আমি পার্লকে এখনও জানতাম না!)

এটি আরও স্থির পরিস্থিতির জন্য বোঝানো হয়েছে - আপনি ফর্মটির কনফিগার প্যারামিটার সেট করে এটি কনফিগার করেন branch.<branch>.autorebaseparent। এটি এমন কোনও শাখাকে স্পর্শ করবে না যার কনফিগার প্যারামিটার সেট নেই। যদি এটি আপনি না চান তবে আপনি খুব বেশি ঝামেলা ছাড়াই সম্ভবত যেখানে এটি চান সেখানে হ্যাক করতে পারেন। আমি গত দু'বছরে সত্যিই এটি খুব বেশি ব্যবহার করি নি, তবে আমি যখন এটি ব্যবহার করেছি তখন সর্বদা এটি যথেষ্ট নিরাপদ এবং স্থিতিশীল বলে মনে হয়েছিল, ভর স্বয়ংক্রিয় রিবেসিংয়ের মাধ্যমে এটি সম্ভব।

সুতরাং এটি এখানে। আপনার কাছে ডাকা একটি ফাইলে এটি সংরক্ষণ করে ব্যবহার git-auto-rebaseকরুন PATH। বাস্তবের -nচেষ্টা করার আগে ড্রাই ড্রাই ( ) বিকল্পটি ব্যবহার করা সম্ভবত এটি একটি ভাল ধারণা । আপনার সত্যিকারের চেয়ে এটি আরও কিছুটা বিশদ হতে পারে তবে এটি আপনাকে কীভাবে পুনর্নির্মাণের চেষ্টা করতে চলেছে এবং কী হবে তা আপনাকে প্রদর্শন করবে। আপনাকে কিছুটা দুঃখ বাঁচাতে পারে।

#!/bin/bash

CACHE_DIR=.git/auto-rebase
TODO=$CACHE_DIR/todo
TODO_BACKUP=$CACHE_DIR/todo.backup
COMPLETED=$CACHE_DIR/completed
ORIGINAL_BRANCH=$CACHE_DIR/original_branch
REF_NAMESPACE=refs/pre-auto-rebase

print_help() {
    echo "Usage:  git auto-rebase [opts]"
    echo "Options:"
    echo "    -n   dry run"
    echo "    -c   continue previous auto-rebase"
    echo "    -a   abort previous auto-rebase"
    echo "         (leaves completed rebases intact)"
}

cleanup_autorebase() {
    rm -rf $CACHE_DIR
    if [ -n "$dry_run" ]; then
        # The dry run should do nothing here. It doesn't create refs, and won't
        # run unless auto-rebase is empty. Leave this here to catch programming
        # errors, and for possible future -f option.
        git for-each-ref --format="%(refname)" $REF_NAMESPACE |
        while read ref; do
            echo git update-ref -d $ref
        done
    else
        git for-each-ref --format="%(refname)" $REF_NAMESPACE |
        while read ref; do
            git update-ref -d $ref
        done
    fi
}

# Get the rebase relationships from branch.*.autorebaseparent
get_config_relationships() {
    mkdir -p .git/auto-rebase
    # We cannot simply read the indicated parents and blindly follow their
    # instructions; they must form a directed acyclic graph (like git!) which
    # furthermore has no sources with two sinks (i.e. a branch may not be
    # rebased onto two others).
    # 
    # The awk script checks for cycles and double-parents, then sorts first by
    # depth of hierarchy (how many parents it takes to get to a top-level
    # parent), then by parent name. This means that all rebasing onto a given
    # parent happens in a row - convenient for removal of cached refs.
    IFS=$'\n'
    git config --get-regexp 'branch\..+\.autorebaseparent' | \
    awk '{
        child=$1
        sub("^branch[.]","",child)
        sub("[.]autorebaseparent$","",child)
        if (parent[child] != 0) {
            print "Error: branch "child" has more than one parent specified."
            error=1
            exit 1
        }
        parent[child]=$2
    }
    END {
        if ( error != 0 )
            exit error
        # check for cycles
        for (child in parent) {
            delete cache
            depth=0
            cache[child]=1
            cur=child
            while ( parent[cur] != 0 ) {
                depth++
                cur=parent[cur]
                if ( cache[cur] != 0 ) {
                    print "Error: cycle in branch."child".autorebaseparent hierarchy detected"
                    exit 1
                } else {
                    cache[cur]=1
                }
            }
            depths[child]=depth" "parent[child]" "child
        }
        n=asort(depths, children)
        for (i=1; i<=n; i++) {
            sub(".* ","",children[i])
        }
        for (i=1; i<=n; i++) {
            if (parent[children[i]] != 0)
                print parent[children[i]],children[i]
        }
    }' > $TODO

    # Check for any errors. If the awk script's good, this should really check
    # exit codes.
    if grep -q '^Error:' $TODO; then
        cat $TODO
        rm -rf $CACHE_DIR
        exit 1
    fi

    cp $TODO $TODO_BACKUP
}

# Get relationships from config, or if continuing, verify validity of cache
get_relationships() {
    if [ -n "$continue" ]; then
        if [ ! -d $CACHE_DIR ]; then
            echo "Error: You requested to continue a previous auto-rebase, but"
            echo "$CACHE_DIR does not exist."
            exit 1
        fi
        if [ -f $TODO -a -f $TODO_BACKUP -a -f $ORIGINAL_BRANCH ]; then
            if ! cat $COMPLETED $TODO | diff - $TODO_BACKUP; then
                echo "Error: You requested to continue a previous auto-rebase, but the cache appears"
                echo "to be invalid (completed rebases + todo rebases != planned rebases)."
                echo "You may attempt to manually continue from what is stored in $CACHE_DIR"
                echo "or remove it with \"git auto-rebase -a\""
                exit 1
            fi
        else
            echo "Error: You requested to continue a previous auto-rebase, but some cached files"
            echo "are missing."
            echo "You may attempt to manually continue from what is stored in $CACHE_DIR"
            echo "or remove it with \"git auto-rebase -a\""
            exit 1
        fi
    elif [ -d $CACHE_DIR ]; then
        echo "A previous auto-rebase appears to have been left unfinished."
        echo "Either continue it with \"git auto-rebase -c\" or remove the cache with"
        echo "\"git auto-rebase -a\""
        exit 1
    else
        get_config_relationships
    fi
}

# Verify that desired branches exist, and pre-refs do not.
check_ref_existence() {
    local parent child
    for pair in "${pairs[@]}"; do
        parent="${pair% *}"
        if ! git show-ref -q --verify "refs/heads/$parent" > /dev/null ; then
            if ! git show-ref -q --verify "refs/remotes/$parent" > /dev/null; then
                child="${pair#* }"
                echo "Error: specified parent branch $parent of branch $child does not exist"
                exit 1
            fi
        fi
        if [ -z "$continue" ]; then
            if git show-ref -q --verify "$REF_NAMESPACE/$parent" > /dev/null; then
                echo "Error: ref $REF_NAMESPACE/$parent already exists"
                echo "Most likely a previous git-auto-rebase did not complete; if you have fixed all"
                echo "necessary rebases, you may try again after removing it with:"
                echo
                echo "git update-ref -d $REF_NAMESPACE/$parent"
                echo
                exit 1
            fi
        else
            if ! git show-ref -q --verify "$REF_NAMESPACE/$parent" > /dev/null; then
                echo "Error: You requested to continue a previous auto-rebase, but the required"
                echo "cached ref $REF_NAMESPACE/$parent is missing."
                echo "You may attempt to manually continue from the contents of $CACHE_DIR"
                echo "and whatever refs in refs/$REF_NAMESPACE still exist, or abort the previous"
                echo "auto-rebase with \"git auto-rebase -a\""
                exit 1
            fi
        fi
    done
}

# Create the pre-refs, storing original position of rebased parents
create_pre_refs() {
    local parent prev_parent
    for pair in "${pairs[@]}"; do
        parent="${pair% *}"
        if [ "$prev_parent" != "$parent" ]; then
            if [ -n "$dry_run" ]; then
                echo git update-ref "$REF_NAMESPACE/$parent" "$parent" \"\"
            else
                if ! git update-ref "$REF_NAMESPACE/$parent" "$parent" ""; then
                    echo "Error: cannot create ref $REF_NAMESPACE/$parent"
                    exit 1
                fi
            fi
        fi

        prev_parent="$parent"
    done
}

# Perform the rebases, updating todo/completed as we go
perform_rebases() {
    local prev_parent parent child
    for pair in "${pairs[@]}"; do
        parent="${pair% *}"
        child="${pair#* }"

        # We do this *before* rebasing, assuming most likely any failures will be
        # fixed with rebase --continue, and therefore should not be attempted again
        head -n 1 $TODO >> $COMPLETED
        sed -i '1d' $TODO

        if [ -n "$dry_run" ]; then
            echo git rebase --onto "$parent" "$REF_NAMESPACE/$parent" "$child"
            echo "Successfully rebased $child onto $parent"
        else
            echo git rebase --onto "$parent" "$REF_NAMESPACE/$parent" "$child"
            if ( git merge-ff -q "$child" "$parent" 2> /dev/null && echo "Fast-forwarded $child to $parent." ) || \
                git rebase --onto "$parent" "$REF_NAMESPACE/$parent" "$child"; then
                echo "Successfully rebased $child onto $parent"
            else
                echo "Error rebasing $child onto $parent."
                echo 'You should either fix it (end with git rebase --continue) or abort it, then use'
                echo '"git auto-rebase -c" to continue. You may also use "git auto-rebase -a" to'
                echo 'abort the auto-rebase. Note that this will not undo already-completed rebases.'
                exit 1
            fi
        fi

        prev_parent="$parent"
    done
}

rebase_all_intelligent() {
    if ! git rev-parse --show-git-dir &> /dev/null; then
        echo "Error: git-auto-rebase must be run from inside a git repository"
        exit 1
    fi

    SUBDIRECTORY_OK=1
    . "$(git --exec-path | sed 's/:/\n/' | grep -m 1 git-core)"/git-sh-setup
    cd_to_toplevel


    # Figure out what we need to do (continue, or read from config)
    get_relationships

    # Read the resulting todo list
    OLDIFS="$IFS"
    IFS=$'\n'
    pairs=($(cat $TODO))
    IFS="$OLDIFS"

    # Store the original branch
    if [ -z "$continue" ]; then
        git symbolic-ref HEAD | sed 's@refs/heads/@@' > $ORIGINAL_BRANCH
    fi

    check_ref_existence
    # These three depend on the pairs array
    if [ -z "$continue" ]; then
        create_pre_refs
    fi
    perform_rebases

    echo "Returning to original branch"
    if [ -n "$dry_run" ]; then
        echo git checkout $(cat $ORIGINAL_BRANCH)
    else
        git checkout $(cat $ORIGINAL_BRANCH) > /dev/null
    fi

    if diff -q $COMPLETED $TODO_BACKUP ; then
        if [ "$(wc -l $TODO | cut -d" " -f1)" -eq 0 ]; then
            cleanup_autorebase
            echo "Auto-rebase complete"
        else
            echo "Error: todo-rebases not empty, but completed and planned rebases match."
            echo "This should not be possible, unless you hand-edited a cached file."
            echo "Examine $TODO, $TODO_BACKUP, and $COMPLETED to determine what went wrong."
            exit 1
        fi
    else
        echo "Error: completed rebases don't match planned rebases."
        echo "Examine $TODO_BACKUP and $COMPLETED to determine what went wrong."
        exit 1
    fi
}


while getopts "nca" opt; do
    case $opt in
        n ) dry_run=1;;
        c ) continue=1;;
        a ) abort=1;;
        * )
            echo "git-auto-rebase is too dangerous to run with invalid options; exiting"
            print_help
            exit 1
    esac
done
shift $((OPTIND-1))


case $# in
    0 )
        if [ -n "$abort" ]; then
            cleanup_autorebase
        else
            rebase_all_intelligent
        fi
        ;;

    * )
        print_help
        exit 1
        ;;
esac

একটি জিনিস যা আমি খুঁজে পেয়েছি, যেহেতু আমি মূলত এটি সম্বোধন করেছি, তা হ'ল কখনও কখনও উত্তরটি হ'ল আপনি আসলে পুনর্বাসনা করতে চাননি! প্রথমে ডান সাধারণ পূর্বপুরুষে টপিক শাখাগুলি শুরু করার জন্য এবং তার পরে তাদের এগিয়ে যাওয়ার চেষ্টা না করার জন্য কিছু বলার আছে। তবে এটি আপনার এবং আপনার কর্মপ্রবাহের মধ্যে।


উপবিষ্টিত "পরিবর্তে মার্জ ব্যবহার করুন"। একত্রীকরণ বিকল্পটি ব্যবহার করার আগে আমি অনেক বিষয় এবং সাবটোপিক শাখাগুলি পুনরায় প্রত্যাবর্তনের চেষ্টা করার জন্য বেশ কয়েক ঘন্টা ব্যয় করেছি এবং নতুন মাস্টার মূল মাস্টার থেকে ভারীভাবে বিচ্যুত হওয়া সত্ত্বেও, মার্জ করা কার্য সম্পাদন করা অনেক সহজ ছিল।
davenpcj

4
এটি আমাকে কিছুটা ভয় দেখায় যে উত্তরটি রয়েছে: "আমি এখনও পার্লকে জানতাম না" - বিশেষত যেহেতু উত্তরটি পার্ল-তে লেখা নেই ...
...-)

@ পিটারভি.মার্চ, মানে?
পেসারিয়ার

0

যদি কোন প্রতিশ্রুতিবদ্ধতার তারিখ আপডেট করার প্রয়োজন হয় , GIT_COMMITTER_DATEপরিবেশের পরিবর্তনশীল ব্যবহার করতে পারেন ( ম্যানুয়াল )। --formatঅতিরিক্ত বিন্যাস ছাড়াই একটি শাখার নাম পেতে বিকল্পটিও ব্যবহার করুন।

export GIT_COMMITTER_DATE=$( date -Iseconds )
git branch --format='%(refname)' --contains C | xargs -n 1 | git rebase -p --onto master C^
unset GIT_COMMITTER_DATE
# don't forget to unset this variable to avoid effect for the further work

বিশেষ দ্রষ্টব্য: এটা হয় সেট করতে প্রয়োজন বোধ করা হয় --committer-date-is-author-dateবা GIT_COMMITTER_DATEএকই চেকসাম গ্যারান্টি C', Ca'এবং Cb'(rebasing উপর করে বৈশিষ্ট্য , বৈশিষ্ট্য একটি এবং বৈশিষ্ট্য-B সঙ্গতিপূর্ণভাবেই)।

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.