What is Repository - Getting a Git Repository

Zia

2 Followers

Follow

Feb 9, 2024

-

1 sec read

382

0

0

0

Getting a Git Repository

By now, users know how to successfully set up and configure Git. Git is built for collaborative and repetitive working on a project. Thus, to fully use capabilities and learn about all of its functionalities, one may look at the actions involved in starting a project.

What is a Repository?

Users may want to start a new project, which is likely to have a large number of files involved. The natural course of action is to create a folder (also known as a directory) on the user's computer, which will store all of those files. This folder is usually given a name suitable to the project, and can hence, be the home of any data related to that project. Git makes use of the same approach to version control, by providing users with the concept of a repository. A repository is the highest-level home of all files and documents created in the course of working on a project. A repository can contain all types of files, along with nested repositories, which typically correspond to subsets of a project.

How are Repositories Created?

Git repositories within Git, are equivalent to project folders within one's computer. Thus, when a Git repository is created, it is stored inside the corresponding project's home folder on the local machine. There are two approaches to creating a Git repository:

• Creating a new repository
• Cloning an existing repository
  
  

When a new repository is created, Git creates a sub-folder inside the project folder. This contains all the files that are required to function inside it. This folder is not the user's concern in most cases, as it will be used only by Git. The user must only focus on various operations that are to be committed in this newly created repository over time.

Setting Up the Project Folder

Learners may now look at ways a Git repository can be created while setting up a project folder. Orderly maintenance of a project folder is of crucial importance to the performance of the programmer in that project. A properly maintained project folder with well-considered sub-folders would be a great asset to any programmer. Project files should be appropriately named and the sub-folders should correspond to the subsets of the project. Well-written and comprehensive documentation is also an added advantage. Luckily, Gitt takes care of all of these by virtue of its version control system. Initializing Git in a repository is an operation that only has to be performed once.

Setting up a New Project Folder with Git

While working on a new project, the user will often be required to create a new folder on their local machine. A folder is also known as a directory. Users may also have to add Git version control to it. This can be accomplished in a few simple steps, which are detailed here.

First, create a new folder, and name it appropriately. This can be done using the operating system's GUI or through the command line. Then, open a command prompt and navigate to this newly created folder. Add Git version control to it by executing the following command: git init. After successfully completing this execution, a new subfolder called '.git' will be added to the user project folder. This will contain all of the files required for the maintenance of Git version control in the user project folder.

Adding Git to an Existing Project Folder

Even if a project folder has already been created and some files already exist, Git can be added to it. This is typically useful when one decides to use Git version control after beginning work on their project. To accomplish this, follow these steps:

• First, navigate to the project folder in the command prompt.
• Then, initialize a Git repository in the folder using the following command: git init.
  
  

The .git Directory

The git directory is created as a result of the execution of the 'git init' command. It contains all the data essential to the functioning of the newly created Git repository, that is, it contains metadata. The contents of this repository are mainly of three types.

Git Configuration

Git configuration is a set of possible actions that can be performed on the Git version control system to customize it. Various options are available in Git and these usually are initialized with default values. However, users may change them at will for their convenience. Immediately after installing Git, the user can set a username and e-mail using the configuration. This is an example of the configuration.

Levels of Configuration

While looking for configuration options, Git will look at the local level first, followed by the global level, and then, the system level.

• Local level, which means that any options change, will apply to that repository.
  
  
• Global level, which means that any options changed, will apply to that user across the whole operating system.
  
  
• System level, which means that any options changed, will apply across the entire machine.
  
  

Git Clone

Suppose a user wants to start working on a project that already exists as a repository created by another collaborator. For example, consider the scenario of a developer, Paul, moving out of an organization. His work is assigned to Adam. Instead of overwriting Paul's work, Adam decides to clone his project repository. This means that he can use Paul's files and work on them. The original version does not get modified. Cloning refers to the process of obtaining a copy of an existing Git repository, which may be present on the local machine or in a local file system. This copy can then be used for development.

Using the clone Command

While looking for configuration options, Git will look at the local level first, followed by the global level, and then, the system level. To clone an existing repository into a new one, the user must identify the existing repository. This can be done using the URL associated with that particular repository. The URL uniquely identifies any resource on the Internet - in this case, a repository. After having obtained the required URL, the user should use the following command: git-clone URL, by replacing 'URL' with the required one. The execution of this command results in the creation of a new directory, which has Gitinitialized inside it, producing a .git directory. This is similar to the result of 'git init'.

Setting the Target Name

The process shown in the previous section results in a repository of the same name as the cloned repository. It is also possible to clone an existing repository into a repository of another name on the user's local machine. This can be done as follows: git clone URL repo_name.

First Commit

A repository for a user's project may be created by initializing a new one or cloning an existing one. It is now time to start working on the project. This means that several files will be created. Over the course of working on a project, changes will frequently be made to the user's project folder, such as additions, deletions, and modifications. To bring these changes under the purview of the version control system, they must be committed to Git. In a regular application such as Word, to record permanently the changes made to a file, the user would use the 'Save' option. In the Git version control environment, the equivalent of the 'Save' option is the 'commit' option.

Staging Files

Before a change is made in the repository it can be committed to Git, it must be staged first. The Git version control system must be told that a particular file or set of files should be committed, whenever the next commit happens. Staging is executed using the following command: git add. This command can be used in a number of ways, to stage a single file, a set of files, or a sub-repository. The identifier of what is to be staged is given in the staging command after the keyword 'add'. Consider that inside the my_first_project folder, users have created a folder named 'my_first_folder', and a file named 'my_first_file'. Both of these can be staged.

Committing Files

Once staging has been done, the repository is ready for committing. When a file is committed to Git, the version control system adds this newest version to its records. When a set of changes is committed to Git, the user is required to include a message. This message typically describes the purpose of that committed operation.

The chosen editor will start up after this command is executed, asking for the commit message.

Alternatively, the message can be included in the command itself, by asking for the 'm' option. The command will take the following form: git commit -m "my first commit!".