RepositoryState.java

  1. /*
  2.  * Copyright (C) 2008, Mike Ralphson <mike@abacus.co.uk>
  3.  * Copyright (C) 2008, Robin Rosenberg <robin.rosenberg.lists@dewire.com>
  4.  * Copyright (C) 2007, Robin Rosenberg <robin.rosenberg@dewire.com>
  5.  * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org> and others
  6.  *
  7.  * This program and the accompanying materials are made available under the
  8.  * terms of the Eclipse Distribution License v. 1.0 which is available at
  9.  * https://www.eclipse.org/org/documents/edl-v10.php.
  10.  *
  11.  * SPDX-License-Identifier: BSD-3-Clause
  12.  */

  13. package org.eclipse.jgit.lib;

  14. import org.eclipse.jgit.internal.JGitText;
  15. /**
  16.  * Important state of the repository that affects what can and cannot bed
  17.  * done. This is things like unhandled conflicted merges and unfinished rebase.
  18.  *
  19.  * The granularity and set of states are somewhat arbitrary. The methods
  20.  * on the state are the only supported means of deciding what to do.
  21.  */
  22. public enum RepositoryState {
  23.     /** Has no work tree and cannot be used for normal editing. */
  24.     BARE {
  25.         @Override
  26.         public boolean canCheckout() { return false; }

  27.         @Override
  28.         public boolean canResetHead() { return false; }

  29.         @Override
  30.         public boolean canCommit() { return false; }

  31.         @Override
  32.         public boolean canAmend() { return false; }

  33.         @Override
  34.         public boolean isRebasing() { return false; }

  35.         @Override
  36.         public String getDescription() {
  37.             return JGitText.get().repositoryState_bare;
  38.         }
  39.     },

  40.     /**
  41.      * A safe state for working normally
  42.      * */
  43.     SAFE {
  44.         @Override
  45.         public boolean canCheckout() { return true; }

  46.         @Override
  47.         public boolean canResetHead() { return true; }

  48.         @Override
  49.         public boolean canCommit() { return true; }

  50.         @Override
  51.         public boolean canAmend() { return true; }

  52.         @Override
  53.         public boolean isRebasing() { return false; }

  54.         @Override
  55.         public String getDescription() { return JGitText.get().repositoryState_normal; }
  56.     },

  57.     /** An unfinished merge. Must resolve or reset before continuing normally
  58.      */
  59.     MERGING {
  60.         @Override
  61.         public boolean canCheckout() { return false; }

  62.         @Override
  63.         public boolean canResetHead() { return true; }

  64.         @Override
  65.         public boolean canCommit() { return false; }

  66.         @Override
  67.         public boolean canAmend() { return false; }

  68.         @Override
  69.         public boolean isRebasing() { return false; }

  70.         @Override
  71.         public String getDescription() { return JGitText.get().repositoryState_conflicts; }
  72.     },

  73.     /**
  74.      * An merge where all conflicts have been resolved. The index does not
  75.      * contain any unmerged paths.
  76.      */
  77.     MERGING_RESOLVED {
  78.         @Override
  79.         public boolean canCheckout() { return true; }

  80.         @Override
  81.         public boolean canResetHead() { return true; }

  82.         @Override
  83.         public boolean canCommit() { return true; }

  84.         @Override
  85.         public boolean canAmend() { return false; }

  86.         @Override
  87.         public boolean isRebasing() { return false; }

  88.         @Override
  89.         public String getDescription() { return JGitText.get().repositoryState_merged; }
  90.     },

  91.     /** An unfinished cherry-pick. Must resolve or reset before continuing normally
  92.      */
  93.     CHERRY_PICKING {
  94.         @Override
  95.         public boolean canCheckout() { return false; }

  96.         @Override
  97.         public boolean canResetHead() { return true; }

  98.         @Override
  99.         public boolean canCommit() { return false; }

  100.         @Override
  101.         public boolean canAmend() { return false; }

  102.         @Override
  103.         public boolean isRebasing() { return false; }

  104.         @Override
  105.         public String getDescription() { return JGitText.get().repositoryState_conflicts; }
  106.     },

  107.     /**
  108.      * A cherry-pick where all conflicts have been resolved. The index does not
  109.      * contain any unmerged paths.
  110.      */
  111.     CHERRY_PICKING_RESOLVED {
  112.         @Override
  113.         public boolean canCheckout() { return true; }

  114.         @Override
  115.         public boolean canResetHead() { return true; }

  116.         @Override
  117.         public boolean canCommit() { return true; }

  118.         @Override
  119.         public boolean canAmend() { return false; }

  120.         @Override
  121.         public boolean isRebasing() { return false; }

  122.         @Override
  123.         public String getDescription() { return JGitText.get().repositoryState_merged; }
  124.     },

  125.     /** An unfinished revert. Must resolve or reset before continuing normally
  126.      */
  127.     REVERTING {
  128.         @Override
  129.         public boolean canCheckout() { return false; }

  130.         @Override
  131.         public boolean canResetHead() { return true; }

  132.         @Override
  133.         public boolean canCommit() { return false; }

  134.         @Override
  135.         public boolean canAmend() { return false; }

  136.         @Override
  137.         public boolean isRebasing() { return false; }

  138.         @Override
  139.         public String getDescription() { return JGitText.get().repositoryState_conflicts; }
  140.     },

  141.     /**
  142.      * A revert where all conflicts have been resolved. The index does not
  143.      * contain any unmerged paths.
  144.      */
  145.     REVERTING_RESOLVED {
  146.         @Override
  147.         public boolean canCheckout() { return true; }

  148.         @Override
  149.         public boolean canResetHead() { return true; }

  150.         @Override
  151.         public boolean canCommit() { return true; }

  152.         @Override
  153.         public boolean canAmend() { return false; }

  154.         @Override
  155.         public boolean isRebasing() { return false; }

  156.         @Override
  157.         public String getDescription() { return JGitText.get().repositoryState_merged; }
  158.     },

  159.     /**
  160.      * An unfinished rebase or am. Must resolve, skip or abort before normal work can take place
  161.      */
  162.     REBASING {
  163.         @Override
  164.         public boolean canCheckout() { return false; }

  165.         @Override
  166.         public boolean canResetHead() { return false; }

  167.         @Override
  168.         public boolean canCommit() { return true; }

  169.         @Override
  170.         public boolean canAmend() { return true; }

  171.         @Override
  172.         public boolean isRebasing() { return true; }

  173.         @Override
  174.         public String getDescription() { return JGitText.get().repositoryState_rebaseOrApplyMailbox; }
  175.     },

  176.     /**
  177.      * An unfinished rebase. Must resolve, skip or abort before normal work can take place
  178.      */
  179.     REBASING_REBASING {
  180.         @Override
  181.         public boolean canCheckout() { return false; }

  182.         @Override
  183.         public boolean canResetHead() { return false; }

  184.         @Override
  185.         public boolean canCommit() { return true; }

  186.         @Override
  187.         public boolean canAmend() { return true; }

  188.         @Override
  189.         public boolean isRebasing() { return true; }

  190.         @Override
  191.         public String getDescription() { return JGitText.get().repositoryState_rebase; }
  192.     },

  193.     /**
  194.      * An unfinished apply. Must resolve, skip or abort before normal work can take place
  195.      */
  196.     APPLY {
  197.         @Override
  198.         public boolean canCheckout() { return false; }

  199.         @Override
  200.         public boolean canResetHead() { return false; }

  201.         @Override
  202.         public boolean canCommit() { return true; }

  203.         @Override
  204.         public boolean canAmend() { return true; }

  205.         @Override
  206.         public boolean isRebasing() { return false; }

  207.         @Override
  208.         public String getDescription() { return JGitText.get().repositoryState_applyMailbox; }
  209.     },

  210.     /**
  211.      * An unfinished rebase with merge. Must resolve, skip or abort before normal work can take place
  212.      */
  213.     REBASING_MERGE {
  214.         @Override
  215.         public boolean canCheckout() { return false; }

  216.         @Override
  217.         public boolean canResetHead() { return false; }

  218.         @Override
  219.         public boolean canCommit() { return true; }

  220.         @Override
  221.         public boolean canAmend() { return true; }

  222.         @Override
  223.         public boolean isRebasing() { return true; }

  224.         @Override
  225.         public String getDescription() { return JGitText.get().repositoryState_rebaseWithMerge; }
  226.     },

  227.     /**
  228.      * An unfinished interactive rebase. Must resolve, skip or abort before normal work can take place
  229.      */
  230.     REBASING_INTERACTIVE {
  231.         @Override
  232.         public boolean canCheckout() { return false; }

  233.         @Override
  234.         public boolean canResetHead() { return false; }

  235.         @Override
  236.         public boolean canCommit() { return true; }

  237.         @Override
  238.         public boolean canAmend() { return true; }

  239.         @Override
  240.         public boolean isRebasing() { return true; }

  241.         @Override
  242.         public String getDescription() { return JGitText.get().repositoryState_rebaseInteractive; }
  243.     },

  244.     /**
  245.      * Bisecting being done. Normal work may continue but is discouraged
  246.      */
  247.     BISECTING {
  248.         /* Changing head is a normal operation when bisecting */
  249.         @Override
  250.         public boolean canCheckout() { return true; }

  251.         /* Do not reset, checkout instead */
  252.         @Override
  253.         public boolean canResetHead() { return false; }

  254.         /* Commit during bisect is useful */
  255.         @Override
  256.         public boolean canCommit() { return true; }

  257.         @Override
  258.         public boolean canAmend() { return false; }

  259.         @Override
  260.         public boolean isRebasing() { return false; }

  261.         @Override
  262.         public String getDescription() { return JGitText.get().repositoryState_bisecting; }
  263.     };

  264.     /**
  265.      * Whether checkout can be done.
  266.      *
  267.      * @return whether checkout can be done.
  268.      */
  269.     public abstract boolean canCheckout();

  270.     /**
  271.      * @return true if we can commit
  272.      */
  273.     public abstract boolean canCommit();

  274.     /**
  275.      * @return true if reset to another HEAD is considered SAFE
  276.      */
  277.     public abstract boolean canResetHead();

  278.     /**
  279.      * @return true if amending is considered SAFE
  280.      */
  281.     public abstract boolean canAmend();

  282.     /**
  283.      * @return true if the repository is currently in a rebase
  284.      * @since 3.0
  285.      */
  286.     public abstract boolean isRebasing();

  287.     /**
  288.      * @return a human readable description of the state.
  289.      */
  290.     public abstract String getDescription();
  291. }