doc/user/packages/workflows/build_packages.md
Use the GitLab package registry to install and build packages for different package formats.
Create a directory called my-composer-package and change to that directory:
mkdir my-composer-package && cd my-composer-package
Run composer init and answer the prompts.
For namespace, enter your unique namespace, like your GitLab username or group name.
A file called composer.json is created:
{
"name": "<namespace>/composer-test",
"description": "Library XY",
"type": "library",
"license": "GPL-3.0-only",
"authors": [
{
"name": "John Doe",
"email": "[email protected]"
}
],
"require": {}
}
Prerequisites:
Download the Conan package manager to your local development environment by following the instructions at conan.io.
When installation is complete, verify you can use Conan in your terminal by running:
conan --version
The Conan version is printed in the output:
Conan version 1.20.5
When you develop with C++ and Conan, you can select from many available compilers. This example uses the CMake build system generator.
To install CMake:
brew install cmake.When installation is complete, verify you can use CMake in your terminal by running:
cmake --version
The CMake version is printed in the output.
To test the package registry, you need a C++ project. If you don't already have one, you can clone the Conan hello world starter project.
To build a package:
Open a terminal and go to your project's root folder.
Generate a new recipe by running conan new with a package name and version:
conan new Hello/0.1 -t
Create a package for the recipe by running conan create with the Conan user
and channel:
conan create . mycompany/beta
[!note] If you use an instance remote, you must follow a specific naming convention.
A package with the recipe Hello/0.1@mycompany/beta is created.
For more details about creating and managing Conan packages, see the Conan documentation.
Prerequisites:
Install the Conan package manager to your local development environment by following the instructions at conan.io.
When you complete the installation, run the following command to verify you can use Conan in your terminal:
conan --version
The Conan version is printed in the output:
Conan version 2.17.0
You must define a profile for Conan 2. If you already defined a profile, skip this step.
To create a profile, run the following command:
conan profile detect
Check the profile:
conan profile list
The command lists the profile in the output:
Profiles found in the cache:
default
The generated profile is usually enough to get started. For more information on Conan profiles, see Conan 2 profiles.
When you develop with C++ and Conan, you can select from many available compilers. The following example uses the CMake build system generator.
Prerequisites:
When installation is complete, verify you can use CMake in your terminal with the following command:
cmake --version
The CMake version is printed in the output.
Prerequisites:
Go to your local project folder and use the conan new command to create a “Hello World” C++ library example project with the cmake_lib template:
mkdir hello && cd hello
conan new cmake_lib -d name=hello -d version=0.1
For more advanced examples, see the Conan 2 examples project.
Prerequisites:
To build a package:
Make sure you are in the hello folder created in the previous section.
Create a package for the recipe by running conan create with the Conan user
and channel:
conan create . --channel=beta --user=mycompany
A package with the recipe hello/0.1@mycompany/beta is created.
For more details about creating and managing Conan packages, see Creating packages.
The required minimum versions are:
Follow the instructions at maven.apache.org to download and install Maven for your local development environment. After installation is complete, verify you can use Maven in your terminal by running:
mvn --version
The output should be similar to:
Apache Maven 3.6.1 (d66c9c0b3152b2e69ee9bac180bb8fcc8e6af555; 2019-04-04T20:00:29+01:00)
Maven home: /Users/<your_user>/apache-maven-3.6.1
Java version: 12.0.2, vendor: Oracle Corporation, runtime: /Library/Java/JavaVirtualMachines/jdk-12.0.2.jdk/Contents/Home
Default locale: en_GB, platform encoding: UTF-8
OS name: "mac os x", version: "10.15.2", arch: "x86_64", family: "mac"
Open your terminal and create a directory to store the project.
From the new directory, run this Maven command to initialize a new package:
mvn archetype:generate -DgroupId=com.mycompany.mydepartment -DartifactId=my-project -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
The arguments are:
DgroupId: A unique string that identifies your package. Follow
the Maven naming conventions.DartifactId: The name of the JAR, appended to the end of the DgroupId.DarchetypeArtifactId: The archetype used to create the initial structure of
the project.DinteractiveMode: Create the project using batch mode (optional).This message indicates that the project was set up successfully:
...
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.429 s
[INFO] Finished at: 2020-01-28T11:47:04Z
[INFO] ------------------------------------------------------------------------
In the folder where you ran the command, a new directory should be displayed.
The directory name should match the DartifactId parameter, which in this case,
is my-project.
If you want to create a new Gradle project, you must install Gradle. Follow instructions at gradle.org to download and install Gradle for your local development environment.
In your terminal, verify you can use Gradle by running:
gradle -version
To use an existing Gradle project, in the project directory,
on Linux execute gradlew, or on Windows execute gradlew.bat.
The output should be similar to:
------------------------------------------------------------
Gradle 6.0.1
------------------------------------------------------------
Build time: 2019-11-18 20:25:01 UTC
Revision: fad121066a68c4701acd362daf4287a7c309a0f5
Kotlin: 1.3.50
Groovy: 2.5.8
Ant: Apache Ant(TM) version 1.10.7 compiled on September 1 2019
JVM: 11.0.5 (Oracle Corporation 11.0.5+10)
OS: Windows 10 10.0 amd64
Open your terminal and create a directory to store the project.
From this new directory, run this command to initialize a new package:
gradle init
The output should be:
Select type of project to generate:
1: basic
2: application
3: library
4: Gradle plugin
Enter selection (default: basic) [1..4]
Enter 3 to create a new Library project. The output should be:
Select implementation language:
1: C++
2: Groovy
3: Java
4: Kotlin
5: Scala
6: Swift
Enter 3 to create a new Java Library project. The output should be:
Select build script DSL:
1: Groovy
2: Kotlin
Enter selection (default: Groovy) [1..2]
Enter 1 to create a new Java Library project that is described in Groovy DSL, or 2 to create one that is described in Kotlin DSL. The output should be:
Select test framework:
1: JUnit 4
2: TestNG
3: Spock
4: JUnit Jupiter
Enter 1 to initialize the project with JUnit 4 testing libraries. The output should be:
Project name (default: test):
Enter a project name or press <kbd>Enter</kbd> to use the directory name as project name.
Install sbt to create new sbt projects.
To install sbt for your development environment:
Follow the instructions at scala-sbt.org.
From your terminal, verify you can use sbt:
sbt --version
The output is similar to:
[warn] Project loading failed: (r)etry, (q)uit, (l)ast, or (i)gnore? (default: r)
sbt script version: 1.9.8
Open your terminal and create a directory to store the project.
From the new directory, initialize a new project:
sbt new scala/scala-seed.g8
The output is:
Minimum Scala build.
name [My Something Project]: hello
Template applied in ./hello
Enter a project name or press <kbd>Enter</kbd> to use the directory name as project name.
Open the build.sbt file and edit it as described in the sbt documentation to publish your project to the package registry.
Install Node.js and npm in your local development environment by following the instructions at npmjs.com.
When installation is complete, verify you can use npm in your terminal by running:
npm --version
The npm version is shown in the output:
6.10.3
Create an empty directory.
Go to the directory and initialize an empty package by running:
npm init
Enter responses to the questions. Ensure the package name follows the naming convention and is scoped to the project or group where the registry exists.
As an alternative to npm, you can install Yarn in your local environment by following the instructions at classic.yarnpkg.com.
When installation is complete, verify you can use Yarn in your terminal by running:
yarn --version
The Yarn version is shown in the output:
1.19.1
Create an empty directory.
Go to the directory and initialize an empty package by running:
yarn init
Enter responses to the questions. Ensure the package name follows the naming convention and is scoped to the project or group where the registry exists.
A package.json file is created.
Follow the instructions from Microsoft to install NuGet. If you have Visual Studio, NuGet is probably already installed.
Verify that the NuGet CLI is installed by running:
nuget help
The output should be similar to:
NuGet Version: 5.1.0.6013
usage: NuGet <command> [args] [options]
Type 'NuGet help <command>' for help on a specific command.
Available commands:
[output truncated]
Install a recent version of pip and twine.
Create a test project.
Open your terminal.
Create a directory called MyPyPiPackage, and then go to that directory:
mkdir MyPyPiPackage && cd MyPyPiPackage
Create another directory and go to it:
mkdir mypypipackage && cd mypypipackage
Create the required files in this directory:
touch __init__.py
touch greet.py
Open the greet.py file, and then add:
def SayHello():
print("Hello from MyPyPiPackage")
return
Open the __init__.py file, and then add:
from .greet import SayHello
To test the code, in your MyPyPiPackage directory, start the Python prompt.
python
Run this command:
>>> from mypypipackage import SayHello
>>> SayHello()
A message indicates that the project was set up successfully:
Python 3.8.2 (v3.8.2:7b3ab5921f, Feb 24 2020, 17:52:18)
[Clang 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> from mypypipackage import SayHello
>>> SayHello()
Hello from MyPyPiPackage
After you create a project, you can create a package.
In your terminal, go to the MyPyPiPackage directory.
Create a pyproject.toml file:
touch pyproject.toml
This file contains all the information about the package. For more information
about this file, see creating pyproject.toml.
Because GitLab identifies packages based on
Python normalized names (PEP-503),
ensure your package name meets these requirements. See the installation section
for details.
Open the pyproject.toml file, and then add basic information:
[build-system]
requires = ["setuptools>=61.0"]
build-backend = "setuptools.build_meta"
[project]
name = "mypypipackage"
version = "0.0.1"
authors = [
{ name="Example Author", email="[email protected]" },
]
description = "A small example package"
requires-python = ">=3.7"
classifiers = [
"Programming Language :: Python :: 3",
"Operating System :: OS Independent",
]
[tool.setuptools.packages]
find = {}
Save the file.
Install the package build library:
pip install build
Build the package:
python -m build
The output should be visible in a newly-created dist folder:
ls dist
The output should appear similar to the following:
mypypipackage-0.0.1-py3-none-any.whl mypypipackage-0.0.1.tar.gz
The package is now ready to be published to the package registry.