Skip to content

Using_Git

Youcef SKLAB edited this page Feb 21, 2020 · 22 revisions

Using Git from GAMA to version and share models

To use Git in GAMA select Views -> Other... -> Show View -> Other...

In the Show view window that appears select Git -> Git Repositories and click on Open

Show View Window

Creating Local Repository

With Git you can easily create local repositories to version your work locally. First, you have to create a GAMA project (e.g GitNewProject) that you want to share via your local repository.

After you have created your GAMA project, go to the Git Repository view and click on Create a new local Git repository.

Create New Local Git Repository

In the following window specify the directory for the new repository (select the folder of the created GAMA project in the last step - GitNewProject -), throught the button Browse...

Select folder new local Repository

then hit the Create button.

Create Button

Now your local repository is created, you can add models and files into your GAMA project. As you selected the folder of the new created GAMA Project, the repository will not be empty. So, it will be initialized with all the folders and files of the GAMA projet. Note the changed icons: the project node will have a repository icon, the child nodes will have an icon with a question mark.

Changed icons

Before you can commit the files to your repository, you need to add them. Simply right click the shared project’s node and navigate to Team -> Add to Index.

Add Ignore Commit from Menu

After this operation, the question mark should change to a plus symbol.

Icons Changed after add

To set certain folders or files to be ignored by Git, right click them and select Team -> Ignore. The ignored items will be stored in a file called .gitignore, which you should add to the repository.

Commit

Now you can modify files in your project, save changes made in your workspace to your repository and commit them. You can do commit the projec by right clicking the project node and selecting Team -> Commit… from the context menu. In the Commit wizard, all files should be selected automatically. Enter a commit message and hit the Commit button.

Icons Changed after add

If the commit was successful, the plus symbols will have turned into repository icons.

Icons Changed after commit

After changing files in your project, a “>” sign will appear right after the icon, telling you the status of these files is dirty. Any parent folder of this file will be marked as dirty as well.

Changes to commit

If you want to commit the changes to your repository, right click the project (or the files you want to commit) and select Team => Commit… . Enter a commit message and click Commit to commit the selected files to your repository.

Adding Files

To add a new file to the repository, you need to create it in your shared GAMA project first. Then, the new file will appear with a question mark.

New file added to project

Right click it and navigate to Team => Add to Index. The question mark will turn into a plus symbol and the file will be tracked by Git, but it is not yet committed. In the next commit, the file will be added to the repository and the plus symbol will turn into a repository icon.

Commit new added file

Reverting Changes

If you want to revert any changes, there are two options. You can compare each file you want to revert with the HEAD revision (or the index, or the previous version) and undo some or all changes done. Second, you can hard reset your project, causing any changes to be reverted.

Revert via Compare

Right click the file you want to revert and select Compare With -> HEAD Revision. This will open a comparison with the HEAD Revision, highlighting any changes done. You can revert several lines. select the line you want to revert and hit the Copy Current Change from Right to Left button (in the toolbar).

Revert by Compare

Revert via Reset

To reset all changes made to your project, right click the project node and navigate to Team -> Reset… . Select the branch you want to reset to (if you haven’t created any other branches, there will be just one). Click the reset button. All changes will be reset to this branch’s last commit. Be careful with this option as all changes in your GamaProject will be lost.

Revert by Reset

Cloning Repositories

To checkout a remote project, you will have to clone its repository first. Open the GAMA Import wizard: right click the User models node -> Import... -> Other...

Import git project

Select Git -> Projects from Git and click Next.

Import git project - Next

Select “Clone URI” and click next.

Repository URI

Now you will have to enter the repository’s location. Entering the URI will automatically fill some fields. Complete any other required fields and hit Next (e.g, Authentification fields). If you use GitHub, you can copy the URI from the web page.

Repository location

Select all branches you wish to clone and hit Next again.

Branch Selection

Hit next, then choose a local storage location to save the repository in.

Set local location

To import the projects, select the cloned repository and hit Next.

Select Import Existing Projects and hit Next.

Select a wizard to use

In the following window, select all projects you want to import and click Finish.

Select projects to import

The projects should now appear in the Models Explorer. (Note the repository symbol in the icons indicating that the projects are already shared.)

Imported projects

Creating Branches

To create a new branch in your repository, right click your project and navigate to Team -> Switch to -> New Branch… from the context menu. Select the branch you want to create a new branch from, hit New branch and enter a name for the new branch.

Create new branch

The new branch (NewBranch) should appear in the branch selection window.

Created new branch

You can see all the branches in the Git Repositories view.

New branches view

If you would like to checkout the a branch, select it and click Checkout.

Check out a branch

Merge

To merge one branch into another, right click the project node and navigate to Team -> Merge…

