pax_global_header00006660000000000000000000000064142534506660014525gustar00rootroot0000000000000052 comment=cc1b22283656282d3518c176dd419eaa6cfce548 rebar3-3.19.0/000077500000000000000000000000001425345066600127755ustar00rootroot00000000000000rebar3-3.19.0/.dockerignore000066400000000000000000000001011425345066600154410ustar00rootroot00000000000000.DS_Store .gitignore _build _checkouts Dockerfile .dockerignore rebar3-3.19.0/.editorconfig000066400000000000000000000004631425345066600154550ustar00rootroot00000000000000# EditorConfig file: http://EditorConfig.org # Top-most EditorConfig file. root = true # Unix-style, newlines, indent style of 4 spaces, with a newline ending every file. [*] end_of_line = lf insert_final_newline = true charset = utf-8 trim_trailing_whitespace = true indent_style = space indent_size = 4 rebar3-3.19.0/.github/000077500000000000000000000000001425345066600143355ustar00rootroot00000000000000rebar3-3.19.0/.github/ISSUE_TEMPLATE.md000066400000000000000000000022201425345066600170360ustar00rootroot00000000000000### Pre-Check ### - If you are filing for a bug, please do a quick search in current issues first - For bugs, mention if you are willing or interested in helping fix the issue - For questions or support, it helps to include context around your project or problem - Think of a descriptive title (more descriptive than 'feature X is broken' unless it is fully broken) ### Environment ### - Add the result of `rebar3 report` to your message: ``` $ rebar3 report "my failing command" ... ``` - Verify whether the version of rebar3 you're running is the latest release (see https://github.com/erlang/rebar3/releases) - If possible, include information about your project and its structure. Open source projects or examples are always easier to debug. If you can provide an example code base to reproduce the issue on, we will generally be able to provide more help, and faster. ### Current behaviour ### Describe the current behaviour. In case of a failure, crash, or exception, please include the result of running the command with debug information: ``` DEBUG=1 rebar3 ``` ### Expected behaviour ### Describe what you expected to happen. rebar3-3.19.0/.github/workflows/000077500000000000000000000000001425345066600163725ustar00rootroot00000000000000rebar3-3.19.0/.github/workflows/main.yml000066400000000000000000000025051425345066600200430ustar00rootroot00000000000000name: Common Test on: pull_request: branches: - 'main' push: branches: - 'main' jobs: linux: name: Test on OTP ${{ matrix.otp_version }} and ${{ matrix.os }} runs-on: ${{ matrix.os }} strategy: matrix: otp_version: [23, 24, 25] os: [ubuntu-latest] container: image: erlang:${{ matrix.otp_version }} env: LATEST_OTP_RELEASE: 25 steps: - uses: actions/checkout@v2 - name: Compile run: ./bootstrap - name: CT tests run: ./rebar3 ct - shell: bash name: Dialyzer run: | [[ "${{ matrix.otp_version }}" != "${{ env.LATEST_OTP_RELEASE }}" ]] || (./rebar3 clean -a && ./rebar3 as dialyzer dialyzer) macos: name: Test on MacOS runs-on: macos-latest steps: - uses: actions/checkout@v2 - name: Brew Version Check run: brew --version - name: Keep Brew Fresh run: brew update - name: Install Erlang run: brew install erlang - name: Compile run: ./bootstrap - name: CT tests run: ./rebar3 ct windows: name: Test on Windows runs-on: windows-latest steps: - uses: actions/checkout@v2 - name: Install Erlang run: choco install erlang - name: Compile run: .\bootstrap.ps1 - name: CT tests run: .\rebar3.ps1 ct rebar3-3.19.0/.github/workflows/nightly.yml000066400000000000000000000013201425345066600205670ustar00rootroot00000000000000name: Nightly on: push: branches: - 'main' jobs: build: name: Publish escript for every merge to main runs-on: ubuntu-18.04 steps: - uses: actions/checkout@v2 - uses: erlef/setup-beam@v1 with: otp-version: '23.3.4.14' - name: Compile run: ./bootstrap - name: CT tests run: ./rebar3 ct - name: Configure AWS credentials uses: aws-actions/configure-aws-credentials@v1 with: aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }} aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }} aws-region: us-east-1 - name: Copy rebar3 escript to S3 run: | aws s3 cp ./rebar3 s3://rebar3-nightly rebar3-3.19.0/.github/workflows/publish.yml000066400000000000000000000026551425345066600205730ustar00rootroot00000000000000name: Publish on: push: tags: - '*' jobs: build: name: Create release and publish escript for every new tag runs-on: ubuntu-18.04 steps: - uses: actions/checkout@v2 - uses: erlef/setup-beam@v1 with: otp-version: '23.3.4.14' - name: Compile run: ./bootstrap - name: CT tests run: ./rebar3 ct - name: Create Release id: create_release uses: actions/create-release@v1 env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} with: tag_name: ${{ github.ref }} release_name: ${{ github.ref }} draft: false prerelease: false - name: Upload Release Asset id: upload-release-asset uses: actions/upload-release-asset@v1 env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} with: upload_url: ${{ steps.create_release.outputs.upload_url }} asset_path: ./rebar3 asset_name: rebar3 asset_content_type: application/octet-stream - name: Configure AWS credentials if: "!github.event.release.prerelease" uses: aws-actions/configure-aws-credentials@v1 with: aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }} aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }} aws-region: us-east-1 - name: Copy rebar3 escript to S3 if: "!github.event.release.prerelease" run: | aws s3 cp ./rebar3 s3://rebar3 rebar3-3.19.0/.github/workflows/shelltests.yml000066400000000000000000000013721425345066600213120ustar00rootroot00000000000000name: Shell tests on: pull_request: branches: - 'main' push: branches: - 'main' jobs: shelltests: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - uses: erlef/setup-beam@v1 with: otp-version: '25.0' elixir-version: '1.13' - name: Compile run: ./bootstrap - name: Install run: | sudo cp ./rebar3 /usr/local/bin/ - name: Checkout shell tests run: git clone https://github.com/tsloughter/rebar3_tests - name: Install and run shelltestrunner run: | sudo apt-get update sudo apt-get install -y shelltestrunner build-essential cmake liblz4-dev cd rebar3_tests mix local.hex --force ./run_tests.sh rebar3-3.19.0/.gitignore000066400000000000000000000004221425345066600147630ustar00rootroot00000000000000_checkouts .rebar3 rebar3 rebar3.cmd rebar3.ps1 _build .depsolver_plt *.beam test/*_data logs /rebar *~ *.orig .*.swp /rt.work /dialyzer_warnings /rebar.cmd /.eunit /deps /.rebar priv/templates/*.dtl.erl ebin .edts env # hex_core artifact src/vendored/r3_safe_erl_term.erl rebar3-3.19.0/CONTRIBUTING.md000066400000000000000000000307631425345066600152370ustar00rootroot00000000000000# Contributing to Rebar3 1. [License](#license) 2. [Submitting a bug](#submitting-a-bug) 3. [Requesting or implementing a feature](#requesting-or-implementing-a-feature) 4. [Project Structure](#project-structure) 5. [Tests](#tests) 6. [Submitting your changes](#submitting-your-changes) 1. [Code Style](#code-style) 2. [Committing your changes](#committing-your-changes) 3. [Pull Requests and Branching](#pull-requests-and-branching) 4. [Credit](#credit) ## License ## Rebar3 is licensed under the [Apache License 2.0](LICENSE) for all new code. However, since it is built from older code bases, some files still hold other free licenses (such as BSD). Where it is the case, the license is added in comments. All files without specific headers can safely be assumed to be under Apache 2.0. ## Submitting a Bug Bugs can be submitted to the [Github issue page](https://github.com/erlang/rebar3/issues). Rebar3 is not perfect software and will be buggy. When submitting a bug, be careful to know the following: - The Erlang version you are running - The Rebar3 version you are using - The command you were attempting to run This information can be automatically generated to put into your bug report by calling `rebar3 report "my command"`. You may be asked for further information regarding: - Your environment, including the Erlang version used to compile rebar3, details about your operating system, where your copy of Erlang was installed from, and so on; - Your project, including its structure, and possibly to remove build artifacts to start from a fresh build - What it is you are trying to do exactly; we may provide alternative means to do so. If you can provide an example code base to reproduce the issue on, we will generally be able to provide more help, and faster. All contributors and rebar3 maintainers are generally unpaid developers working on the project in their own free time with limited resources. We ask for respect and understanding and will try to provide the same back. ## Requesting or implementing a feature Before requesting or implementing a new feature, please do the following: - Take a look at our [list of plugins](https://rebar3.org/docs/configuration/plugins#recommended-plugins) to know if the feature isn't already supported by the community. - Verify in existing [tickets](https://github.com/erlang/rebar3/issues) whether the feature might already is in the works, has been moved to a plugin, or has already been rejected. If this is done, open up a ticket. Tell us what is the feature you want, why you need it, and why you think it should be in rebar3 itself. We may discuss details with you regarding the implementation, its inclusion within the project or as a plugin. Depending on the feature, we may provide full support for it, or ask you to help implement and/or commit to maintaining it in the future. We're dedicated to providing a stable build tool, and may also ask features to exist as a plugin before being included in core rebar3 -- the migration path from one to the other is fairly simple and little to no code needs rewriting. ## Project Structure Rebar3 is an escript built around the concept of providers. Providers are the modules that do the work to fulfill a user's command. They are documented in [the official documentation website](http://www.rebar3.org/docs/plugins#section-provider-interface). Example provider: ```erlang -module(rebar_prv_something). -behaviour(rebar_provider). -export([init/1, do/1, format_error/1]). -define(PROVIDER, something). -define(DEPS, []). %% =================================================================== %% Public API %% =================================================================== -spec init(rebar_state:state()) -> {ok, rebar_state:state()}. init(State) -> State1 = rebar_state:add_provider(State, rebar_provider:create([ {name, ?PROVIDER}, {module, ?MODULE}, {bare, true}, {deps, ?DEPS}, {example, "rebar dummy"}, {short_desc, "dummy plugin."}, {desc, ""}, {opts, []} ])), {ok, State1}. -spec do(rebar_state:state()) -> {ok, rebar_state:state()}. do(State) -> %% Do something {ok, State}. -spec format_error(any()) -> iolist(). format_error(Reason) -> io_lib:format("~p", [Reason]). ``` Providers are then listed in `rebar.app.src`, and can be called from the command line or as a programmatical API. All commands are therefore implemented in standalone modules. If you call `rebar3 `, the module in charge of it is likely located in `src/rebar_prv_.erl`. Templates are included in `priv/templates/` The official test suite is Common Test, and tests are located in `test/`. Useful modules include: - `rebar_api`, providing an interface for plugins to call into core rebar3 functionality - `rebar_core`, for initial boot and setup of a project - `rebar_config`, handling the configuration of each project. - `rebar_app_info`, giving access to the metadata of a specific OTP application in a project. - `rebar_base_compiler`, giving a uniform interface to compile `.erl` files. - `rebar_dir` for directory handling and management - `rebar_file_util` for cross-platform file handling - `rebar_state`, the glue holding together a specific build or task run; includes canonical versions of the configuration, profiles, applications, dependencies, and so on. - `rebar_utils` for generic tasks and functionality required across multiple providers or modules. ## Tests Rebar3 tries to have as many of its features tested as possible. Everything that a user can do and should be repeatable in any way should be tested. Tests are written using the Common Test framework. Tests for rebar3 can be run by calling: ```bash $ rebar3 escriptize # or bootstrap $ ./rebar3 ct ``` Most tests are named according to their module name followed by the `_SUITE` suffix. Providers are made shorter, such that `rebar_prv_new` is tested in `rebar_new_SUITE`. Most tests in the test suite will rely on calling Rebar3 in its API form, then investigating the build output. Because most tests have similar requirements, the `test/rebar_test_utils` file contains common code to set up test projects, run tasks, and verify artifacts at once. A basic example can look like: ```erlang -module(rebar_some_SUITE). -compile(export_all). -include_lib("common_test/include/ct.hrl"). -include_lib("eunit/include/eunit.hrl"). all() -> [checks_success, checks_failure]. init_per_testcase(Case, Config0) -> %% Create a project directory in the test run's priv_dir Config = rebar_test_utils:init_rebar_state(Config0), %% Create toy applications AppDir = ?config(apps, Config), Name = rebar_test_utils:create_random_name("app1_"++atom_to_list(Case)), Vsn = rebar_test_utils:create_random_vsn(), rebar_test_utils:create_app(AppDir, Name, Vsn, [kernel, stdlib]), %% Add the data to the test config [{name, Name} | Config]. end_per_testcase(_, Config) -> Config. checks_success(Config) -> %% Validates that the application in `name' is successfully compiled Name = ?config(name, Config), rebar_test_utils:run_and_check(Config, [], ["compile"], {ok, [{app, Name}]}). checks_failure(Config) -> %% Checks that a result fails Command = ["fakecommand", "fake-arg"], rebar_test_utils:run_and_check( Config, [], Command, {error, io_lib:format("Command ~p not found", [fakecommand])} ). ``` The general interface to `rebar_test_utils:run_and_check` is `run_and_check(CTConfig, RebarConfig, Command, Expect)` where `Expect` can be any of: ```erlang {ok, OKRes} {ok, OKRes, ProfilesUsed} {error, Reason} % where: ProfilesUsed :: string() % matching the profiles to validate (defaults to "*") OKRes :: {app, Name} % name of an app that is in the build directory | {app, Name, valid} % name of an app that is in the build directory and compiled properly | {app, Name, invalid} % name of an app that didn't compile properly | {dep, Name} % name of a dependency in the build directory | {dep, Name, Vsn} % name of a dependency in the build directory with a specific version | {dep_not_exist, Name} % name of a dependency missing from the build directory | {checkout, Name} % name of an app that is a checkout dependency | {plugin, Name} % name of a plugin in the build directory | {plugin, Name, Vsn} % name of a plugin in the build directory with a specific version | {global_plugin, Name} % name of a global plugin in the build directory | {global_plugin, Name, Vsn} % name of a global plugin in the build directory with a specific version | {lock, Name} % name of a locked dependency | {lock, Name, Vsn} % name of a locked dependency of a specific version | {lock, pkg, Name, Vsn}% name of a locked package of a specific version | {lock, src, Name, Vsn}% name of a locked source dependency of a specific version | {release, Name, Vsn, ExpectedDevMode} % validates a release | {tar, Name, Vsn} % validates a tarball's existence | {file, Filename} % validates the presence of a given file | {dir, Dirname} % validates the presence of a given directory Reason :: term() % the exception thrown by rebar3 ``` This generally lets most features be tested fine. Ask for help if you cannot figure out how to write tests for your feature or patch. ## Submitting your changes While we're not too formal when it comes to pull requests to the project, we do appreciate users taking the time to conform to the guidelines that follow. We do expect all pull requests submitted to come with [tests](#tests) before they are merged. If you cannot figure out how to write your tests properly, ask in the pull request for guidance. ### Code Style * Do not introduce trailing whitespace * Indentation is 4 spaces wide, no tabs. * Try not to introduce lines longer than 80 characters * Write small functions whenever possible, and use descriptive names for functions and variables. * Avoid having too many clauses containing clauses containing clauses. Basically, avoid deeply nested `case ... of` or `try ... catch` expressions. Break them out into functions if possible. * Comment tricky or non-obvious decisions made to explain their rationale. ### Committing your changes It helps if your commits are structured as follows: - Fixing a bug is one commit. - Adding a feature is one commit. - Adding two features is two commits. - Two unrelated changes is two commits (and likely two Pull requests) If you fix a (buggy) commit, squash (`git rebase -i`) the changes as a fixup commit into the original commit, unless the patch was following a maintainer's code review. In such cases, it helps to have separate commits. The reviewer may ask you to later squash the commits together to provide a clean commit history before merging in the feature. It's important to write a proper commit title and description. The commit title should be no more than 50 characters; it is the first line of the commit text. The second line of the commit text must be left blank. The third line and beyond is the commit message. You should write a commit message. If you do, wrap all lines at 72 characters. You should explain what the commit does, what references you used, and any other information that helps understanding your changes. ### Pull Requests and Branching All fixes to rebar end up requiring a +1 from one or more of the project's maintainers. When opening a pull request, explain what the patch is doing and if it makes sense, why the proposed implementation was chosen. Try to use well-defined commits (one feature per commit) so that reading them and testing them is easier for reviewers and while bisecting the code base for issues. During the review process, you may be asked to correct or edit a few things before a final rebase to merge things. Do send edits as individual commits to allow for gradual and partial reviews to be done by reviewers. Once the +1s are given, rebasing is appreciated but not mandatory. Please work in feature branches, and do not commit to `main` in your fork. Provide a clean branch without merge commits. If you can, pick a descriptive title for your pull request. When we generate changelogs before cutting a release, a script uses the pull request names to populate the entries. ### Credit To give everyone proper credit in addition to the git history, please feel free to append your name to `THANKS` in your first contribution. rebar3-3.19.0/Dockerfile000066400000000000000000000030131425345066600147640ustar00rootroot00000000000000# https://docs.docker.com/engine/reference/builder/#from # "The FROM instruction initializes a new build stage and sets the # Base Image for subsequent instructions." FROM erlang:20.3.8.1-alpine as builder # https://docs.docker.com/engine/reference/builder/#label # "The LABEL instruction adds metadata to an image." LABEL stage=builder # Install git for fetching non-hex dependencies. Also allows rebar3 # to find it's own git version. # Add any other Alpine libraries needed to compile the project here. # See https://wiki.alpinelinux.org/wiki/Local_APK_cache for details # on the local cache and need for the symlink RUN ln -s /var/cache/apk /etc/apk/cache && \ apk update && \ apk add --update openssh-client git # WORKDIR is located in the image # https://docs.docker.com/engine/reference/builder/#workdir WORKDIR /root/rebar3 # copy the entire src over and build COPY . . RUN ./bootstrap # this is the final runner layer, notice how it diverges from the original erlang # alpine layer, this means this layer won't have any of the other stuff that was # generated previously (deps, build, etc) FROM erlang:20.3.8.1-alpine as runner # copy the generated `rebar3` binary over here COPY --from=builder /root/rebar3/_build/prod/bin/rebar3 . # and install it RUN HOME=/opt ./rebar3 local install \ && rm -f /usr/local/bin/rebar3 \ && ln /opt/.cache/rebar3/bin/rebar3 /usr/local/bin/rebar3 \ && rm -rf rebar3 # simply print out the version for visibility ENTRYPOINT ["/usr/local/bin/rebar3"] CMD ["--version"] rebar3-3.19.0/LICENSE000066400000000000000000000236771425345066600140210ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS rebar3-3.19.0/README.md000066400000000000000000000243011425345066600142540ustar00rootroot00000000000000# Rebar3 [![Build Status](https://github.com/erlang/rebar3/workflows/Common%20Test/badge.svg)](https://github.com/erlang/rebar3/actions?query=branch%3Amaster+workflow%3A"Common+Test") [![Erlang Versions](https://img.shields.io/badge/Supported%20Erlang%2FOTP-23.0%20to%2025.0-blue)](http://www.erlang.org) 1. [What is Rebar3?](#what-is-rebar3) 2. [Why Rebar3?](#why-rebar3) 3. [Should I Use Rebar3?](#should-i-use-rebar3) 4. [Getting Started](#getting-started) 5. [Documentation](#documentation) 6. [Features](#features) 7. [Migrating from rebar2](#migrating-from-rebar2) 8. [Additional Resources](#additional-resources) ## What is Rebar3 Rebar3 is an Erlang tool that makes it easy to create, develop, and release Erlang libraries, applications, and systems in a repeatable manner. Rebar3 will: - respect and enforce standard Erlang/OTP conventions for project structure so they are easily reusable by the community; - manage source dependencies and Erlang [packages](https://hex.pm) while ensuring repeatable builds; - handle build artifacts, paths, and libraries such that standard development tools can be used without a headache; - adapt to projects of all sizes on almost any platform; - treat [documentation](https://rebar3.org/docs/) as a feature, and errors or lack of documentation as a bug. Rebar3 is also a self-contained Erlang script. It is easy to distribute or embed directly in a project. Tasks or behaviours can be modified or expanded with a [plugin system](https://rebar3.org/docs/configuration/plugins) [flexible enough](https://github.com/lfe-rebar3/rebar3_lfe) that even other languages on the Erlang VM will use it as a build tool. ## Why Rebar3 Rebar3 is the spiritual successor to [rebar 2.x](https://github.com/rebar/rebar), which was the first usable build tool for Erlang that ended up seeing widespread community adoption. It however had several shortcomings that made it difficult to use with larger projects or with teams with users new to Erlang. Rebar3 was our attempt at improving over the legacy of Rebar 2.x, providing the features we felt it was missing, and to provide a better environment in which newcomers joining our teams could develop. ## Should I use Rebar3? If your main language for your system is Erlang, that you value repeatable builds and want your various tools to integrate together, we do believe Rebar3 is the best experience you can get. ## Getting Started A [getting started guide is maintained on the official documentation website](https://rebar3.org/docs/getting-started), but installing rebar3 can be done by any of the ways described below Latest stable compiled version: ```bash $ wget https://s3.amazonaws.com/rebar3/rebar3 && chmod +x rebar3 ``` From Source (assuming you have a full Erlang install): ```bash $ git clone https://github.com/erlang/rebar3.git $ cd rebar3 $ ./bootstrap ``` Stable versions can also be obtained from the [releases page](https://github.com/erlang/rebar3/releases). The rebar3 escript can also extract itself with a run script under the user's home directory: ```bash $ ./rebar3 local install ===> Extracting rebar3 libs to ~/.cache/rebar3/lib... ===> Writing rebar3 run script ~/.cache/rebar3/bin/rebar3... ===> Add to $PATH for use: export PATH=~/.cache/rebar3/bin:$PATH ``` To keep it up to date after you've installed rebar3 this way you can use `rebar3 local upgrade` which fetches the latest stable release and extracts to the same place as above. A [nightly version can also be obtained](https://s3.amazonaws.com/rebar3-nightly/rebar3) if desired. Rebar3 may also be available on various OS-specific package managers such as FreeBSD Ports. Those are maintained by the community and Rebar3 maintainers themselves are generally not involved in that process. If you do not have a full Erlang install, we recommend using [erln8](https://erln8.github.io/erln8/) or [kerl](https://github.com/yrashk/kerl). For binary packages, use those provided by [Erlang Solutions](https://www.erlang-solutions.com/resources/download.html), but be sure to choose the "Standard" download option or you'll have issues building projects. Do note that if you are planning to work with multiple Erlang versions on the same machine, you will want to build Rebar3 with the oldest one of them. The 3 newest major Erlang releases are supported at any given time: if the newest version is OTP-24, building with versions as old as OTP-22 will be supported, and produce an executable that will work with those that follow. ## Documentation Rebar3 documentation is maintained on [https://rebar3.org/docs](https://rebar3.org/docs) ## Features Rebar3 supports the following features or tools by default, and may provide many others via the plugin ecosystem: | features | Description | |--------------------- |------------ | | Command composition | Rebar3 allows multiple commands to be run in sequence by calling `rebar3 do ,,...,`. | | Command dependencies | Rebar3 commands know their own dependencies. If a test run needs to fetch dependencies and build them, it will do so. | | Command namespaces | Allows multiple tools or commands to share the same name. | | Compiling | Build the project, including fetching all of its dependencies by calling `rebar3 compile` | | Clean up artifacts | Remove the compiled beam files from a project with `rebar3 clean` or just remove the `_build` directory to remove *all* compilation artifacts | | Code Coverage | Various commands can be instrumented to accumulate code coverage data (such as `eunit` or `ct`). Reports can be generated with `rebar3 cover` | | Common Test | The test framework can be run by calling `rebar3 ct` | | Dependencies | Rebar3 maintains local copies of dependencies on a per-project basis. They are fetched deterministically, can be locked, upgraded, fetched from source, packages, or from local directories. See [Dependencies on the documentation website](https://rebar3.org/docs/configuration/dependencies/). Call `rebar3 tree` to show the whole dependency tree. | | Documentation | Print help for rebar3 itself (`rebar3 help`) or for a specific task (`rebar3 help `). Full reference at [rebar3.org](https://rebar3.org/docs). | | Dialyzer | Run the Dialyzer analyzer on the project with `rebar3 dialyzer`. Base PLTs for each version of the language will be cached and reused for faster analysis | | Edoc | Generate documentation using edoc with `rebar3 edoc` | | Escript generation | Rebar3 can be used to generate [escripts](http://www.erlang.org/doc/man/escript.html) providing an easy way to run all your applications on a system where Erlang is installed | | Eunit | The test framework can be run by calling `rebar3 eunit` | | Locked dependencies | Dependencies are going to be automatically locked to ensure repeatable builds. Versions can be changed with `rebar3 upgrade` or `rebar3 upgrade `, or locks can be released altogether with `rebar3 unlock`. | | Packages | A given [Hex package](https://hex.pm) can be inspected `rebar3 pkgs `. This will output its description and available versions | | Path | While paths are managed automatically, you can print paths to the current build directories with `rebar3 path`. | | Plugins | Rebar3 can be fully extended with [plugins](https://rebar3.org/docs/configuration/plugins/). List or upgrade plugins by using the plugin namespace (`rebar3 plugins`). | | Profiles | Rebar3 can have subconfiguration options for different profiles, such as `test` or `prod`. These allow specific dependencies or compile options to be used in specific contexts. See [Profiles](https://rebar3.org/docs/configuration/profiles) in the docs. | | Releases | Rebar3 supports [building releases](https://rebar3.org/docs/deployment/releases) with the `relx` tool, providing a way to ship fully self-contained Erlang systems. Release update scripts for live code updates can also be generated. | | Shell | A full shell with your applications available can be started with `rebar3 shell`. From there, call tasks as `r3:do(compile)` to automatically recompile and reload the code without interruption | | Tarballs | Releases can be packaged into tarballs ready to be deployed. | | Templates | Configurable templates ship out of the box (try `rebar3 new` for a list or `rebar3 new help