Merge a branch

The merge will execute and a window will pop-up with the results. The possible results are Already-up-to-date, Fast-forward, Merged, Conflicting, Failed.

Merge a branch

Note that a conflicting result will leave the merge process incomplete. You will have to resolve the conflicts and try again. When there are conflicting changes in the working project, the merge will fail.

Fetch and Pull

To update the remote branches when cloning remote repositories (Git creates copies of the branches as local branches and as remote branches) you will have to use Fetch. To perform a Fetch, select Team -> Fetch From… from the project’s context menu.

To update your local branches, you will have to perform a Merge operation after fetching.

Pull

Pull combines Fetch and Merge. Select Team -> Pull.

Push

Local changes made to your local branches can be pushed to remote repositories causing a merge from your branches into the branches of the remote repository (X pulls from Y is the same as Y pushes to X). The Push wizard is pretty much the same as the Fetch wizard.

Git Push

History View

To show the repository history, right click it and select Team -> Show in History. This will open the History View, giving an overview of the commits and allowing you to perform several actions (creating branches/tags, revert, reset…).

Git Push

  1. What's new (Changelog)
  1. Installation and Launching
    1. Installation
    2. Launching GAMA
    3. Updating GAMA
    4. Installing Plugins
  2. Workspace, Projects and Models
    1. Navigating in the Workspace
    2. Changing Workspace
    3. Importing Models
  3. Editing Models
    1. GAML Editor (Generalities)
    2. GAML Editor Tools
    3. Validation of Models
  4. Running Experiments
    1. Launching Experiments
    2. Experiments User interface
    3. Controls of experiments
    4. Parameters view
    5. Inspectors and monitors
    6. Displays
    7. Batch Specific UI
    8. Errors View
  5. Running Headless
    1. Headless Batch
    2. Headless Server
    3. Headless Legacy
  6. Preferences
  7. Troubleshooting
  1. Introduction
    1. Start with GAML
    2. Organization of a Model
    3. Basic programming concepts in GAML
  2. Manipulate basic Species
  3. Global Species
    1. Regular Species
    2. Defining Actions and Behaviors
    3. Interaction between Agents
    4. Attaching Skills
    5. Inheritance
  4. Defining Advanced Species
    1. Grid Species
    2. Graph Species
    3. Mirror Species
    4. Multi-Level Architecture
  5. Defining GUI Experiment
    1. Defining Parameters
    2. Defining Displays Generalities
    3. Defining 3D Displays
    4. Defining Charts
    5. Defining Monitors and Inspectors
    6. Defining Export files
    7. Defining User Interaction
  6. Exploring Models
    1. Run Several Simulations
    2. Batch Experiments
    3. Exploration Methods
  7. Optimizing Model Section
    1. Runtime Concepts
    2. Optimizing Models
  8. Multi-Paradigm Modeling
    1. Control Architecture
    2. Defining Differential Equations
  1. Manipulate OSM Data
  2. Diffusion
  3. Using Database
  4. Using FIPA ACL
  5. Using BDI with BEN
  6. Using Driving Skill
  7. Manipulate dates
  8. Manipulate lights
  9. Using comodel
  10. Save and restore Simulations
  11. Using network
  12. Headless mode
  13. Using Headless
  14. Writing Unit Tests
  15. Ensure model's reproducibility
  16. Going further with extensions
    1. Calling R
    2. Using Graphical Editor
    3. Using Git from GAMA
  1. Built-in Species
  2. Built-in Skills
  3. Built-in Architecture
  4. Statements
  5. Data Type
  6. File Type
  7. Expressions
    1. Literals
    2. Units and Constants
    3. Pseudo Variables
    4. Variables And Attributes
    5. Operators [A-A]
    6. Operators [B-C]
    7. Operators [D-H]
    8. Operators [I-M]
    9. Operators [N-R]
    10. Operators [S-Z]
  8. Exhaustive list of GAMA Keywords
  1. Installing the GIT version
  2. Developing Extensions
    1. Developing Plugins
    2. Developing Skills
    3. Developing Statements
    4. Developing Operators
    5. Developing Types
    6. Developing Species
    7. Developing Control Architectures
    8. Index of annotations
  3. Introduction to GAMA Java API
    1. Architecture of GAMA
    2. IScope
  4. Using GAMA flags
  5. Creating a release of GAMA
  6. Documentation generation

  1. Predator Prey
  2. Road Traffic
  3. 3D Tutorial
  4. Incremental Model
  5. Luneray's flu
  6. BDI Agents

  1. Team
  2. Projects using GAMA
  3. Scientific References
  4. Training Sessions

Resources

  1. Videos
  2. Conferences
  3. Code Examples
  4. Pedagogical materials
Clone this wiki locally